PineScript Crypto Trading Strategy Analyzer
An expert assistant for developing and optimizing cryptocurrency trading strategies using TradingView Pine Script and Python backtesting frameworks.
What This Skill Does
This skill provides comprehensive support for a cryptocurrency trading strategy repository that combines Pine Script strategies with Python backtesting tools. It understands pullback-based trading strategies optimized for prop firm requirements (max 10% drawdown, consistent profitability) and can help with development, optimization, and analysis of trading systems.
Step-by-Step Instructions
1. Repository Structure Understanding
When working with this codebase, recognize these key directories:
`nakinvest/*.pine` - Pine Script v5 strategies for TradingView`nakinvest/backtest/` - Python backtesting framework`nakinvest/module2/` - Pine Script utilities`nakinvest/volatility-strategy/` - Volatility-based strategies2. Pine Script Development
When editing or creating Pine Script files:
Use Pine Script v5 syntaxMain strategies include: EMA Pullback, Prop Firm, RSI Divergence, Cross EMA, ZLSMA ChandelierTo test changes: 1. Edit the `.pine` file locally
2. Copy contents to TradingView Pine Editor
3. Apply to chart and run Strategy Tester
Follow naming convention: Use `*-optimized.pine` for optimized strategies3. Python Backtesting Setup
Before running backtests, ensure dependencies are installed:
```bash
Install TA-Lib (required dependency)
macOS:
brew install ta-lib
Ubuntu/Debian:
sudo apt-get install ta-lib
Install Python dependencies
cd nakinvest/backtest
pip install -r requirements.txt
```
4. Running Backtests
Execute backtests using these commands:
```bash
cd nakinvest/backtest
Basic backtest
python run_backtest.py
Run optimization (grid search)
python run_optimization.py
Test across multiple cryptocurrencies
python test_all_coins.py
Download market data
python download_all_data.py
```
5. Understanding Strategy Logic Flow
When analyzing or modifying strategies, follow this flow:
1. **Data Fetching**: `CryptoDataFetcher` retrieves OHLCV data from Binance/Yahoo/CSV
2. **Indicator Calculation**: Calculate EMAs, RSI, volume using TA-Lib
3. **Signal Generation**: Multi-confluence checks:
- Higher timeframe trend (HTF MA)
- Pullback depth and proximity to support/resistance
- RSI divergence or extreme levels
- Volume confirmation
- MA distance filter
4. **Risk Management**: Calculate stop loss and take profit
5. **Backtesting**: Simulate trades, track equity, calculate metrics
6. Configuration Management
The Python backtester uses hierarchical configuration:
Edit `config.yaml` for main parametersOverride programmatically via `strategy_config` dictDefault values in `PropFirmStrategy.__init__`Key configuration areas:
Position sizing (default: 2% equity)Stop loss (default: 1%)Take profit (default: 1%)Max drawdown (default: 10% - prop firm requirement)Commission (default: 0.045%)Slippage (default: 0.01%)7. Pine Script to Python Translation
When translating strategies between Pine Script and Python:
| Pine Script | Python |
|-------------|--------|
| `ta.ema()` | `talib.EMA()` |
| `ta.rsi()` | `talib.RSI()` |
| `close[1]` | `df['close'].iloc[idx-1]` |
| `strategy.entry()` | Position tracking + trade recording |
Ensure risk parameters remain identical between implementations.
8. Data Sources
Configure data sources via `data_source` parameter:
`binance` (preferred for crypto): Use CCXT, symbols like `BTC/USDT`, `ETH/USDT``yahoo`: Alternative source via yfinance, symbols like `BTC-USD`, `ETH-USD``csv`: Custom data filesMarket data is cached in `market_data/` as JSON files.
9. Optimization Workflows
For strategy optimization:
Use `optimize_strategy.py` or `run_optimization.py` for grid searchUse `advanced_optimizer.py` for multi-metric optimizationUse `real_data_optimizer.py` for real market dataResults saved as timestamped JSON/TXT filesUse narrow parameter ranges for faster results10. Output Analysis
After backtests, analyze these outputs:
`backtest_report.html` - Interactive HTML with metrics and trade history`backtest_chart.png` - Equity curve, drawdown, P&L distribution`backtest.log` - Detailed execution logs`*_RESULTS_*.json` - Machine-readable results11. Prop Firm Requirements Validation
Ensure strategies meet prop firm requirements:
Max drawdown: 10%Max daily drawdown: 5%Consistent profitabilityRisk management: 2% position size, 1% stop lossCheck these metrics in backtest reports and optimization results.
12. Performance Considerations
Market data is cached - reuse cached data when possibleOptimization can be slow - limit parameter rangesBacktest engine uses vectorial processing where possibleCommission and slippage are applied to all tradesCore Files Reference
**Python Backtesting:**
`prop_firm_strategy.py` - Main strategy with multi-confluence entry system`run_backtest.py` - Backtest runner with reporting`data_fetcher.py` - Market data fetcher (Binance/Yahoo/CSV)`config.yaml` - Strategy configuration**Optimization:**
`optimize_strategy.py`, `run_optimization.py` - Grid search`advanced_optimizer.py` - Multi-metric optimization`real_data_optimizer.py` - Real market data optimization**Pine Script:**
`ema20-pullback.pine` - Core pullback strategy`prop-firm-strategy.pine`, `prop-firm-optimized.pine` - Prop firm optimized`rsi-divergences.pine`, `rsi-divergence-pro.pine` - Divergence systems`cross-ema.pine`, `cross-ema-rsi.pine` - EMA crossover strategiesImportant Notes
Always ensure TA-Lib is installed before running Python backtestsPine Script files must be tested in TradingView - they cannot run locallyKeep risk parameters aligned between Pine Script and Python implementationsProp firm drawdown limits are strictly enforced in backtestsMarket data caching improves performance - delete cache to refresh dataUse version control when experimenting with strategy parameters