class MyStrategy {
    // Define public variables (user-configurable)
    public fastPeriod: number = 10;     // Public - users can modify
    public slowPeriod: number = 20;     // Public - users can modify
    
    // Define private variables (internal use only)
    private _position: any = null;    // Private - users cannot modify
    private _lastSignal: string | null = null;  // Private - internal state

    __init__(): void {
        // Called once when strategy starts
        // Initialize indicators, reset state, etc.
    }

    __tick__(): any {
        // Called for every new data point/tick
        // Main strategy logic goes here
        // Return results for plotting/execution
    }

    __shutdown__(): void {
        // Called when strategy is stopped
        // Cleanup resources, close positions, etc.
    }
}

Copy

// Calculate 20-period SMA
private sma20: number[] = bdpo.sma(data.close, 20);
private currentSMA: number = this.sma20[this.sma20.length - 1];

// Multiple SMAs for crossover strategy
private smaFast: number[] = bdpo.sma(data.close, 10);
private smaSlow: number[] = bdpo.sma(data.close, 20);

Copy

// MACD components using EMAs
private ema12: number[] = bdpo.ema(data.close, 12);
private ema26: number[] = bdpo.ema(data.close, 26);

// Check for bullish crossover
if (this.ema12[this.ema12.length - 1] > this.ema26[this.ema26.length - 1]) {
    // Fast EMA above slow EMA - bullish signal
}

Copy

private wma20: number[] = bdpo.wma(data.close, 20);
private currentWMA: number = this.wma20[this.wma20.length - 1];

// WMA responds faster to price changes than SMA
private priceAboveWMA: boolean = data.close[data.close.length - 1] > this.currentWMA;

Copy

private dema21: number[] = bdpo.dema(data.close, 21);
private currentDEMA: number = this.dema21[this.dema21.length - 1];

// DEMA provides faster signals than regular EMA
// Good for trend following with reduced lag

Copy

private tema14: number[] = bdpo.tema(data.close, 14);
private currentTEMA: number = this.tema14[this.tema14.length - 1];

// TEMA offers the fastest response with minimal noise
// Excellent for scalping and short-term trading

Copy

private trima20: number[] = bdpo.trima(data.close, 20);
private currentTRIMA: number = this.trima20[this.trima20.length - 1];

// TRIMA is very smooth but has significant lag
// Best for identifying major trend direction

Copy

private hma21: number[] = bdpo.hma(data.close, 21);
private currentHMA: number = this.hma21[this.hma21.length - 1];

// HMA combines speed and smoothness effectively
// Popular for swing trading strategies

Copy

private kama10: number[] = bdpo.kama(data.close, 10);
private currentKAMA: number = this.kama10[this.kama10.length - 1];

// KAMA adapts: fast in trends, slow in sideways markets
// Reduces whipsaws while maintaining responsiveness

Copy

private vwma20: number[] = bdpo.vwma(data.close, data.volume, 20);
private currentVWMA: number = this.vwma20[this.vwma20.length - 1];

// VWMA gives more weight to high-volume periods
// Better reflects institutional participation

Copy

private zlema20: number[] = bdpo.zlema(data.close, 20);
private currentZLEMA: number = this.zlema20[this.zlema20.length - 1];

// ZLEMA attempts to eliminate lag completely
// Can be more volatile but very responsive

Copy

private alma: number[] = bdpo.alma(data.close, 21, 0.85, 6);
private currentALMA: number = this.alma[this.alma.length - 1];

// ALMA provides excellent balance between responsiveness and smoothness
// Highly configurable for different trading styles

Copy

private wilders14: number[] = bdpo.wilders(data.close, 14);
private currentWilders: number = this.wilders14[this.wilders14.length - 1];

// Wilder's smoothing is less aggressive than EMA
// Foundation for many classic technical indicators

Copy

private vidya14: number[] = bdpo.vidya(data.close, 14);
private currentVIDYA: number = this.vidya14[this.vidya14.length - 1];

// VIDYA adapts smoothing factor based on volatility
// Fast response in volatile markets, stable in quiet periods

Copy

// Standard RSI setup
private rsi14: number[] = bdpo.rsi(data.close, 14);
private currentRSI: number = this.rsi14[this.rsi14.length - 1];

// Trading signals
if (this.currentRSI > 70) {
    // Overbought - consider selling
} else if (this.currentRSI < 30) {
    // Oversold - consider buying
}

Copy

// Standard MACD (12,26,9)
private macdData: any = bdpo.macd(data.close, 12, 26, 9);

// Access MACD components
private macdLine: number = this.macdData.macd[this.macdData.macd.length - 1];
private signalLine: number = this.macdData.signal[this.macdData.signal.length - 1];
private histogram: number = this.macdData.histogram[this.macdData.histogram.length - 1];

// Signal detection
if (this.macdLine > this.signalLine && this.histogram > 0) {
    // Bullish signal
}

Copy

// Standard Stochastic (14,3,3)
private stochastic: any = bdpo.stoch(data.high, data.low, data.close, 14, 3, 3);
private kPercent: number = this.stochastic.k[this.stochastic.k.length - 1];
private dPercent: number = this.stochastic.d[this.stochastic.d.length - 1];

// Trading signals
if (this.kPercent > 80 && this.dPercent > 80) {
    // Overbought condition
} else if (this.kPercent < 20 && this.dPercent < 20) {
    // Oversold condition
}

Copy

private stochRSI: number[] = bdpo.stochrsi(data.close, 14);
private currentStochRSI: number = this.stochRSI[this.stochRSI.length - 1];

// StochRSI signals (0-1 scale, more sensitive than regular RSI)
if (this.currentStochRSI > 0.8) {
    // Extremely overbought
} else if (this.currentStochRSI < 0.2) {
    // Extremely oversold
}

Copy

private williamsR: number[] = bdpo.willr(data.high, data.low, data.close, 14);
private currentWillR: number = this.williamsR[this.williamsR.length - 1];

// Williams %R interpretation (inverted from typical overbought/oversold)
if (this.currentWillR > -20) {
    // Overbought (close to 0)
} else if (this.currentWillR < -80) {
    // Oversold (close to -100)
}

Copy

private cci20: number[] = bdpo.cci(data.high, data.low, data.close, 20);
private currentCCI: number = this.cci20[this.cci20.length - 1];

// CCI interpretation
if (this.currentCCI > 100) {
    // Strong uptrend, potential overbought
} else if (this.currentCCI < -100) {
    // Strong downtrend, potential oversold
}

Copy

private mfi14: number[] = bdpo.mfi(data.high, data.low, data.close, data.volume, 14);
private currentMFI: number = this.mfi14[this.mfi14.length - 1];

// MFI interpretation (similar to RSI but includes volume)
if (this.currentMFI > 80) {
    // Overbought with volume confirmation
} else if (this.currentMFI < 20) {
    // Oversold with volume confirmation
}

Copy

private awesomeOscillator: number[] = bdpo.ao(data.high, data.low);
private currentAO: number = this.awesomeOscillator[this.awesomeOscillator.length - 1];
private previousAO: number = this.awesomeOscillator[this.awesomeOscillator.length - 2];

// AO signals
if (this.currentAO > 0 && this.previousAO <= 0) {
    // Bullish momentum shift
} else if (this.currentAO < 0 && this.previousAO >= 0) {
    // Bearish momentum shift
}

Copy

private aroonValues: any = bdpo.aroon(data.high, data.low, 25);
private aroonUp: number = this.aroonValues.aroonUp[this.aroonValues.aroonUp.length - 1];
private aroonDown: number = this.aroonValues.aroonDown[this.aroonValues.aroonDown.length - 1];

// Aroon trend analysis
if (this.aroonUp > 70 && this.aroonDown < 30) {
    // Strong uptrend
} else if (this.aroonDown > 70 && this.aroonUp < 30) {
    // Strong downtrend
} else if (Math.abs(this.aroonUp - this.aroonDown) < 20) {
    // Consolidation/sideways trend
}

Copy

private aroonOsc: number[] = bdpo.aroonosc(data.high, data.low, 25);
private currentAroonOsc: number = this.aroonOsc[this.aroonOsc.length - 1];

// Aroon Oscillator signals (-100 to +100)
if (this.currentAroonOsc > 40) {
    // Strong bullish trend
} else if (this.currentAroonOsc < -40) {
    // Strong bearish trend
} else {
    // Weak trend or consolidation
}

Copy

private balanceOfPower: number[] = bdpo.bop(data.open, data.high, data.low, data.close);
private currentBOP: number = this.balanceOfPower[this.balanceOfPower.length - 1];

// BOP interpretation (-1 to +1 scale)
if (this.currentBOP > 0.5) {
    // Strong buying pressure
} else if (this.currentBOP < -0.5) {
    // Strong selling pressure
} else {
    // Balanced market
}

Copy

private cmo: number[] = bdpo.cmo(data.close, 14);
private currentCMO: number = this.cmo[this.cmo.length - 1];

// CMO signals (-100 to +100 scale)
if (this.currentCMO > 50) {
    // Overbought condition
} else if (this.currentCMO < -50) {
    // Oversold condition
}

Copy

private readonly period: number = 20;
private closePrices: number[] = bdpo.getClosePrices();
private dpo: number[] = bdpo.dpo(this.closePrices, this.period);
private currentDPO: number = this.dpo[this.dpo.length - 1];

// DPO helps identify short-term cycles
if (this.currentDPO > 0) {
    // Price above detrended level - potential sell signal
} else if (this.currentDPO < 0) {
    // Price below detrended level - potential buy signal
}

Copy

private readonly period: number = 10;
private highPrices: number[] = bdpo.getHighPrices();
private lowPrices: number[] = bdpo.getLowPrices();
private fisher: number[] = bdpo.fisher(this.highPrices, this.lowPrices, this.period);
private currentFisher: number = this.fisher[this.fisher.length - 1];

// Fisher Transform creates sharper turning points
if (this.currentFisher > 1.5) {
    // Overbought - potential reversal signal
} else if (this.currentFisher < -1.5) {
    // Oversold - potential reversal signal
}

Copy

private readonly period: number = 10;
private closePrices: number[] = bdpo.getClosePrices();
private momentum: number[] = bdpo.mom(this.closePrices, this.period);
private currentMomentum: number = this.momentum[this.momentum.length - 1];

// Momentum indicates price velocity
if (this.currentMomentum > 0) {
    // Positive momentum - upward price movement
} else if (this.currentMomentum < 0) {
    // Negative momentum - downward price movement
}

// Look for momentum divergences with price

Copy

private readonly fastPeriod: number = 12;
private readonly slowPeriod: number = 26;
private closePrices: number[] = bdpo.getClosePrices();
private ppo: number[] = bdpo.ppo(this.closePrices, this.fastPeriod, this.slowPeriod);
private currentPPO: number = this.ppo[this.ppo.length - 1];

// PPO signals similar to MACD but normalized
if (this.currentPPO > 0) {
    // Bullish momentum - fast MA above slow MA
} else if (this.currentPPO < 0) {
    // Bearish momentum - fast MA below slow MA
}

// Look for PPO crossovers and divergences

Copy

private roc12: number[] = bdpo.roc(data.close, 12);
private currentROC: number = this.roc12[this.roc12.length - 1];

// ROC interpretation (percentage)
if (this.currentROC > 10) {
    // Strong bullish momentum (10% gain in 12 periods)
} else if (this.currentROC < -10) {
    // Strong bearish momentum (10% loss in 12 periods)
}

Copy

private ultimateOsc: number[] = bdpo.ultosc(data.high, data.low, data.close, 7, 14, 28);
private currentUO: number = this.ultimateOsc[this.ultimateOsc.length - 1];

// Ultimate Oscillator signals (0-100 scale)
if (this.currentUO > 70) {
    // Overbought - potential sell signal
} else if (this.currentUO < 30) {
    // Oversold - potential buy signal
}

Copy

private bollingerBands: any = bdpo.bbands(data.close, 20, 2);
private upperBand: number = this.bollingerBands.upper[this.bollingerBands.upper.length - 1];
private lowerBand: number = this.bollingerBands.lower[this.bollingerBands.lower.length - 1];

Copy

private keltnerChannels: any = bdpo.kc(data.high, data.low, data.close, 20, 2.0);
private kcUpper: number = this.keltnerChannels.upper[this.keltnerChannels.upper.length - 1];
private kcLower: number = this.keltnerChannels.lower[this.keltnerChannels.lower.length - 1];

Copy

private donchianChannels: any = bdpo.dc(data.high, data.low, 20);
private dcUpper: number = this.donchianChannels.upper[this.donchianChannels.upper.length - 1];
private dcLower: number = this.donchianChannels.lower[this.donchianChannels.lower.length - 1];

// Breakout strategy
if (data.close[data.close.length - 1] > this.dcUpper) {
    // Price broke above upper channel - bullish breakout
}

Copy

private priceBands: any = bdpo.pbands(data.close, 20);

Copy

private onBalanceVolume: number[] = bdpo.obv(data.close, data.volume);

Copy

private vwap: number[] = bdpo.vwap(data.high, data.low, data.close, data.volume);
private currentVWAP: number = this.vwap[this.vwap.length - 1];

// Compare current price to VWAP
if (data.close[data.close.length - 1] > this.currentVWAP) {
    // Price above VWAP - bullish sentiment
}

Copy

private adLine: number[] = bdpo.ad(data.high, data.low, data.close, data.volume);
private currentAD: number = this.adLine[this.adLine.length - 1];
private previousAD: number = this.adLine[this.adLine.length - 2];

// Rising A/D line confirms uptrend
// Divergence between price and A/D suggests reversal

Copy

private cmf20: number[] = bdpo.cmf(data.high, data.low, data.close, data.volume, 20);
private currentCMF: number = this.cmf20[this.cmf20.length - 1];

// CMF above 0.1 = buying pressure
// CMF below -0.1 = selling pressure

Copy

private emv14: number[] = bdpo.emv(data.high, data.low, data.volume, 14);
private currentEMV: number = this.emv14[this.emv14.length - 1];

// Positive EMV = price rising on low volume (easy movement)
// Negative EMV = price falling or high volume required

Copy

private forceIndex: number[] = bdpo.fi(data.close, data.volume, 13);
private currentFI: number = this.forceIndex[this.forceIndex.length - 1];

// Rising FI confirms uptrend with volume
// Falling FI confirms downtrend with volume

Copy

private kvo: number[] = bdpo.kvo(data.high, data.low, data.close, data.volume, 34, 55);
private currentKVO: number = this.kvo[this.kvo.length - 1];

// KVO crossover above zero = bullish volume momentum
// KVO crossover below zero = bearish volume momentum

Copy

private negativeVolumeIndex: number[] = bdpo.nvi(data.close, data.volume);
private currentNVI: number = this.negativeVolumeIndex[this.negativeVolumeIndex.length - 1];

// NVI tracks uninformed traders (retail) activity
// Rising NVI during low volume suggests retail accumulation

Copy

private positiveVolumeIndex: number[] = bdpo.pvi(data.close, data.volume);
private currentPVI: number = this.positiveVolumeIndex[this.positiveVolumeIndex.length - 1];

// PVI tracks smart money (institutional) activity
// Rising PVI suggests institutions are accumulating

Copy

private atr14: number[] = bdpo.atr(data.high, data.low, data.close, 14);

Copy

// NATR gives volatility as percentage (0-100)
private natr14: number[] = bdpo.natr(data.high, data.low, data.close, 14);
private currentVolatility: number = this.natr14[this.natr14.length - 1];

// Use for position sizing based on volatility
if (this.currentVolatility > 5) {
    // High volatility - reduce position size
    const volatilityAdjustedSize = baseSize * (5 / this.currentVolatility);
}

Copy

private trueRange: number[] = bdpo.tr(data.high, data.low, data.close);
private currentTR: number = this.trueRange[this.trueRange.length - 1];

Copy

private chaikinVol: number[] = bdpo.cvi(data.high, data.low, 10);

Copy

private historicalVol: number[] = bdpo.volatility(data.close, 20);
private currentVol: number = this.historicalVol[this.historicalVol.length - 1];

Copy

private vhf28: number[] = bdpo.vhf(data.close, 28);
private currentVHF: number = this.vhf28[this.vhf28.length - 1];

// VHF > 0.35 typically indicates trending market
// VHF < 0.25 typically indicates trading/sideways market
if (this.currentVHF > 0.35) {
    // Use trend-following strategy
} else if (this.currentVHF < 0.25) {
    // Use mean-reversion strategy
}

Copy

private apo: number[] = bdpo.apo(data.close, 12, 26);

Copy

private dx14: number[] = bdpo.dx(data.high, data.low, data.close, 14);

Copy

private diValues: any = bdpo.di(data.high, data.low, data.close, 14);
private plusDI: number = this.diValues.plus[this.diValues.plus.length - 1];
private minusDI: number = this.diValues.minus[this.diValues.minus.length - 1];

// DI crossover signals
if (this.plusDI > this.minusDI) {
    // Bullish trend - +DI above -DI
} else if (this.minusDI > this.plusDI) {
    // Bearish trend - -DI above +DI
}

Copy

private dmValues: any = bdpo.dm(data.high, data.low, 14);
private plusDM: number = this.dmValues.plus[this.dmValues.plus.length - 1];
private minusDM: number = this.dmValues.minus[this.dmValues.minus.length - 1];

// DM analysis for trend direction
private dmRatio: number = this.plusDM / this.minusDM;
if (this.dmRatio > 1.5) {
    // Strong upward movement
} else if (this.dmRatio < 0.67) {
    // Strong downward movement
}

Copy

private adx: number[] = bdpo.adx(data.high, data.low, data.close, 14);
private currentADX: number = this.adx[this.adx.length - 1];

// ADX trend strength interpretation
if (this.currentADX > 40) {
    // Very strong trend
} else if (this.currentADX > 25) {
    // Strong trend
} else if (this.currentADX > 20) {
    // Moderate trend
} else {
    // Weak or no trend
}

Copy

private adxr: number[] = bdpo.adxr(data.high, data.low, data.close, 14);
private currentADXR: number = this.adxr[this.adxr.length - 1];

// ADXR provides smoother trend strength readings
if (this.currentADXR > 30) {
    // Strong sustained trend
} else if (this.currentADXR < 20) {
    // Weak trend or sideways market
}

Copy

private psar: number[] = bdpo.psar(data.high, data.low, 0.02, 0.2);
private currentPSAR: number = this.psar[this.psar.length - 1];
private currentClose: number = data.close[data.close.length - 1];

// PSAR trading signals
if (this.currentClose > this.currentPSAR) {
    // Bullish signal - price above PSAR
} else if (this.currentClose < this.currentPSAR) {
    // Bearish signal - price below PSAR
}

Copy

private trix: number[] = bdpo.trix(data.close, 14);
private currentTRIX: number = this.trix[this.trix.length - 1];
private previousTRIX: number = this.trix[this.trix.length - 2];

// TRIX signals
if (this.currentTRIX > 0 && this.previousTRIX <= 0) {
    // Bullish signal - TRIX crosses above zero
} else if (this.currentTRIX < 0 && this.previousTRIX >= 0) {
    // Bearish signal - TRIX crosses below zero
}

Copy

private linreg: number[] = bdpo.linreg(data.close, 20);
private currentLR: number = this.linreg[this.linreg.length - 1];
private currentPrice: number = data.close[data.close.length - 1];

// Linear regression trend analysis
private deviation: number = this.currentPrice - this.currentLR;
private deviationPercent: number = (deviation / this.currentLR) * 100;

if (Math.abs(this.deviationPercent) > 2) {
    // Price significantly deviates from trend
}

Copy

private midpoint: number[] = bdpo.midpoint(data.close, 14);
private currentMP: number = this.midpoint[this.midpoint.length - 1];
private currentPrice: number = data.close[data.close.length - 1];

// Midpoint as support/resistance level
if (this.currentPrice > this.currentMP) {
    // Price above midpoint - potential bullish
} else if (this.currentPrice < this.currentMP) {
    // Price below midpoint - potential bearish
}

Copy

private midprice: number[] = bdpo.midprice(data.high, data.low, 14);
private currentMidprice: number = this.midprice[this.midprice.length - 1];
private currentClose: number = data.close[data.close.length - 1];

// Midprice as dynamic support/resistance
private distanceFromMidprice: number = this.currentClose - this.currentMidprice;
private distancePercent: number = (distanceFromMidprice / this.currentMidprice) * 100;

if (Math.abs(this.distancePercent) > 1.5) {
    // Price significantly away from recent midprice
}

Copy

private fastMA: number[] = bdpo.ema(data.close, 12);
private slowMA: number[] = bdpo.ema(data.close, 26);
private crossUp: boolean[] = bdpo.crossover(this.fastMA, this.slowMA);

Copy

private fastMA: number[] = bdpo.ema(data.close, 12);
private slowMA: number[] = bdpo.ema(data.close, 26);
private crossDown: boolean[] = bdpo.crossunder(this.fastMA, this.slowMA);

// Check for bearish crossover signal
if (this.crossDown[this.crossDown.length - 1]) {
    // Fast MA crossed below slow MA - bearish signal
}

Copy

private rsi: number[] = bdpo.rsi(data.close, 14);
private rsiCrosses70: boolean[] = bdpo.crossany(this.rsi, [70]); // Cross 70 level

// Detect any crossover of RSI with 70 level
if (this.rsiCrosses70[this.rsiCrosses70.length - 1]) {
    // RSI crossed 70 level in either direction
}

Copy

private rsi: number[] = bdpo.rsi(data.close, 14);
private rsiCrossesAbove30: boolean[] = bdpo.crossOverNumber(this.rsi, 30);

// Check if RSI crosses above 30 (exit oversold)
if (this.rsiCrossesAbove30[this.rsiCrossesAbove30.length - 1]) {
    // RSI just crossed above 30 - potential buy signal
}

Copy

class MultiIndicatorStrategy {
    // Public configuration
    public rsiPeriod: number = 14;
    public smaPeriod: number = 20;
    public bbandsPeriod: number = 20;
    public bbandsStdDev: number = 2;
    
    // Private variables
    private rsi: number[] = [];
    private sma: number[] = [];
    private bbands: any = null;
    private atr: number[] = [];
    
    public __init__(): void {
        console.log("Multi-indicator strategy initialized");
    }
    
    public __tick__(data: any): void {
        // Calculate all indicators
        this.rsi = bdpo.rsi(data.close, this.rsiPeriod);
        this.sma = bdpo.sma(data.close, this.smaPeriod);
        this.bbands = bdpo.bbands(data.close, this.bbandsPeriod, this.bbandsStdDev);
        this.atr = bdpo.atr(data.high, data.low, data.close, 14);
        
        const currentPrice: number = data.close[data.close.length - 1];
        const currentRSI: number = this.rsi[this.rsi.length - 1];
        const currentSMA: number = this.sma[this.sma.length - 1];
        const upperBand: number = this.bbands.upper[this.bbands.upper.length - 1];
        const lowerBand: number = this.bbands.lower[this.bbands.lower.length - 1];
        const currentATR: number = this.atr[this.atr.length - 1];
        
        // Entry conditions
        const bullishCondition: boolean = currentPrice > currentSMA && 
                                        currentRSI < 70 && 
                                        currentPrice > lowerBand;
                                        
        const bearishCondition: boolean = currentPrice < currentSMA && 
                                        currentRSI > 30 && 
                                        currentPrice < upperBand;
        
        // Execute trades
        if (bullishCondition) {
            const stopLoss: number = currentPrice - (currentATR * 2);
            const takeProfit: number = currentPrice + (currentATR * 3);
            bdpo.orderSend("BUY", 0.1, stopLoss, takeProfit);
        } else if (bearishCondition) {
            const stopLoss: number = currentPrice + (currentATR * 2);
            const takeProfit: number = currentPrice - (currentATR * 3);
            bdpo.orderSend("SELL", 0.1, stopLoss, takeProfit);
        }
    }
    
    public __shutdown__(): void {
        console.log("Multi-indicator strategy completed");
    }
}

Copy

// Market buy order
await bdpo.orderSend({
    orderType: "BUY",
    lotSize: 1000,
    stopLoss: 95.0,
    takeProfit: 105.0,
    note: "Bullish breakout entry"
});

// Limit order with risk management
await bdpo.orderSend({
    orderType: "BUYLIMIT",
    lotSize: 500,
    price: 98.50,
    stopLoss: 96.00,
    takeProfit: 103.00
});

// Stop order for trend following
await bdpo.orderSend({
    orderType: "BUYSTOP",
    lotSize: 750,
    price: 102.00,
    stopLoss: 99.50
});

Copy

// Emergency close all positions
bdpo.orderCloseAll();

// Close all positions at end of trading session
if (bdpo.isMarketClose()) {
    bdpo.orderCloseAll();
}

Copy

// Comprehensive order validation and execution
class OrderManager {
    public maxPositionSize: number = 1000;
    public maxRiskPercent: number = 2;
    
    public async sendOrder(orderType: string, lotSize: number, options: any = {}): Promise {
        try {
            // Validate position size
            if (lotSize > this.maxPositionSize) {
                bdpo.log(`Order size ${lotSize} exceeds maximum ${this.maxPositionSize}`);
                return false;
            }
            
            // Check account balance for risk management
            const balance = bdpo.getBalance();
            const riskAmount = balance * (this.maxRiskPercent / 100);
            const currentPrice = bdpo.getPrice();
            const orderValue = lotSize * currentPrice;
            
            if (orderValue > riskAmount) {
                bdpo.log(`Order value exceeds risk limit: ${orderValue} > ${riskAmount}`);
                return false;
            }
            
            // Execute order with proper error handling
            await bdpo.orderSend({
                orderType: orderType,
                lotSize: lotSize,
                stopLoss: options.stopLoss,
                takeProfit: options.takeProfit,
                note: options.note || `Auto order: ${orderType}`
            });
            
            bdpo.log(`Order executed successfully: ${orderType} ${lotSize}`);
            return true;
            
        } catch (error) {
            bdpo.log(`Order execution failed: ${error.message}`);
            return false;
        }
    }
}

Copy

// Advanced position sizing with ATR-based stops
class RiskManagedTrading {
    public riskPerTrade: number = 0.02; // 2% risk per trade
    
    public calculatePositionSize(entryPrice: number, stopLoss: number): number {
        const balance = bdpo.getBalance();
        const riskAmount = balance * this.riskPerTrade;
        const riskPerShare = Math.abs(entryPrice - stopLoss);
        
        if (riskPerShare === 0) {
            bdpo.log("Error: Stop loss equals entry price");
            return 0;
        }
        
        const positionSize = Math.floor(riskAmount / riskPerShare);
        bdpo.log(`Position size calculated: ${positionSize} shares`);
        return positionSize;
    }
    
    public async placeManagedOrder(orderType: string, entryPrice: number, atrValue: number): Promise {
        // Calculate dynamic stop loss based on ATR
        const stopMultiplier = 2.0;
        const stopLoss = orderType === "BUY" 
            ? entryPrice - (atrValue * stopMultiplier)
            : entryPrice + (atrValue * stopMultiplier);
            
        const takeProfit = orderType === "BUY"
            ? entryPrice + (atrValue * 3.0) // 3:1 risk-reward
            : entryPrice - (atrValue * 3.0);
            
        const positionSize = this.calculatePositionSize(entryPrice, stopLoss);
        
        if (positionSize > 0) {
            await bdpo.orderSend({
                orderType: orderType,
                lotSize: positionSize,
                price: orderType.includes("LIMIT") || orderType.includes("STOP") ? entryPrice : undefined,
                stopLoss: stopLoss,
                takeProfit: takeProfit,
                note: `ATR-based order: R=${this.riskPerTrade * 100}%`
            });
        }
    }
}

Copy

// Get all open positions
const openPositions: any[] = bdpo.getOpenPositions();

// Check if we have any long positions
const longPositions = openPositions.filter(pos => pos.side === 'BUY');
bdpo.log(`Currently holding ${longPositions.length} long positions`);

// Calculate total position value
const totalValue = openPositions.reduce((sum, pos) => sum + (pos.size * pos.price), 0);

Copy

// Get pending orders
const pendingOrders: any[] = bdpo.getPendingPositions();

// Check for pending buy orders
const pendingBuys = pendingOrders.filter(order => 
    order.side === 'BUYLIMIT' || order.side === 'BUYSTOP'
);

// Cancel old pending orders (if needed)
if (pendingBuys.length > 5) {
    bdpo.log("Too many pending buy orders, consider cleanup");
}

Copy

// Analyze trading performance
const closedPositions: any[] = bdpo.getClosedPositions();

// Calculate win rate
const winners = closedPositions.filter(pos => pos.profit > 0);
const winRate = (winners.length / closedPositions.length) * 100;

// Calculate total P&L
const totalPnL = closedPositions.reduce((sum, pos) => sum + pos.profit, 0);

bdpo.log(`Win Rate: ${winRate.toFixed(2)}%, Total P&L: $${totalPnL.toFixed(2)}`);

Copy

// Quick position count check
const openCount: number = bdpo.getTotalOpenPositions();

// Position management based on count
if (openCount >= 10) {
    bdpo.log("High position count - monitoring closely");
} else if (openCount === 0) {
    bdpo.log("No open positions - ready for new trades");
}

bdpo.log(`Current open positions: ${openCount}`);

Copy

// Monitor pending order count
const pendingCount: number = bdpo.getTotalPendingPositions();

// Cleanup strategy for too many pending orders
if (pendingCount > 20) {
    bdpo.log("Too many pending orders - consider cleanup");
    // Implementation to cancel old orders would go here
}

bdpo.log(`Pending orders: ${pendingCount}`);

Copy

// Track trading activity
const closedCount: number = bdpo.getTotalClosedPositions();

// Performance analysis trigger
if (closedCount >= 100) {
    bdpo.log("Milestone reached - analyzing 100 completed trades");
    // Trigger performance analysis
}

bdpo.log(`Total completed trades: ${closedCount}`);

Copy

// Check position limits before opening new trades
const maxPositions: number = bdpo.getMaxOpenPositions();
const currentPositions: number = bdpo.getOpenPositions().length;

if (currentPositions < maxPositions) {
    // Safe to open new position
    await bdpo.orderSend({
        orderType: "BUY",
        lotSize: 1000
    });
} else {
    bdpo.log("Maximum positions reached, waiting for exits");
}

Copy

// Get current balance
const balance: number = bdpo.getBalance();

// Calculate position size based on risk percentage
const riskPercent: number = 2; // 2% risk per trade
const riskAmount: number = balance * (riskPercent / 100);

// Use balance for position sizing
const currentPrice: number = bdpo.getPrice();
const maxPositionSize: number = riskAmount / currentPrice;

bdpo.log(`Account Balance: $${balance.toFixed(2)}`);

Copy

// Monitor account equity
const equity: number = bdpo.getEquity();
const balance: number = bdpo.getBalance();
const unrealizedPnL: number = equity - balance;

// Check margin usage
const marginUsage: number = ((balance - equity) / balance) * 100;

if (marginUsage > 50) {
    bdpo.log("Warning: High margin usage detected");
    // Consider reducing position sizes
}

bdpo.log(`Equity: $${equity.toFixed(2)}, Unrealized P&L: $${unrealizedPnL.toFixed(2)}`);

Copy

// Track performance metrics
const profit: number = bdpo.getProfit();
const balance: number = bdpo.getBalance();
const profitPercent: number = (profit / balance) * 100;

// Implement profit protection
if (profitPercent > 10) {
    bdpo.log("Profit target reached, reducing risk");
    // Reduce position sizes or close some positions
}

// Stop loss at account level
if (profitPercent < -5) {
    bdpo.log("Daily loss limit reached, closing all positions");
    bdpo.orderCloseAll();
}

bdpo.log(`Current P&L: $${profit.toFixed(2)} (${profitPercent.toFixed(2)}%)`);

Copy

class RiskManagedStrategy {
    public maxRiskPercent: number = 2;      // Max 2% risk per trade
    public maxDailyLoss: number = -5;       // Stop trading at -5% daily loss
    public profitTarget: number = 10;       // Take profits at +10%
    
    private _initialBalance: number = 0;

    __init__(): void {
        this._initialBalance = bdpo.getBalance();
    }

    __tick__(): any {
        // Calculate current performance
        const currentBalance: number = bdpo.getBalance();
        const dailyPnL: number = ((currentBalance - this._initialBalance) / this._initialBalance) * 100;
        
        // Check daily loss limit
        if (dailyPnL <= this.maxDailyLoss) {
            bdpo.log("Daily loss limit reached - stopping trading");
            bdpo.orderCloseAll();
            return { status: "stopped", reason: "daily_loss_limit" };
        }
        
        // Check profit target
        if (dailyPnL >= this.profitTarget) {
            bdpo.log("Daily profit target reached - reducing risk");
            // Reduce position sizes or close half positions
        }
        
        // Calculate position size based on account risk
        const riskAmount: number = currentBalance * (this.maxRiskPercent / 100);
        const currentPrice: number = bdpo.getPrice();
        const stopLossDistance: number = currentPrice * 0.02; // 2% stop loss
        const positionSize: number = riskAmount / stopLossDistance;
        
        return {
            accountMetrics: {
                balance: currentBalance,
                dailyPnL: dailyPnL,
                riskAmount: riskAmount,
                positionSize: positionSize
            }
        };
    }
}

Copy

// Basic spline plot with custom properties
const prices: number[] = bdpo.getClose(data);
const customMA: number[] = bdpo.sma(prices, 20);

bdpo.plot("splines", [customMA], {
  splineColor: "#2196F3",
  splineWidth: 2,
  skipNan: true
}, {
  precision: 4
});

// Range plot for oscillator with custom bands
const rsi: number[] = bdpo.rsi(prices, 14);

bdpo.plot("range", [rsi], {
  rangeColor: "#9C27B0",
  rangeBackColor: "#9C27B022",
  rangeBandColor: "#FF5722",
  rangeLineWidth: 2,
  upperBand: 70,
  lowerBand: 30
}, {
  precision: 5
});

// Area plot with gradient fill
const atr: number[] = bdpo.atr(bdpo.getHigh(data), bdpo.getLow(data), prices, 14);
const upperBand: number[] = prices.map((price, i) => price + atr[i] * 2);

bdpo.plot("area", [upperBand], {
  areaColor: "#4CAF50",
  areaLineWidth: 1.5,
  areaBack1: "#4CAF5080",
  areaBack2: "#4CAF5010"
}, {
  precision: 5
});

// Band plot for Bollinger Bands
const bbands = bdpo.bbands(prices, 20, 2);

bdpo.plot("band", [bbands.upper, bbands.middle, bbands.lower], {
  upperBandColor: "#2196F3",
  middleBandColor: "#FF9800",
  lowerBandColor: "#2196F3",
  bandBackColor: "#2196F320",
  bandLineWidth: 1,
  showMid: true
}, {
  precision: 5
});

// Histogram with conditional colors
const macd = bdpo.macd(prices, 12, 26, 9);

bdpo.plot("histogram", [macd.histogram], {
  histColorUp: "#4CAF50",
  histColorDw: "#F44336",
  histColorSemiUp: "#8BC34A",
  histColorSemiDw: "#FFAB91",
  histBarWidth: 6,
  histLineWidth: 1
}, {
  precision: 5
});

// Trade arrows with custom styling
bdpo.plot("arrowTrades", {
  high: bdpo.getHigh(data),
  low: bdpo.getLow(data),
  close: prices,
  trades: [[1, "BUY", false], [-1, "SELL", true]]
}, {
  arrowBuyColor: "#00E676",
  arrowSellColor: "#FF1744",
  arrowSize: 8,
  arrowShowLabels: true,
  arrowMarkerOutline: true,
  arrowOutlineWidth: 3
}, {
  precision: 5
});

// Price labels with custom styling
bdpo.plot("priceLabels", {
  text: "Important Level",
  dir: 1,
  pin: "close",
  color: "#FFFFFF",
  back: "#FF5722",
  stroke: "#D84315",
  offset: 10
}, {
  labelColor: "#FFFFFF",
  labelBack: "#FF572280",
  labelStroke: "#D84315",
  labelBorderRadius: 5,
  labelOffset: 8
}, {
  precision: 2
});

Copy

// Moving average crossover system
const prices: number[] = bdpo.getClose(data);
const fastMA: number[] = bdpo.ema(prices, 12);
const slowMA: number[] = bdpo.ema(prices, 26);

// Plot fast MA in green using spline properties
bdpo.plot("splines", [fastMA], {
  splineColor: "#00E676",
  splineWidth: 2,
  skipNan: true
}, {
  precision: 4
});

// Plot slow MA in red using spline properties
bdpo.plot("splines", [slowMA], {
  splineColor: "#FF5722",
  splineWidth: 2,
  skipNan: true
}, {
  precision: 4
});

// Dynamic support/resistance levels
const highs: number[] = bdpo.getHigh(data);
const lows: number[] = bdpo.getLow(data);

// Rolling resistance level
const resistance: number[] = [];
for (let i = 0; i < highs.length; i++) {
  const periodHighs = highs.slice(Math.max(0, i - 20), i + 1);
  resistance.push(bdpo.max(periodHighs));
}

// Rolling support level
const support: number[] = [];
for (let i = 0; i < lows.length; i++) {
  const periodLows = lows.slice(Math.max(0, i - 20), i + 1);
  support.push(bdpo.min(periodLows));
}

bdpo.plot("splines", [resistance], {
  splineColor: "#FF1744",
  splineWidth: 2,
  skipNan: true
}, {
  precision: 4,
});

bdpo.plot("splines", [support], {
  splineColor: "#00E676",
  splineWidth: 2,
  skipNan: true
}, {
  precision: 4,
});

Copy

// MACD histogram with proper histogram properties
const prices: number[] = bdpo.getClose(data);
const macd: any = bdpo.macd(prices, 12, 26, 9);
const histogram: number[] = macd.histogram;

bdpo.plot("histogram", [histogram], {
  histColorUp: "#4CAF50",
  histColorDw: "#F44336",
  histColorSemiUp: "#8BC34A",
  histColorSemiDw: "#FFAB91",
  histBarWidth: 6,
  histLineWidth: 1
}, {
  precision: 4,
});

// Volume profile histogram
const volumes: number[] = bdpo.getVolume(data);
const volumeMA: number[] = bdpo.sma(volumes, 20);

// Relative volume (current vs average)
const relativeVolume: number[] = volumes.map((vol, i) => 
  volumeMA[i] > 0 ? (vol / volumeMA[i] - 1) * 100 : 0
);

bdpo.plot("histogram", [relativeVolume], {
  histColorUp: "#2196F3",
  histColorDw: "#FF5722",
  histColorValue: "#FF9800",
  histBarWidth: 4,
  histLineWidth: 1
}, {
  precision: 1,
});

// Momentum oscillator with zero line
const rsi: number[] = bdpo.rsi(prices, 14);
const rsiCentered: number[] = rsi.map(value => value - 50); // Center around 0

bdpo.plot("histogram", [rsiCentered], {
  histColorUp: "#4CAF50",
  histColorDw: "#F44336",
  histColorSemiUp: "#8BC34A",
  histColorSemiDw: "#FFAB91",
  histBarWidth: 5,
  histLineWidth: 1
}, {
  precision: 2,
});

Copy

// Moving average crossover signals with arrow trades
const prices: number[] = bdpo.getClose(data);
const fastMA: number[] = bdpo.ema(prices, 12);
const slowMA: number[] = bdpo.ema(prices, 26);

// Generate crossover signals
const buySignals: number[] = [];
const sellSignals: number[] = [];

for (let i = 1; i < prices.length; i++) {
  // Buy signal: fast MA crosses above slow MA
  if (fastMA[i] > slowMA[i] && fastMA[i-1] <= slowMA[i-1]) {
    buySignals.push(prices[i]);
  } else {
    buySignals.push(null);
  }
  
  // Sell signal: fast MA crosses below slow MA
  if (fastMA[i] < slowMA[i] && fastMA[i-1] >= slowMA[i-1]) {
    sellSignals.push(prices[i]);
  } else {
    sellSignals.push(null);
  }
}

// Plot buy signals with arrow trades
bdpo.plot("arrowTrades", [buySignals], {
  arrowBuyColor: "#4CAF50",
  arrowSellColor: "#F44336",
  arrowSize: 8,
  arrowShowLabels: true,
  arrowMarkerOutline: true,
  arrowOutlineWidth: 2
}, {
  precision: 4,
});

// Plot sell signals with arrow trades
bdpo.plot("arrowTrades", [sellSignals], {
  arrowBuyColor: "#4CAF50",
  arrowSellColor: "#F44336",
  arrowSize: 8,
  arrowShowLabels: true,
  arrowMarkerOutline: true,
  arrowOutlineWidth: 2
}, {
  precision: 4,
});

// Trade execution markers using trades plot type
const tradeData: any[] = [
  // Buy trade at index 50
  { type: 'buy', price: 100.50, index: 50 },
  // Sell trade at index 75
  { type: 'sell', price: 105.25, index: 75 }
];

// Convert trade data to plot format
const tradeMarkers: number[] = new Array(prices.length).fill(null);
tradeData.forEach(trade => {
  tradeMarkers[trade.index] = trade.price;
});

bdpo.plot("trades", [tradeMarkers], {
  tradeBuyColor: "#08b2c6",
  tradeSellColor: "#e42633",
  tradeRadius: 5,
  tradeShowLabels: true,
  tradeMarkerOutline: true,
  tradeOutlineWidth: 3
}, {
  title: "Trade Executions"
});

for (let i = 1; i < fastMA.length; i++) { const currentFast = fastMA[i]; const currentSlow = slowMA[i]; const prevFast = fastMA[i - 1]; const prevSlow = slowMA[i - 1]; // Bullish crossover if (prevFast <= prevSlow && currentFast > currentSlow) { buySignals[i] = prices[i]; } else { buySignals[i] = null; } // Bearish crossover if (prevFast >= prevSlow && currentFast < currentSlow) { sellSignals[i] = prices[i]; } else { sellSignals[i] = null; } } // Plot buy signals bdpo.plot("arrowTrades", { high: bdpo.getHigh(data), low: bdpo.getLow(data), close: prices, trades: buySignals.map((signal, i) => signal ? [1, "BUY", false] : null).filter(Boolean) }, { arrowBuyColor: "#4CAF50", arrowSellColor: "#F44336", arrowSize: 8, arrowShowLabels: true, arrowMarkerOutline: true, arrowOutlineWidth: 2 }, { title: "Buy Signals" }); // Plot sell signals bdpo.plot("arrowTrades", { high: bdpo.getHigh(data), low: bdpo.getLow(data), close: prices, trades: sellSignals.map((signal, i) => signal ? [-1, "SELL", false] : null).filter(Boolean) }, { arrowBuyColor: "#4CAF50", arrowSellColor: "#F44336", arrowSize: 8, arrowShowLabels: true, arrowMarkerOutline: true, arrowOutlineWidth: 2 }, { title: "Sell Signals" }); // Support/Resistance breakout alerts const highs: number[] = bdpo.getHigh(data); const lows: number[] = bdpo.getLow(data); const breakoutSignals: number[] = []; for (let i = 20; i < prices.length; i++) { const recentHigh = bdpo.max(highs.slice(i - 20, i)); const recentLow = bdpo.min(lows.slice(i - 20, i)); // Breakout above resistance if (prices[i] > recentHigh) { breakoutSignals[i] = prices[i]; } // Breakdown below support else if (prices[i] < recentLow) { breakoutSignals[i] = prices[i]; } else { breakoutSignals[i] = null; } } bdpo.plot("trades", breakoutSignals.map((signal, i) => signal ? [1, signal, "BREAKOUT"] : null ).filter(Boolean), { tradeBuyColor: "#FF9800", tradeSellColor: "#FF9800", tradeRadius: 6, tradeShowLabels: true, tradeMarkerOutline: true, tradeOutlineWidth: 2 }, { title: "Breakout Alerts" });

Copy

// Advanced market structure analysis
const prices: number[] = bdpo.getClose(data);
const highs: number[] = bdpo.getHigh(data);
const lows: number[] = bdpo.getLow(data);
const volumes: number[] = bdpo.getVolume(data);

// 1. Trend strength indicator
const trendStrength: number[] = [];
const period = 20;

for (let i = period; i < prices.length; i++) {
  const periodPrices = prices.slice(i - period, i + 1);
  const linearReg = calculateLinearRegression(periodPrices);
  const slope = linearReg.slope;
  const rSquared = linearReg.rSquared;
  
  // Combine slope and correlation for trend strength
  trendStrength[i] = slope * rSquared * 100;
}

// Plot trend strength with conditional colors
const strengthColors = trendStrength.map(strength => {
  if (strength > 0.5) return "#4CAF50";      // Strong uptrend
  if (strength > 0.1) return "#8BC34A";      // Weak uptrend
  if (strength < -0.5) return "#F44336";     // Strong downtrend
  if (strength < -0.1) return "#FF5722";     // Weak downtrend
  return "#9E9E9E";                          // Sideways
});

bdpo.plot("histogram", [trendStrength], {
  histColorUp: "#4CAF50",
  histColorDw: "#F44336",
  histColorSemiUp: "#8BC34A",
  histColorSemiDw: "#FFAB91",
  histBarWidth: 4,
  histLineWidth: 1
}, {
  title: "Trend Strength",
  precision: 2
});

// 2. Volume-weighted price levels
const vwap: number[] = [];
const vwapBands: { upper: number[], lower: number[] } = { upper: [], lower: [] };

for (let i = 0; i < prices.length; i++) {
  // Calculate VWAP for current session
  const sessionStart = Math.max(0, i - 100); // 100-period session
  const sessionPrices = prices.slice(sessionStart, i + 1);
  const sessionVolumes = volumes.slice(sessionStart, i + 1);
  
  let totalVolumePrice = 0;
  let totalVolume = 0;
  
  for (let j = 0; j < sessionPrices.length; j++) {
    totalVolumePrice += sessionPrices[j] * sessionVolumes[j];
    totalVolume += sessionVolumes[j];
  }
  
  vwap[i] = totalVolume > 0 ? totalVolumePrice / totalVolume : prices[i];
  
  // Calculate standard deviation bands
  const variance = sessionPrices.reduce((sum, price, idx) => {
    const weightedPrice = price * sessionVolumes[idx];
    return sum + Math.pow(weightedPrice - vwap[i] * sessionVolumes[idx], 2);
  }, 0) / totalVolume;
  
  const stdDev = Math.sqrt(variance);
  vwapBands.upper[i] = vwap[i] + stdDev * 2;
  vwapBands.lower[i] = vwap[i] - stdDev * 2;
}

// Plot VWAP and bands
bdpo.plot("splines", [vwap], {
  splineColor: "#FF9800",
  splineWidth: 2,
  skipNan: true
}, {
  title: "VWAP",
  precision: 4
});

bdpo.plot("splines", [vwapBands.upper], {
  splineColor: "#FF9800",
  splineWidth: 1,
  skipNan: true
}, {
  title: "VWAP Upper Band"
});

bdpo.plot("splines", [vwapBands.lower], {
  splineColor: "#FF9800",
  splineWidth: 1,
  skipNan: true
}, {
  title: "VWAP Lower Band"
});

// 3. Market regime detection
const volatility: number[] = bdpo.atr(highs, lows, prices, 14);
const avgVol: number[] = bdpo.sma(volatility, 50);
const volRatio: number[] = volatility.map((vol, i) => 
  avgVol[i] > 0 ? vol / avgVol[i] : 1
);

// Regime classification
const regimeSignals: number[] = volRatio.map((ratio, i) => {
  if (ratio > 1.5) return 2;    // High volatility regime
  if (ratio < 0.7) return -2;   // Low volatility regime
  return 0;                     // Normal regime
});

bdpo.plot("histogram", [regimeSignals], {
  conditionalColors: {
    2: "#F44336",   // High vol (red)
    0: "#9E9E9E",   // Normal (gray)
    "-2": "#4CAF50" // Low vol (green)
  },
  opacity: 0.6
}, {
  title: "Market Regime",
  precision: 0
});

// Helper function for linear regression
function calculateLinearRegression(data: number[]): { slope: number, rSquared: number } {
  const n = data.length;
  const x = Array.from({ length: n }, (_, i) => i);
  const y = data;
  
  const sumX = bdpo.sum(x);
  const sumY = bdpo.sum(y);
  const sumXY = bdpo.sum(x.map((xi, i) => xi * y[i]));
  const sumXX = bdpo.sum(x.map(xi => xi * xi));
  const sumYY = bdpo.sum(y.map(yi => yi * yi));
  
  const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
  const intercept = (sumY - slope * sumX) / n;
  
  // Calculate R-squared
  const yMean = sumY / n;
  const ssRes = bdpo.sum(y.map((yi, i) => Math.pow(yi - (slope * x[i] + intercept), 2)));
  const ssTot = bdpo.sum(y.map(yi => Math.pow(yi - yMean, 2)));
  const rSquared = 1 - (ssRes / ssTot);
  
  return { slope, rSquared };
}

Copy

// Get different timeframe data
const chartData: any[] = bdpo.getTimeframeData("current");
const hourlyData: any[] = bdpo.getTimeframeData("1h");
const dailyData: any[] = bdpo.getTimeframeData("1d");

// Use in strategy
if (chartData && chartData.length > 0) {
  const currentPrice: number = chartData[chartData.length - 1][4]; // Last close
  bdpo.log(`Current price: ${currentPrice}`);
}

Copy

// Get current chart data
const chartData: any[] = bdpo.getChartData(data);

// Process current timeframe candles
if (chartData && chartData.length >= 50) {
  const sma20: number[] = bdpo.sma(bdpo.getClose(chartData), 20);
  const lastSMA: number = sma20[sma20.length - 1];
  
  bdpo.log(`Current SMA20: ${lastSMA.toFixed(4)}`);
}

Copy

// Check available timeframes
const timeframes: string[] = bdpo.getAvailableTimeframes(data);
bdpo.log(`Available timeframes: ${timeframes.join(", ")}`);

// Dynamically process multiple timeframes
timeframes.forEach((tf: string) => {
  const tfData: any[] = bdpo.getTimeframeData(tf);
  const closes: number[] = bdpo.getClose(tfData);
  const lastClose: number = closes[closes.length - 1];
  
  bdpo.log(`${tf} last close: ${lastClose}`);
});

Copy

// Extract timestamps
const chartData: any[] = bdpo.getChartData(data);
const timestamps: number[] = bdpo.getTimestamps(chartData);

// Convert to dates and analyze time gaps
const dates: Date[] = timestamps.map((ts: number) => bdpo.timestampToDate(ts));
const lastCandleTime: Date = dates[dates.length - 1];

bdpo.log(`Last candle time: ${lastCandleTime.toISOString()}`);

Copy

// Extract open prices
const chartData: any[] = bdpo.getChartData(data);
const opens: number[] = bdpo.getOpen(chartData);

// Calculate opening gap
const lastOpen: number = opens[opens.length - 1];
const prevClose: number = bdpo.getClose(chartData)[chartData.length - 2];
const gap: number = ((lastOpen - prevClose) / prevClose) * 100;

bdpo.log(`Opening gap: ${gap.toFixed(2)}%`);

Copy

// Extract high prices
const chartData: any[] = bdpo.getChartData(data);
const highs: number[] = bdpo.getHigh(chartData);

// Find recent high
const recentHigh: number = bdpo.getHighestHigh(chartData, 20);
const currentPrice: number = bdpo.getClose(chartData)[chartData.length - 1];
const distanceFromHigh: number = ((currentPrice - recentHigh) / recentHigh) * 100;

bdpo.log(`Distance from 20-period high: ${distanceFromHigh.toFixed(2)}%`);

Copy

// Extract low prices
const chartData: any[] = bdpo.getChartData(data);
const lows: number[] = bdpo.getLow(chartData);

// Find support level
const recentLow: number = bdpo.getLowestLow(chartData, 50);
const currentPrice: number = bdpo.getClose(chartData)[chartData.length - 1];
const supportLevel: number = recentLow * 1.02; // 2% above recent low

if (currentPrice <= supportLevel) {
  bdpo.log("Price near support level");
}

Copy

// Extract close prices for technical analysis
const chartData: any[] = bdpo.getChartData(data);
const closes: number[] = bdpo.getClose(chartData);

// Use with indicators
const sma20: number[] = bdpo.sma(closes, 20);
const ema12: number[] = bdpo.ema(closes, 12);
const rsi: number[] = bdpo.rsi(closes, 14);

// Current values
const currentClose: number = closes[closes.length - 1];
const currentSMA: number = sma20[sma20.length - 1];
const currentRSI: number = rsi[rsi.length - 1];

bdpo.log(`Close: ${currentClose}, SMA20: ${currentSMA.toFixed(4)}, RSI: ${currentRSI.toFixed(2)}`);

Copy

// Extract volume for analysis
const chartData: any[] = bdpo.getChartData(data);
const volumes: number[] = bdpo.getVolume(chartData);

// Calculate volume moving average
const volumeSMA: number[] = bdpo.sma(volumes, 20);
const currentVolume: number = volumes[volumes.length - 1];
const avgVolume: number = volumeSMA[volumeSMA.length - 1];

// Volume spike detection
const volumeRatio: number = currentVolume / avgVolume;
if (volumeRatio > 2.0) {
  bdpo.log(`High volume spike detected: ${volumeRatio.toFixed(2)}x average`);
}

Copy

// Get recent data for analysis
const chartData: any[] = bdpo.getChartData(data);
const last50Candles: any[] = bdpo.getLastCandles(chartData, 50);

// Calculate short-term indicators
const recentCloses: number[] = bdpo.getClose(last50Candles);
const shortRSI: number[] = bdpo.rsi(recentCloses, 14);
const recentHigh: number = bdpo.getHighestHigh(last50Candles, 20);

bdpo.log(`Recent RSI: ${shortRSI[shortRSI.length - 1].toFixed(2)}`);

Copy

// Analyze historical data
const chartData: any[] = bdpo.getChartData(data);
const first100Candles: any[] = bdpo.getFirstCandles(chartData, 100);

// Calculate historical volatility
const historicalCloses: number[] = bdpo.getClose(first100Candles);
const returns: number[] = [];
for (let i = 1; i < historicalCloses.length; i++) {
  const dailyReturn: number = (historicalCloses[i] - historicalCloses[i-1]) / historicalCloses[i-1];
  returns.push(dailyReturn);
}

bdpo.log(`Historical period analyzed: ${first100Candles.length} candles`);

Copy

// Analyze specific time period
const chartData: any[] = bdpo.getChartData(data);
const now: number = Date.now();
const yesterday: number = now - (24 * 60 * 60 * 1000);

const recentCandles: any[] = bdpo.getCandlesByTimestamp(chartData, yesterday, now);
const periodCloses: number[] = bdpo.getClose(recentCandles);

// Calculate period performance
if (periodCloses.length > 1) {
  const periodReturn: number = ((periodCloses[periodCloses.length - 1] - periodCloses[0]) / periodCloses[0]) * 100;
  bdpo.log(`24h return: ${periodReturn.toFixed(2)}%`);
}

Copy

// Get current candle information
const chartData: any[] = bdpo.getChartData(data);
const lastCandle: any[] | null = bdpo.getLastCandle(chartData);

if (lastCandle) {
  const [timestamp, open, high, low, close, volume] = lastCandle;
  const bodySize: number = Math.abs(close - open);
  const range: number = high - low;
  const bodyPercentage: number = (bodySize / range) * 100;
  
  bdpo.log(`Current candle - O:${open} H:${high} L:${low} C:${close} V:${volume}`);
  bdpo.log(`Body: ${bodyPercentage.toFixed(1)}% of range`);
}

Copy

// Compare first and last candles
const chartData: any[] = bdpo.getChartData(data);
const firstCandle: any[] | null = bdpo.getFirstCandle(chartData);
const lastCandle: any[] | null = bdpo.getLastCandle(chartData);

if (firstCandle && lastCandle) {
  const totalReturn: number = ((lastCandle[4] - firstCandle[4]) / firstCandle[4]) * 100;
  const startDate: Date = bdpo.timestampToDate(firstCandle[0]);
  const endDate: Date = bdpo.timestampToDate(lastCandle[0]);
  
  bdpo.log(`Total return from ${startDate.toDateString()} to ${endDate.toDateString()}: ${totalReturn.toFixed(2)}%`);
}

Copy

// Find resistance levels
const chartData: any[] = bdpo.getChartData(data);
const high20: number = bdpo.getHighestHigh(chartData, 20);
const high50: number = bdpo.getHighestHigh(chartData, 50);
const allTimeHigh: number = bdpo.getHighestHigh(chartData);

const currentPrice: number = bdpo.getClose(chartData)[chartData.length - 1];

// Distance from highs
const distanceFrom20High: number = ((currentPrice - high20) / high20) * 100;
const distanceFrom50High: number = ((currentPrice - high50) / high50) * 100;

bdpo.log(`20-period high: ${high20} (${distanceFrom20High.toFixed(1)}% away)`);
bdpo.log(`50-period high: ${high50} (${distanceFrom50High.toFixed(1)}% away)`);

Copy

// Find support levels
const chartData: any[] = bdpo.getChartData(data);
const low20: number = bdpo.getLowestLow(chartData, 20);
const low50: number = bdpo.getLowestLow(chartData, 50);
const allTimeLow: number = bdpo.getLowestLow(chartData);

const currentPrice: number = bdpo.getClose(chartData)[chartData.length - 1];

// Support level analysis
const supportDistance20: number = ((currentPrice - low20) / low20) * 100;
const supportDistance50: number = ((currentPrice - low50) / low50) * 100;

if (supportDistance20 < 5) {
  bdpo.log("Price approaching 20-period support level");
}

bdpo.log(`20-period low: ${low20} (+${supportDistance20.toFixed(1)}% above)`);

Copy

// Analyze volatility through price ranges
const chartData: any[] = bdpo.getChartData(data);
const ranges: number[] = bdpo.getPriceRange(chartData);

// Calculate average range and volatility
const avgRange: number[] = bdpo.sma(ranges, 20);
const currentRange: number = ranges[ranges.length - 1];
const avgCurrentRange: number = avgRange[avgRange.length - 1];

// Volatility expansion/contraction
const rangeRatio: number = currentRange / avgCurrentRange;

if (rangeRatio > 1.5) {
  bdpo.log("High volatility - range expansion detected");
} else if (rangeRatio < 0.5) {
  bdpo.log("Low volatility - range contraction detected");
}

Copy

// Analyze candle strength through body size
const chartData: any[] = bdpo.getChartData(data);
const bodySizes: number[] = bdpo.getBodySize(chartData);
const ranges: number[] = bdpo.getPriceRange(chartData);

// Calculate body-to-range ratios
const bodyRatios: number[] = bodySizes.map((body: number, i: number) => 
  ranges[i] > 0 ? (body / ranges[i]) * 100 : 0
);

const lastBodyRatio: number = bodyRatios[bodyRatios.length - 1];

// Candle strength analysis
if (lastBodyRatio > 70) {
  bdpo.log("Strong candle - large body relative to range");
} else if (lastBodyRatio < 30) {
  bdpo.log("Weak candle - small body, likely indecision");
}

Copy

// Analyze rejection at higher prices
const chartData: any[] = bdpo.getChartData(data);
const upperShadows: number[] = bdpo.getUpperShadow(chartData);
const ranges: number[] = bdpo.getPriceRange(chartData);

// Calculate shadow-to-range ratios
const shadowRatios: number[] = upperShadows.map((shadow: number, i: number) => 
  ranges[i] > 0 ? (shadow / ranges[i]) * 100 : 0
);

const lastShadowRatio: number = shadowRatios[shadowRatios.length - 1];

// Rejection pattern detection
if (lastShadowRatio > 60) {
  bdpo.log("Strong upper rejection - potential resistance");
  
  // Check if it's a shooting star pattern
  const bodySizes: number[] = bdpo.getBodySize(chartData);
  const lastBodyRatio: number = (bodySizes[bodySizes.length - 1] / ranges[ranges.length - 1]) * 100;
  
  if (lastBodyRatio < 30) {
    bdpo.log("Shooting star pattern detected");
  }
}

Copy

// Analyze buying pressure and support
const chartData: any[] = bdpo.getChartData(data);
const lowerShadows: number[] = bdpo.getLowerShadow(chartData);
const ranges: number[] = bdpo.getPriceRange(chartData);

// Calculate lower shadow ratios
const shadowRatios: number[] = lowerShadows.map((shadow: number, i: number) => 
  ranges[i] > 0 ? (shadow / ranges[i]) * 100 : 0
);

const lastShadowRatio: number = shadowRatios[shadowRatios.length - 1];

// Support and hammer pattern detection
if (lastShadowRatio > 60) {
  bdpo.log("Strong lower rejection - potential support");
  
  // Check for hammer pattern
  const bodySizes: number[] = bdpo.getBodySize(chartData);
  const lastBodyRatio: number = (bodySizes[bodySizes.length - 1] / ranges[ranges.length - 1]) * 100;
  
  if (lastBodyRatio < 30) {
    bdpo.log("Hammer pattern detected - potential reversal");
  }
}

Copy

// Analyze bullish momentum
const chartData: any[] = bdpo.getChartData(data);
const bullishCandles: boolean[] = bdpo.isBullish(chartData);

// Count consecutive bullish candles
let consecutiveBullish: number = 0;
for (let i = bullishCandles.length - 1; i >= 0; i--) {
  if (bullishCandles[i]) {
    consecutiveBullish++;
  } else {
    break;
  }
}

// Calculate bullish percentage over last 20 candles
const last20: boolean[] = bullishCandles.slice(-20);
const bullishCount: number = last20.filter(Boolean).length;
const bullishPercentage: number = (bullishCount / last20.length) * 100;

bdpo.log(`Consecutive bullish candles: ${consecutiveBullish}`);
bdpo.log(`Bullish momentum (20-period): ${bullishPercentage.toFixed(1)}%`);

Copy

// Analyze bearish pressure
const chartData: any[] = bdpo.getChartData(data);
const bearishCandles: boolean[] = bdpo.isBearish(chartData);

// Count consecutive bearish candles
let consecutiveBearish: number = 0;
for (let i = bearishCandles.length - 1; i >= 0; i--) {
  if (bearishCandles[i]) {
    consecutiveBearish++;
  } else {
    break;
  }
}

// Calculate bearish pressure
const last20: boolean[] = bearishCandles.slice(-20);
const bearishCount: number = last20.filter(Boolean).length;
const bearishPercentage: number = (bearishCount / last20.length) * 100;

// Risk management based on bearish momentum
if (bearishPercentage > 70 && consecutiveBearish >= 3) {
  bdpo.log("Strong bearish momentum - consider defensive positioning");
}

bdpo.log(`Consecutive bearish candles: ${consecutiveBearish}`);

Copy

// Convert timestamps for time-based analysis
const chartData: any[] = bdpo.getChartData(data);
const lastCandle: any[] | null = bdpo.getLastCandle(chartData);

if (lastCandle) {
  const candleDate: Date = bdpo.timestampToDate(lastCandle[0]);
  const now: Date = new Date();
  const ageMinutes: number = (now.getTime() - candleDate.getTime()) / (1000 * 60);
  
  bdpo.log(`Last candle date: ${candleDate.toISOString()}`);
  bdpo.log(`Candle age: ${ageMinutes.toFixed(1)} minutes`);
  
  // Time-based trading rules
  const hour: number = candleDate.getHours();
  if (hour >= 9 && hour <= 16) {
    bdpo.log("Market hours - active trading period");
  } else {
    bdpo.log("After hours - reduced liquidity expected");
  }
}

Copy

// Get complete asset information
const asset: any = bdpo.getAsset();

if (asset) {
  bdpo.log(`Asset Details:`);
  bdpo.log(`Symbol: ${asset.ticker}`);
  bdpo.log(`Exchange: ${asset.exchange}`);
  bdpo.log(`Type: ${asset.type}`);
  bdpo.log(`Contract Size: ${asset.contract_size}`);
  
  // Use asset properties for trading decisions
  if (asset.type === 'crypto') {
    // Crypto-specific logic
  } else if (asset.type === 'forex') {
    // Forex-specific logic
  }
}

Copy

// Get current trading symbol
const symbol: string | null = bdpo.getSymbol();

if (symbol) {
  bdpo.log(`Trading: ${symbol}`);
  
  // Symbol-specific trading logic
  if (symbol.includes('BTC')) {
    // Bitcoin-related strategies
    const btcSpecificRiskManagement = true;
  } else if (symbol.includes('USD')) {
    // USD pair strategies
    const usdPairStrategy = true;
  }
  
  // Use symbol for logging and tracking
  bdpo.log(`${symbol}: Strategy initialized`);
}

Copy

// Get data source
const source: string | null = bdpo.getSource();

if (source) {
  bdpo.log(`Data source: ${source}`);
  
  // Source-specific adjustments
  if (source === 'BINANCE') {
    // Binance-specific considerations (crypto exchange)
    const cryptoMode = true;
  } else if (source === 'BLACKBULL') {
    // BlackBull-specific considerations (forex broker)
    const forexMode = true;
  }
  
  // Adjust strategy based on data source characteristics
  bdpo.log(`Strategy adapted for ${source} data feed`);
}

Copy

// Get descriptive asset name
const assetName: string | null = bdpo.getName();

if (assetName) {
  bdpo.log(`Trading: ${assetName}`);
  
  // Use for user-friendly logging and reports
  const symbol: string = bdpo.getSymbol();
  const performance = calculatePerformance();
  
  bdpo.log(`${assetName} (${symbol}) Performance: ${performance.toFixed(2)}%`);
}

Copy

// Get asset type for strategy adaptation
const assetType: string | null = bdpo.getType();

if (assetType) {
  bdpo.log(`Asset type: ${assetType}`);
  
  // Type-specific strategy configuration
  switch (assetType) {
    case 'crypto':
      // Cryptocurrency specific settings
      const volatilityMultiplier = 1.5;
      const tradingHours = '24/7';
      break;
      
    case 'forex':
      // Forex specific settings
      const volatilityMultiplier = 1.0;
      const tradingHours = 'weekdays';
      break;
      
    case 'stock':
      // Stock specific settings
      const volatilityMultiplier = 0.8;
      const tradingHours = 'market_hours';
      break;
      
    default:
      bdpo.log(`Unknown asset type: ${assetType}`);
  }
}

Copy

// Get base and quote assets
const baseAsset: string | null = bdpo.getBaseAsset();
const quoteAsset: string | null = bdpo.getQuoteAsset();

if (baseAsset && quoteAsset) {
  bdpo.log(`Trading pair: ${baseAsset}/${quoteAsset}`);
  
  // Currency-specific analysis
  if (baseAsset === 'BTC') {
    // Bitcoin correlation analysis
    const btcDominance = checkBitcoinDominance();
  } else if (baseAsset === 'EUR') {
    // Euro economic indicators
    const euroZoneData = getEuroZoneEconomicData();
  }
  
  // Position sizing based on base asset
  const positionSize = calculatePositionSize(baseAsset);
}

Copy

// Get quote asset for P&L calculations
const quoteAsset: string | null = bdpo.getQuoteAsset();

if (quoteAsset) {
  bdpo.log(`Profit/Loss calculated in: ${quoteAsset}`);
  
  // Quote asset considerations
  if (quoteAsset === 'USD') {
    // US Dollar considerations
    const dollarStrengthIndex = getDollarIndex();
  } else if (quoteAsset === 'JPY') {
    // Japanese Yen considerations
    const yenCarryTrade = analyzeCarryTrade();
  }
  
  // Account currency conversion if needed
  const accountCurrency = getAccountCurrency();
  if (accountCurrency !== quoteAsset) {
    const conversionRate = getConversionRate(quoteAsset, accountCurrency);
    bdpo.log(`Conversion rate ${quoteAsset}/${accountCurrency}: ${conversionRate}`);
  }
}

Copy

// Get contract size for position calculations
const contractSize: number | null = bdpo.getContractSize();

if (contractSize) {
  bdpo.log(`Contract size: ${contractSize}`);
  
  // Position value calculations
  const lotSize = 1.0;
  const currentPrice = bdpo.getAsk();
  const positionValue = lotSize * contractSize * currentPrice;
  
  bdpo.log(`Position value: ${positionValue.toFixed(2)}`);
  
  // Risk management based on contract size
  const accountBalance = bdpo.getBalance();
  const maxPositionPercent = 0.02; // 2% risk
  const maxLots = (accountBalance * maxPositionPercent) / (contractSize * currentPrice);
  
  bdpo.log(`Max recommended lots: ${maxLots.toFixed(2)}`);
}

Copy

// Get trading quantity limits
const minQty: number | null = bdpo.getMinQty();
const maxQty: number | null = bdpo.getMaxQty();

if (minQty !== null && maxQty !== null) {
  bdpo.log(`Trading limits: ${minQty} - ${maxQty} lots`);
  
  // Validate order size before placing trades
  function validateOrderSize(requestedLots: number): number {
    if (requestedLots < minQty) {
      bdpo.log(`Order size too small. Minimum: ${minQty}, adjusting to ${minQty}`);
      return minQty;
    }
    
    if (requestedLots > maxQty) {
      bdpo.log(`Order size too large. Maximum: ${maxQty}, adjusting to ${maxQty}`);
      return maxQty;
    }
    
    return requestedLots;
  }
  
  // Use in order placement
  const desiredLots = 5.0;
  const validatedLots = validateOrderSize(desiredLots);
  
  bdpo.orderSend({
    orderType: "BUY",
    lotSize: validatedLots
  });
}

Copy

// Get pip value for calculations
const pipValue: number | null = bdpo.getPip();

if (pipValue) {
  bdpo.log(`Pip value: ${pipValue}`);
  
  // Calculate pip-based stop loss and take profit
  const currentPrice = bdpo.getAsk();
  const stopLossPips = 50;
  const takeProfitPips = 100;
  
  const stopLossPrice = currentPrice - (stopLossPips * (pipValue / 10));
  const takeProfitPrice = currentPrice + (takeProfitPips * (pipValue / 10));
  
  bdpo.log(`Stop Loss: ${stopLossPrice.toFixed(5)}`);
  bdpo.log(`Take Profit: ${takeProfitPrice.toFixed(5)}`);
  
  // Risk calculation in pips
  const riskInPips = Math.abs(currentPrice - stopLossPrice) / (pipValue / 10);
  bdpo.log(`Risk: ${riskInPips.toFixed(1)} pips`);
}

Copy

// Get price precision for formatting
const precision: number | null = bdpo.getPrecision();

if (precision) {
  bdpo.log(`Price precision: ${precision} decimal places`);
  
  // Format prices correctly
  function formatPrice(price: number): string {
    return price.toFixed(precision);
  }
  
  const currentPrice = bdpo.getAsk();
  const formattedPrice = formatPrice(currentPrice);
  
  bdpo.log(`Current price: ${formattedPrice}`);
  
  // Ensure order prices match broker precision
  const calculatedStopLoss = 1.23456789;
  const preciseStopLoss = parseFloat(formatPrice(calculatedStopLoss));
  
  bdpo.orderSend({
    orderType: "BUYLIMIT",
    price: preciseStopLoss,
    lotSize: 1.0
  });
}

Copy

// Get minimum price step for order placement
const stepSize: number | null = bdpo.getStepSize();

if (stepSize) {
  bdpo.log(`Minimum price step: ${stepSize}`);
  
  // Round prices to valid steps
  function roundToStepSize(price: number): number {
    return Math.round(price / stepSize) * stepSize;
  }
  
  // Example: Place limit order with valid price
  const currentPrice = bdpo.getAsk();
  const targetPrice = currentPrice * 1.02; // 2% above current
  const validPrice = roundToStepSize(targetPrice);
  
  bdpo.log(`Target: ${targetPrice}, Valid: ${validPrice}`);
  
  bdpo.orderSend({
    orderType: "BUYLIMIT",
    price: validPrice,
    lotSize: 1.0
  });
}

Copy

// Get current ask price for buy orders
const askPrice: number = bdpo.getAsk();
const bidPrice: number = bdpo.getBid();

bdpo.log(`Ask: ${askPrice}, Bid: ${bidPrice}`);

// Use ask price for buy order calculations
const buyOrderPrice = askPrice;
const stopLoss = askPrice * 0.98; // 2% below ask
const takeProfit = askPrice * 1.04; // 4% above ask

// Place buy order at current ask
bdpo.orderSend({
  orderType: "BUY",
  lotSize: 1.0,
  stopLoss: stopLoss,
  takeProfit: takeProfit
});

// Monitor spread
const spread = askPrice - bidPrice;
const spreadPips = bdpo.getSpread();
bdpo.log(`Spread: ${spread.toFixed(5)} (${spreadPips.toFixed(1)} pips)`);

Copy

// Get current bid price for sell orders
const bidPrice: number = bdpo.getBid();
const askPrice: number = bdpo.getAsk();

bdpo.log(`Bid: ${bidPrice}, Ask: ${askPrice}`);

// Use bid price for sell order calculations
const sellOrderPrice = bidPrice;
const stopLoss = bidPrice * 1.02; // 2% above bid
const takeProfit = bidPrice * 0.96; // 4% below bid

// Place sell order at current bid
bdpo.orderSend({
  orderType: "SELL",
  lotSize: 1.0,
  stopLoss: stopLoss,
  takeProfit: takeProfit
});

// Calculate mid price
const midPrice = (askPrice + bidPrice) / 2;
bdpo.log(`Mid price: ${midPrice.toFixed(5)}`);

Copy

// Monitor spread for optimal trade entry
const currentSpread: number = bdpo.getSpread();
const avgSpread = 2.5; // Historical average spread in pips

bdpo.log(`Current spread: ${currentSpread.toFixed(1)} pips`);

// Trade only when spread is reasonable
if (currentSpread <= avgSpread * 1.5) {
  bdpo.log("Spread acceptable for trading");
  
  // Continue with trade logic
  const askPrice = bdpo.getAsk();
  const bidPrice = bdpo.getBid();
  
  // Factor spread into profit targets
  const minProfitPips = currentSpread * 3; // 3x spread minimum
  const takeProfitDistance = minProfitPips * (bdpo.getPip() / 10);
  
  bdpo.orderSend({
    orderType: "BUY",
    lotSize: 1.0,
    takeProfit: askPrice + takeProfitDistance
  });
  
} else {
  bdpo.log(`Spread too wide: ${currentSpread.toFixed(1)} pips. Waiting for better conditions.`);
}

Copy

// Get exchange information
const exchange: string | null = bdpo.getExchange();

if (exchange) {
  bdpo.log(`Trading on: ${exchange}`);
  
  // Exchange-specific configurations
  switch (exchange.toLowerCase()) {
    case 'blackbull markets':
      // BlackBull specific settings
      const maxLeverage = 500;
      const supportsCrypto = true;
      break;
      
    case 'binance':
      // Binance specific settings
      const maxLeverage = 125;
      const cryptoOnly = true;
      break;
      
    case 'mt4':
    case 'mt5':
      // MetaTrader platform settings
      const forexFocus = true;
      break;
      
    default:
      bdpo.log(`Unknown exchange: ${exchange}`);
  }
  
  // Log exchange in trade records
  const symbol = bdpo.getSymbol();
  bdpo.log(`${symbol} @ ${exchange}: Strategy active`);
}

Copy

// Calculate total volume over last 10 periods
const volumes: number[] = bdpo.getVolume(data).slice(-10);
const totalVolume: number = bdpo.sum(volumes);

// Calculate cumulative returns
const returns: number[] = [];
const prices: number[] = bdpo.getClose(data);
for (let i = 1; i < prices.length; i++) {
  const dailyReturn: number = (prices[i] - prices[i-1]) / prices[i-1];
  returns.push(dailyReturn);
}
const totalReturn: number = bdpo.sum(returns);

bdpo.log(`Total volume (10 periods): ${totalVolume}`);
bdpo.log(`Cumulative return: ${(totalReturn * 100).toFixed(2)}%`);

Copy

// Calculate average price over last 20 periods
const prices: number[] = bdpo.getClose(data).slice(-20);
const avgPrice: number = bdpo.mean(prices);

// Calculate average daily range
const highs: number[] = bdpo.getHigh(data);
const lows: number[] = bdpo.getLow(data);
const ranges: number[] = highs.map((high: number, i: number) => high - lows[i]);
const avgRange: number = bdpo.mean(ranges.slice(-30));

// Performance metrics
const currentPrice: number = prices[prices.length - 1];
const distanceFromAvg: number = ((currentPrice - avgPrice) / avgPrice) * 100;

bdpo.log(`Average price (20 periods): ${avgPrice.toFixed(4)}`);
bdpo.log(`Average range (30 periods): ${avgRange.toFixed(4)}`);
bdpo.log(`Distance from average: ${distanceFromAvg.toFixed(2)}%`);

Copy

// Find median price for support/resistance analysis
const prices: number[] = bdpo.getClose(data).slice(-50);
const medianPrice: number = bdpo.median(prices);

// Compare current price to median
const currentPrice: number = prices[prices.length - 1];
const meanPrice: number = bdpo.mean(prices);

// Median is less sensitive to outliers than mean
const meanVsMedian: number = meanPrice - medianPrice;

if (Math.abs(meanVsMedian) > medianPrice * 0.01) {
  bdpo.log("Significant skew detected in price distribution");
}

bdpo.log(`Median price: ${medianPrice.toFixed(4)}`);
bdpo.log(`Mean vs Median difference: ${meanVsMedian.toFixed(4)}`);

Copy

// Calculate price volatility using returns
const prices: number[] = bdpo.getClose(data);
const returns: number[] = [];

// Calculate daily returns
for (let i = 1; i < prices.length; i++) {
  const dailyReturn: number = (prices[i] - prices[i-1]) / prices[i-1];
  returns.push(dailyReturn);
}

// Statistical measures of volatility
const returnVariance: number = bdpo.variance(returns.slice(-30));
const returnStdDev: number = bdpo.std(returns.slice(-30));
const annualizedVolatility: number = returnStdDev * Math.sqrt(252); // 252 trading days

// Risk assessment
const currentReturn: number = returns[returns.length - 1];
const zScore: number = Math.abs(currentReturn) / returnStdDev;

if (zScore > 2) {
  bdpo.log("Unusual price movement detected (>2 standard deviations)");
}

bdpo.log(`30-day volatility (annualized): ${(annualizedVolatility * 100).toFixed(2)}%`);
bdpo.log(`Current move Z-score: ${zScore.toFixed(2)}`);

Copy

// Advanced statistical analysis for trading patterns
const prices: number[] = bdpo.getClose(data).slice(-100);

// Round prices to significant levels for mode analysis
const roundedPrices: number[] = prices.map((price: number) => {
  const decimalPlaces: number = 2; // Round to nearest cent
  return bdpo.round(price, decimalPlaces);
});

// Find most common price levels (support/resistance)
const priceMode: number[] = bdpo.mode(roundedPrices);
const modeLevel: number = Array.isArray(priceMode) ? priceMode[0] : priceMode;

// Robust volatility using MAD (less sensitive to outliers than std dev)
const returns: number[] = [];
for (let i = 1; i < prices.length; i++) {
  const dailyReturn: number = (prices[i] - prices[i-1]) / prices[i-1];
  returns.push(dailyReturn);
}

const madVolatility: number = bdpo.mad(returns);
const stdVolatility: number = bdpo.std(returns);
const robustnessRatio: number = madVolatility / stdVolatility; // Lower = more outliers

// Compound growth calculation using product
const periodReturns: number[] = returns.slice(-20).map((ret: number) => 1 + ret);
const compoundReturn: number = bdpo.prod(periodReturns) - 1;
const avgDailyReturn: number = bdpo.pow(bdpo.prod(periodReturns), 1/20) - 1;

// Risk-adjusted metrics
const currentPrice: number = prices[prices.length - 1];
const distanceFromMode: number = Math.abs(currentPrice - modeLevel) / currentPrice;
const madScore: number = Math.abs(returns[returns.length - 1]) / madVolatility;

// Price clustering analysis
const priceDistances: number[] = roundedPrices.map(price => Math.abs(price - modeLevel));
const avgDistanceFromMode: number = bdpo.mean(priceDistances);

bdpo.log(`Statistical Analysis (100 periods):`);
bdpo.log(`Most common price level: ${modeLevel.toFixed(4)}`);
bdpo.log(`Current distance from mode: ${(distanceFromMode * 100).toFixed(2)}%`);
bdpo.log(`MAD volatility: ${(madVolatility * 100).toFixed(3)}%`);
bdpo.log(`Std volatility: ${(stdVolatility * 100).toFixed(3)}%`);
bdpo.log(`Robustness ratio: ${robustnessRatio.toFixed(2)} (lower = more outliers)`);
bdpo.log(`20-day compound return: ${(compoundReturn * 100).toFixed(2)}%`);
bdpo.log(`Average daily return: ${(avgDailyReturn * 100).toFixed(3)}%`);
bdpo.log(`Current MAD score: ${madScore.toFixed(2)}`);

Copy

// Find key levels for last 50 periods
const highs: number[] = bdpo.getHigh(data).slice(-50);
const lows: number[] = bdpo.getLow(data).slice(-50);
const closes: number[] = bdpo.getClose(data).slice(-50);

const resistance: number = bdpo.max(highs);
const support: number = bdpo.min(lows);
const priceRange: number = bdpo.range(closes);

const currentPrice: number = closes[closes.length - 1];

// Distance to key levels
const distanceToResistance: number = ((resistance - currentPrice) / currentPrice) * 100;
const distanceToSupport: number = ((currentPrice - support) / currentPrice) * 100;

// Range analysis
const avgClose: number = bdpo.mean(closes);
const rangePercentage: number = (priceRange / avgClose) * 100;

bdpo.log(`Resistance: ${resistance.toFixed(4)} (${distanceToResistance.toFixed(2)}% away)`);
bdpo.log(`Support: ${support.toFixed(4)} (${distanceToSupport.toFixed(2)}% away)`);
bdpo.log(`50-period range: ${rangePercentage.toFixed(2)}% of average price`);

Copy

// Calculate distance metrics
const currentPrice: number = bdpo.getClose(data)[data.length - 1];
const sma20: number[] = bdpo.sma(bdpo.getClose(data), 20);
const currentSMA: number = sma20[sma20.length - 1];

// Absolute distance from moving average
const distance: number = bdpo.abs(currentPrice - currentSMA);
const distancePercent: number = (distance / currentSMA) * 100;

// Squared distance for penalty functions
const squaredDistance: number = bdpo.pow(distance / currentSMA, 2);

// Root mean square calculation for volatility
const returns: number[] = [];
const prices: number[] = bdpo.getClose(data);
for (let i = 1; i < 21; i++) {
  const ret: number = (prices[prices.length - i] - prices[prices.length - i - 1]) / prices[prices.length - i - 1];
  returns.push(bdpo.pow(ret, 2));
}
const rmsVolatility: number = bdpo.sqrt(bdpo.mean(returns));

bdpo.log(`Distance from SMA: ${distancePercent.toFixed(2)}%`);
bdpo.log(`RMS Volatility: ${(rmsVolatility * 100).toFixed(2)}%`);

Copy

// Calculate logarithmic returns (continuous compounding)
const prices: number[] = bdpo.getClose(data);
const logReturns: number[] = [];

for (let i = 1; i < prices.length; i++) {
  const logReturn: number = bdpo.log(prices[i] / prices[i-1]);
  logReturns.push(logReturn);
}

// Log returns are additive and normally distributed
const totalLogReturn: number = bdpo.sum(logReturns.slice(-30));
const avgDailyLogReturn: number = bdpo.mean(logReturns.slice(-30));
const logReturnVolatility: number = bdpo.std(logReturns.slice(-30));

// Convert back to simple returns
const totalSimpleReturn: number = Math.exp(totalLogReturn) - 1;

// Log transformation for price scaling
const logPrices: number[] = prices.map((price: number) => bdpo.log10(price));
const logPriceRange: number = bdpo.range(logPrices.slice(-50));

bdpo.log(`30-day total return: ${(totalSimpleReturn * 100).toFixed(2)}%`);
bdpo.log(`Daily log return volatility: ${(logReturnVolatility * 100).toFixed(3)}%`);

Copy

// Volume-price relationship analysis
const volumes: number[] = bdpo.getVolume(data).slice(-30);
const prices: number[] = bdpo.getClose(data).slice(-30);

// Cube root transformation for volume analysis (reduces outlier impact)
const cbrtVolumes: number[] = volumes.map((vol: number) => bdpo.cbrt(vol));
const avgCbrtVolume: number = bdpo.mean(cbrtVolumes);
const currentCbrtVolume: number = bdpo.cbrt(volumes[volumes.length - 1]);

// Exponential decay weighting for recent data
const decayFactor: number = 0.1;
let weightedSum: number = 0;
let totalWeight: number = 0;

for (let i = 0; i < prices.length; i++) {
  const weight: number = bdpo.exp(-decayFactor * (prices.length - 1 - i));
  weightedSum += prices[i] * weight;
  totalWeight += weight;
}
const exponentialMA: number = weightedSum / totalWeight;

// Trend direction analysis using sign function
const priceDiffs: number[] = bdpo.diff(prices);
const trendSigns: number[] = priceDiffs.map((diff: number) => bdpo.sign(diff));
const bullishBars: number = trendSigns.filter((sign: number) => sign > 0).length;
const bearishBars: number = trendSigns.filter((sign: number) => sign < 0).length;
const trendStrength: number = (bullishBars - bearishBars) / trendSigns.length;

bdpo.log(`Volume analysis: Current/Avg = ${(currentCbrtVolume / avgCbrtVolume).toFixed(2)}`);
bdpo.log(`Exponential MA: ${exponentialMA.toFixed(4)}`);
bdpo.log(`Trend strength: ${(trendStrength * 100).toFixed(1)}% (${bullishBars}↑ ${bearishBars}↓)`);

Copy

// Cyclical market analysis using trigonometric functions
const prices: number[] = bdpo.getClose(data);
const periods: number = 20; // 20-day cycle analysis

// Generate sine wave oscillator for cycle detection
const cycleValues: number[] = [];
for (let i = 0; i < prices.length; i++) {
  const angle: number = (2 * Math.PI * i) / periods;
  const sineValue: number = bdpo.sin(angle);
  const cosineValue: number = bdpo.cos(angle);
  
  // Combine sine and cosine for quadrature oscillator
  const cycleValue: number = sineValue * 0.7 + cosineValue * 0.3;
  cycleValues.push(cycleValue);
}

// Price momentum direction analysis
const priceReturns: number[] = [];
for (let i = 1; i < prices.length; i++) {
  const returnValue: number = (prices[i] - prices[i-1]) / prices[i-1];
  priceReturns.push(returnValue);
}

// Convert price movements to angular representation
const currentReturn: number = priceReturns[priceReturns.length - 1];
const avgReturn: number = bdpo.mean(priceReturns.slice(-30));

// Use atan2 for quadrant-aware angle calculation
const momentumAngle: number = bdpo.atan2(currentReturn, avgReturn);
const momentumDegrees: number = (momentumAngle * 180) / Math.PI;

// Trend strength using arctangent transformation
const normalizedReturns: number[] = priceReturns.slice(-30).map((ret: number) => {
  return bdpo.atan(ret * 100) * (2 / Math.PI); // Normalize to [-1, 1]
});

const trendStrength: number = bdpo.mean(normalizedReturns);
const trendConsistency: number = 1 - bdpo.std(normalizedReturns);

// Seasonal pattern detection
const dayOfCycle: number = prices.length % periods;
const seasonalPhase: number = (2 * Math.PI * dayOfCycle) / periods;
const expectedCycleValue: number = bdpo.sin(seasonalPhase);

bdpo.log(`Cycle Analysis (${periods}-day):`);
bdpo.log(`Current cycle position: ${(dayOfCycle / periods * 100).toFixed(1)}%`);
bdpo.log(`Expected cycle value: ${expectedCycleValue.toFixed(3)}`);
bdpo.log(`Momentum angle: ${momentumDegrees.toFixed(1)}°`);
bdpo.log(`Trend strength: ${(trendStrength * 100).toFixed(1)}%`);
bdpo.log(`Trend consistency: ${(trendConsistency * 100).toFixed(1)}%`);

Copy

// Cumulative P&L analysis
const prices: number[] = bdpo.getClose(data);
const returns: number[] = [];

for (let i = 1; i < prices.length; i++) {
  const dailyReturn: number = (prices[i] - prices[i-1]) / prices[i-1];
  returns.push(dailyReturn);
}

// Cumulative returns for equity curve
const cumulativeReturns: number[] = bdpo.cumsum(returns);
const equityCurve: number[] = cumulativeReturns.map((ret: number) => 10000 * (1 + ret));

// Price differences for momentum analysis
const priceDiffs: number[] = bdpo.diff(prices.slice(-30));
const avgPriceChange: number = bdpo.mean(priceDiffs);

// Sorted returns for percentile analysis
const sortedReturns: number[] = bdpo.sort(returns.slice(-100));
const medianReturn: number = bdpo.median(sortedReturns);
const percentile95: number = bdpo.percentile(sortedReturns, 95);
const percentile5: number = bdpo.percentile(sortedReturns, 5);

// Risk metrics
const valueAtRisk5: number = Math.abs(percentile5) * 100; // 5% VaR

bdpo.log(`Current equity: ${equityCurve[equityCurve.length - 1].toFixed(2)}`);
bdpo.log(`Average daily price change: ${avgPriceChange.toFixed(4)}`);
bdpo.log(`5% Value at Risk: ${valueAtRisk5.toFixed(2)}%`);

Copy

// Support and resistance level analysis using unique values
const highs: number[] = bdpo.getHigh(data).slice(-100);
const lows: number[] = bdpo.getLow(data).slice(-100);

// Round to meaningful price levels for clustering analysis
const precision: number = 4; // 4 decimal places
const roundedHighs: number[] = highs.map((high: number) => bdpo.round(high, precision));
const roundedLows: number[] = lows.map((low: number) => bdpo.round(low, precision));

// Find unique price levels
const uniqueHighs: number[] = bdpo.unique(roundedHighs);
const uniqueLows: number[] = bdpo.unique(roundedLows);

// Count frequency of each level for significance
const highFrequency: Map = new Map();
const lowFrequency: Map = new Map();

roundedHighs.forEach((high: number) => {
  highFrequency.set(high, (highFrequency.get(high) || 0) + 1);
});

roundedLows.forEach((low: number) => {
  lowFrequency.set(low, (lowFrequency.get(low) || 0) + 1);
});

// Find most significant levels (appeared multiple times)
const significantResistance: number[] = uniqueHighs.filter((level: number) => 
  (highFrequency.get(level) || 0) >= 3
);
const significantSupport: number[] = uniqueLows.filter((level: number) => 
  (lowFrequency.get(level) || 0) >= 3
);

// Current price analysis
const currentPrice: number = bdpo.getClose(data)[data.length - 1];
const nearestResistance: number = significantResistance
  .filter((level: number) => level > currentPrice)
  .reduce((nearest: number, level: number) => 
    Math.abs(level - currentPrice) < Math.abs(nearest - currentPrice) ? level : nearest,
    significantResistance[0]
  );

const nearestSupport: number = significantSupport
  .filter((level: number) => level < currentPrice)
  .reduce((nearest: number, level: number) => 
    Math.abs(level - currentPrice) < Math.abs(nearest - currentPrice) ? level : nearest,
    significantSupport[0]
  );

// Calculate distances and ratios
const resistanceDistance: number = ((nearestResistance - currentPrice) / currentPrice) * 100;
const supportDistance: number = ((currentPrice - nearestSupport) / currentPrice) * 100;

// Unique value statistics
const priceRange: number = bdpo.max(highs) - bdpo.min(lows);
const uniqueHighCount: number = uniqueHighs.length;
const uniqueLowCount: number = uniqueLows.length;
const consolidationRatio: number = 1 - (uniqueHighCount + uniqueLowCount) / (highs.length + lows.length);

bdpo.log(`Price Level Analysis (100 periods):`);
bdpo.log(`Unique high levels: ${uniqueHighCount} / Unique low levels: ${uniqueLowCount}`);
bdpo.log(`Significant resistance levels: ${significantResistance.length}`);
bdpo.log(`Significant support levels: ${significantSupport.length}`);
bdpo.log(`Nearest resistance: ${nearestResistance?.toFixed(precision)} (${resistanceDistance?.toFixed(2)}% away)`);
bdpo.log(`Nearest support: ${nearestSupport?.toFixed(precision)} (${supportDistance?.toFixed(2)}% away)`);
bdpo.log(`Consolidation ratio: ${(consolidationRatio * 100).toFixed(1)}%`);

Copy

// Position sizing with constraints
const accountBalance: number = bdpo.getBalance();
const riskPercent: number = 2.5;
const currentPrice: number = bdpo.getAsk();

// Calculate raw position size
const riskAmount: number = accountBalance * (riskPercent / 100);
const rawPositionSize: number = riskAmount / currentPrice;

// Apply broker constraints
const minLotSize: number = bdpo.getMinQty() || 0.01;
const maxLotSize: number = bdpo.getMaxQty() || 100;
const stepSize: number = bdpo.getStepSize() || 0.01;

// Round to valid lot size
const roundedSize: number = bdpo.floor(rawPositionSize / stepSize) * stepSize;
const constrainedSize: number = bdpo.clamp(roundedSize, minLotSize, maxLotSize);

// Price formatting for orders
const stopLoss: number = currentPrice * 0.98;
const takeProfit: number = currentPrice * 1.04;
const precision: number = bdpo.getPrecision() || 5;

const formattedStopLoss: number = bdpo.round(stopLoss, precision);
const formattedTakeProfit: number = bdpo.round(takeProfit, precision);

// Risk calculation
const actualRisk: number = constrainedSize * currentPrice * 0.02; // 2% price move
const riskPercentage: number = (actualRisk / accountBalance) * 100;

bdpo.log(`Position size: ${constrainedSize} lots`);
bdpo.log(`Stop Loss: ${formattedStopLoss}`);
bdpo.log(`Take Profit: ${formattedTakeProfit}`);
bdpo.log(`Actual risk: ${riskPercentage.toFixed(2)}%`);

Copy

// Risk analysis using percentiles
const prices: number[] = bdpo.getClose(data);
const returns: number[] = [];

for (let i = 1; i < prices.length; i++) {
  const dailyReturn: number = (prices[i] - prices[i-1]) / prices[i-1];
  returns.push(dailyReturn);
}

// Value at Risk (VaR) calculations
const var95: number = bdpo.percentile(returns.slice(-252), 5); // 5th percentile = 95% VaR
const var99: number = bdpo.percentile(returns.slice(-252), 1); // 1st percentile = 99% VaR

// Expected Shortfall (average of worst 5% outcomes)
const sortedReturns: number[] = bdpo.sort(returns.slice(-252));
const worst5Percent: number[] = sortedReturns.slice(0, Math.floor(sortedReturns.length * 0.05));
const expectedShortfall: number = bdpo.mean(worst5Percent);

// Performance percentiles
const currentReturn: number = returns[returns.length - 1];
const returnRank: number = returns.filter(r => r <= currentReturn).length / returns.length;
const percentileRank: number = returnRank * 100;

// Quartile analysis
const q1: number = bdpo.quantileSeq(returns.slice(-100), 0.25);
const q2: number = bdpo.quantileSeq(returns.slice(-100), 0.50); // median
const q3: number = bdpo.quantileSeq(returns.slice(-100), 0.75);
const iqr: number = q3 - q1; // Interquartile range

bdpo.log(`95% VaR: ${(Math.abs(var95) * 100).toFixed(2)}%`);
bdpo.log(`99% VaR: ${(Math.abs(var99) * 100).toFixed(2)}%`);
bdpo.log(`Expected Shortfall: ${(Math.abs(expectedShortfall) * 100).toFixed(2)}%`);
bdpo.log(`Current return percentile: ${percentileRank.toFixed(1)}%`);

Copy

// Monte Carlo simulation for risk assessment
function runMonteCarloSimulation(initialPrice: number, days: number, numSimulations: number): number[] {
  const finalPrices: number[] = [];
  const avgReturn: number = 0.0008; // 0.08% daily return
  const volatility: number = 0.02; // 2% daily volatility
  
  for (let sim = 0; sim < numSimulations; sim++) {
    let price: number = initialPrice;
    
    for (let day = 0; day < days; day++) {
      // Generate random return using Box-Muller transformation
      const u1: number = bdpo.random();
      const u2: number = bdpo.random();
      const z: number = bdpo.sqrt(-2 * bdpo.log(u1)) * Math.cos(2 * Math.PI * u2);
      
      const dailyReturn: number = avgReturn + volatility * z;
      price = price * (1 + dailyReturn);
    }
    
    finalPrices.push(price);
  }
  
  return finalPrices;
}

// Run simulation
const currentPrice: number = bdpo.getClose(data)[data.length - 1];
const simulatedPrices: number[] = runMonteCarloSimulation(currentPrice, 30, 1000);

// Analyze results
const avgFinalPrice: number = bdpo.mean(simulatedPrices);
const priceVolatility: number = bdpo.std(simulatedPrices);
const priceRange: number = bdpo.range(simulatedPrices);

// Risk metrics from simulation
const var95Simulation: number = bdpo.percentile(simulatedPrices, 5);
const expectedPrice: number = avgFinalPrice;
const worstCase: number = bdpo.min(simulatedPrices);
const bestCase: number = bdpo.max(simulatedPrices);

// Random portfolio rebalancing
const assets: string[] = ['BTC', 'ETH', 'SOL', 'ADA'];
const randomAsset: string = assets[bdpo.randomInt(0, assets.length - 1)];
const randomWeight: number = bdpo.random() * 0.3 + 0.1; // 10-40% allocation

bdpo.log(`Monte Carlo Results (30 days, 1000 simulations):`);
bdpo.log(`Expected price: ${expectedPrice.toFixed(2)}`);
bdpo.log(`95% confidence range: ${var95Simulation.toFixed(2)} - ${bdpo.percentile(simulatedPrices, 95).toFixed(2)}`);
bdpo.log(`Random rebalance: ${randomWeight.toFixed(1)}% to ${randomAsset}`);

Copy

// Correlation analysis using dot product
const prices1: number[] = bdpo.getClose(data).slice(-30);
const prices2: number[] = bdpo.getClose(referenceData).slice(-30);

// Normalize price series (subtract mean, divide by std)
const mean1: number = bdpo.mean(prices1);
const mean2: number = bdpo.mean(prices2);
const std1: number = bdpo.std(prices1);
const std2: number = bdpo.std(prices2);

const normalized1: number[] = prices1.map(p => (p - mean1) / std1);
const normalized2: number[] = prices2.map(p => (p - mean2) / std2);

// Calculate correlation using dot product
const correlation: number = bdpo.dot(normalized1, normalized2) / normalized1.length;

// Vector magnitude analysis
const returns1: number[] = bdpo.diff(prices1);
const returns2: number[] = bdpo.diff(prices2);

const magnitude1: number = bdpo.norm(returns1);
const magnitude2: number = bdpo.norm(returns2);

// Relative strength comparison
const strengthRatio: number = magnitude1 / magnitude2;

// Portfolio diversification analysis
const weights: number[] = [0.6, 0.4]; // 60% asset1, 40% asset2
const returns: number[] = [normalized1[normalized1.length - 1], normalized2[normalized2.length - 1]];

const portfolioReturn: number = bdpo.dot(weights, returns);
const portfolioRisk: number = bdpo.norm([
  weights[0] * returns[0],
  weights[1] * returns[1]
]);

bdpo.log(`Correlation: ${correlation.toFixed(3)}`);
bdpo.log(`Relative strength: ${strengthRatio.toFixed(2)}`);
bdpo.log(`Portfolio return: ${(portfolioReturn * 100).toFixed(2)}%`);
bdpo.log(`Portfolio risk: ${(portfolioRisk * 100).toFixed(2)}%`);

Copy

// Basic logging (info level by default)
bdpo.log("Strategy started successfully");

// Explicit log levels
bdpo.log("Market conditions analyzed", "info");
bdpo.log("High volatility detected", "warn");
bdpo.log("Order execution failed", "error");
bdpo.log("Position opened successfully", "success");
bdpo.log("Debug: RSI calculation complete", "debug");

// Conditional logging based on strategy state
const rsi: number[] = bdpo.rsi(bdpo.getClose(data), 14);
const currentRSI: number = rsi[rsi.length - 1];

if (currentRSI > 70) {
  bdpo.log(`RSI overbought: ${currentRSI.toFixed(2)}`, "warn");
} else if (currentRSI < 30) {
  bdpo.log(`RSI oversold: ${currentRSI.toFixed(2)}`, "warn");
} else {
  bdpo.log(`RSI normal: ${currentRSI.toFixed(2)}`, "info");
}

// Log complex trading decisions
const signal = analyzeMarketConditions();
if (signal.action === "buy") {
  bdpo.log(`BUY Signal: Confidence ${signal.confidence}%, Entry ${signal.price}`, "success");
} else if (signal.action === "sell") {
  bdpo.log(`SELL Signal: Confidence ${signal.confidence}%, Entry ${signal.price}`, "error");
}

Copy

// Strategy initialization
bdpo.logInfo("Strategy initialization complete");
bdpo.logInfo(`Trading ${bdpo.getSymbol()} on ${bdpo.getExchange()}`);

// Market analysis updates
const currentPrice: number = bdpo.getClose(data)[data.length - 1];
const sma20: number[] = bdpo.sma(bdpo.getClose(data), 20);
bdpo.logInfo(`Current price: ${currentPrice.toFixed(4)}, SMA20: ${sma20[sma20.length - 1].toFixed(4)}`);

// Position updates
const openPositions: any[] = bdpo.getOpenPositions();
bdpo.logInfo(`Active positions: ${openPositions.length}`);

// Performance reporting
const balance: number = bdpo.getBalance();
const equity: number = bdpo.getEquity();
const profit: number = bdpo.getProfit();
bdpo.logInfo(`Balance: ${balance.toFixed(2)}, Equity: ${equity.toFixed(2)}, P&L: ${profit.toFixed(2)}`);

Copy

// Risk management warnings
const balance: number = bdpo.getBalance();
const equity: number = bdpo.getEquity();
const drawdown: number = ((balance - equity) / balance) * 100;

if (drawdown > 10) {
  bdpo.logWarn(`High drawdown detected: ${drawdown.toFixed(2)}%`);
}

// Market condition warnings
const spread: number = bdpo.getSpread();
if (spread > 3.0) {
  bdpo.logWarn(`Wide spread detected: ${spread.toFixed(1)} pips`);
}

// Volatility warnings
const atr: number[] = bdpo.atr(bdpo.getHigh(data), bdpo.getLow(data), bdpo.getClose(data), 14);
const currentATR: number = atr[atr.length - 1];
const avgATR: number = bdpo.mean(atr.slice(-50));

if (currentATR > avgATR * 2) {
  bdpo.logWarn(`High volatility: ATR ${currentATR.toFixed(4)} vs avg ${avgATR.toFixed(4)}`);
}

// Position size warnings
const openPositions: any[] = bdpo.getOpenPositions();
if (openPositions.length > 5) {
  bdpo.logWarn(`High position count: ${openPositions.length} open trades`);
}

Copy

// Order execution errors
try {
  const result = bdpo.orderSend({
    orderType: "BUY",
    lotSize: 1.0,
    stopLoss: 1.2500,
    takeProfit: 1.2800
  });
  
  if (!result.success) {
    bdpo.logError(`Order failed: ${result.message}`);
  }
} catch (error) {
  bdpo.logError(`Order execution exception: ${error.message}`);
}

// Data validation errors
const chartData: any[] = bdpo.getChartData(data);
if (!chartData || chartData.length === 0) {
  bdpo.logError("No chart data available - cannot proceed with analysis");
  return;
}

// Calculation errors
try {
  const rsi: number[] = bdpo.rsi(bdpo.getClose(data), 14);
  if (rsi.length === 0) {
    bdpo.logError("RSI calculation failed - insufficient data");
  }
} catch (error) {
  bdpo.logError(`Technical indicator error: ${error.message}`);
}

// Account status errors
const balance: number = bdpo.getBalance();
if (balance <= 0) {
  bdpo.logError("Account balance is zero or negative - trading halted");
}

Copy

// Successful trade execution
const orderResult = bdpo.orderSend({
  orderType: "BUY",
  lotSize: 1.0,
  stopLoss: 1.2500,
  takeProfit: 1.2800
});

if (orderResult.success) {
  bdpo.logSuccess(`Order placed successfully: ${orderResult.orderId}`);
  bdpo.logSuccess(`Entry: ${orderResult.price}, SL: ${orderResult.stopLoss}, TP: ${orderResult.takeProfit}`);
}

// Profit targets achieved
const closedPositions: any[] = bdpo.getClosedPositions();
const recentTrades = closedPositions.slice(-10);
const winningTrades = recentTrades.filter(trade => trade.profit > 0);

if (winningTrades.length >= 7) {
  bdpo.logSuccess(`Strong performance: ${winningTrades.length}/10 winning trades`);
}

// Milestone achievements
const totalProfit: number = bdpo.getProfit();
if (totalProfit > 1000) {
  bdpo.logSuccess(`Milestone achieved: Total profit exceeds $1,000 (${totalProfit.toFixed(2)})`);
}

// Risk management success
const maxDrawdown: number = calculateMaxDrawdown();
if (maxDrawdown < 5) {
  bdpo.logSuccess(`Excellent risk control: Max drawdown only ${maxDrawdown.toFixed(2)}%`);
}

Copy

// Variable state debugging
const prices: number[] = bdpo.getClose(data);
const volumes: number[] = bdpo.getVolume(data);

bdpo.logDebug(`Data length: ${prices.length} candles`);
bdpo.logDebug(`Latest price: ${prices[prices.length - 1]}`);
bdpo.logDebug(`Latest volume: ${volumes[volumes.length - 1]}`);

// Calculation step debugging
const sma20: number[] = bdpo.sma(prices, 20);
const ema12: number[] = bdpo.ema(prices, 12);
const rsi: number[] = bdpo.rsi(prices, 14);

bdpo.logDebug(`SMA20: ${sma20[sma20.length - 1].toFixed(4)}`);
bdpo.logDebug(`EMA12: ${ema12[ema12.length - 1].toFixed(4)}`);
bdpo.logDebug(`RSI14: ${rsi[rsi.length - 1].toFixed(2)}`);

// Signal generation debugging
const signalStrength: number = calculateSignalStrength();
const marketCondition: string = analyzeMarketCondition();

bdpo.logDebug(`Signal strength: ${signalStrength.toFixed(3)}`);
bdpo.logDebug(`Market condition: ${marketCondition}`);

// Performance debugging
const executionStart: number = performance.now();
const complexCalculation = performComplexAnalysis();
const executionTime: number = performance.now() - executionStart;

bdpo.logDebug(`Complex analysis completed in ${executionTime.toFixed(2)}ms`);
bdpo.logDebug(`Analysis result: ${JSON.stringify(complexCalculation)}`);

Copy

// Strategy lifecycle logging
class TradingStrategy {
  public riskPercent: number = 2;
  public stopLossPercent: number = 3;
  
  private _positions: any[] = [];
  private _initialized: boolean = false;

  __init__(): void {
    bdpo.logInfo("Initializing trading strategy...");
    
    try {
      this._positions = [];
      this._initialized = true;
      bdpo.logSuccess("Strategy initialization completed successfully");
      bdpo.logInfo(`Risk per trade: ${this.riskPercent}%, Stop loss: ${this.stopLossPercent}%`);
    } catch (error) {
      bdpo.logError(`Strategy initialization failed: ${error.message}`);
      this._initialized = false;
    }
  }

  __tick__(): any {
    if (!this._initialized) {
      bdpo.logError("Strategy not initialized - skipping tick");
      return null;
    }

    bdpo.logDebug("Processing new market tick...");
    
    // Market analysis
    const prices: number[] = bdpo.getClose(data);
    const currentPrice: number = prices[prices.length - 1];
    const sma20: number[] = bdpo.sma(prices, 20);
    const rsi: number[] = bdpo.rsi(prices, 14);
    
    bdpo.logDebug(`Price: ${currentPrice}, SMA20: ${sma20[sma20.length - 1].toFixed(4)}, RSI: ${rsi[rsi.length - 1].toFixed(2)}`);
    
    // Risk management checks
    const accountBalance: number = bdpo.getBalance();
    const openPositions: any[] = bdpo.getOpenPositions();
    
    if (openPositions.length >= 5) {
      bdpo.logWarn(`Maximum positions reached: ${openPositions.length}/5`);
      return null;
    }
    
    if (accountBalance < 1000) {
      bdpo.logWarn(`Low account balance: $${accountBalance.toFixed(2)}`);
    }
    
    // Signal generation
    const signal = this.generateSignal(currentPrice, sma20, rsi);
    
    if (signal.type === "BUY") {
      bdpo.logInfo(`BUY signal detected: ${signal.reason}`);
      this.executeBuyOrder(signal);
    } else if (signal.type === "SELL") {
      bdpo.logInfo(`SELL signal detected: ${signal.reason}`);
      this.executeSellOrder(signal);
    } else {
      bdpo.logDebug("No trading signal - holding position");
    }
    
    return {
      currentPrice,
      signal: signal.type,
      openPositions: openPositions.length
    };
  }

  private executeBuyOrder(signal: any): void {
    try {
      const orderResult = bdpo.orderSend({
        symbol: bdpo.getSymbol(),
        cmd: 0, // Buy
        volume: this.calculatePositionSize(),
        price: signal.price,
        slippage: 3,
        stoploss: signal.stopLoss,
        takeprofit: signal.takeProfit
      });
      
      if (orderResult && orderResult.ticket) {
        bdpo.logSuccess(`BUY order executed: Ticket #${orderResult.ticket}, Price: ${signal.price}`);
        this._positions.push(orderResult);
      } else {
        bdpo.logError("BUY order execution failed - no ticket returned");
      }
    } catch (error) {
      bdpo.logError(`BUY order execution error: ${error.message}`);
    }
  }

  private executeSellOrder(signal: any): void {
    try {
      const openLongs = this._positions.filter(pos => pos.cmd === 0 && pos.close_time === 0);
      
      if (openLongs.length === 0) {
        bdpo.logWarn("SELL signal but no open long positions to close");
        return;
      }
      
      openLongs.forEach(position => {
        const closeResult = bdpo.orderClose(position.ticket, position.volume, signal.price, 3);
        if (closeResult) {
          bdpo.logSuccess(`Position closed: Ticket #${position.ticket}, Exit: ${signal.price}`);
        } else {
          bdpo.logError(`Failed to close position: Ticket #${position.ticket}`);
        }
      });
    } catch (error) {
      bdpo.logError(`SELL order execution error: ${error.message}`);
    }
  }

  __shutdown__(): void {
    bdpo.logInfo("Shutting down trading strategy...");
    
    try {
      // Close all open positions
      const openPositions = this._positions.filter(pos => pos.close_time === 0);
      if (openPositions.length > 0) {
        bdpo.logWarn(`Closing ${openPositions.length} open positions during shutdown`);
        openPositions.forEach(pos => {
          bdpo.orderClose(pos.ticket, pos.volume, bdpo.getAsk(), 5);
        });
      }
      
      bdpo.logSuccess("Strategy shutdown completed");
      bdpo.logInfo(`Final statistics: ${this._positions.length} total trades executed`);
    } catch (error) {
      bdpo.logError(`Strategy shutdown error: ${error.message}`);
    }
  }
}

Copy

// Advanced debugging patterns for strategy development

class AdvancedTradingStrategy {
  public debugMode: boolean = true;
  public logLevel: string = "debug";
  
  private _executionTimes: number[] = [];
  private _decisionLog: any[] = [];

  __tick__(): any {
    const startTime: number = performance.now();
    
    if (this.debugMode) {
      bdpo.logDebug("=== TICK START ===");
    }
    
    try {
      // 1. Variable state tracking
      const marketData = this.getMarketData();
      this.logVariableState("Market Data", marketData);
      
      // 2. Decision flow tracking
      const decision = this.makeDecision(marketData);
      this.logDecisionFlow(decision);
      
      // 3. Performance monitoring
      const endTime: number = performance.now();
      const executionTime: number = endTime - startTime;
      this._executionTimes.push(executionTime);
      
      if (this.debugMode) {
        bdpo.logDebug(`Execution time: ${executionTime.toFixed(2)}ms`);
        bdpo.logDebug("=== TICK END ===");
      }
      
      // 4. Periodic performance reports
      if (this._executionTimes.length % 100 === 0) {
        this.logPerformanceReport();
      }
      
      return decision;
      
    } catch (error) {
      // 5. Comprehensive error logging
      this.logError("Tick execution error", error, {
        marketData: this.getMarketData(),
        executionTime: performance.now() - startTime,
        tickCount: this._executionTimes.length
      });
      return null;
    }
  }

  private getMarketData(): any {
    const prices: number[] = bdpo.getClose(data);
    const volumes: number[] = bdpo.getVolume(data);
    
    return {
      currentPrice: prices[prices.length - 1],
      previousPrice: prices[prices.length - 2],
      currentVolume: volumes[volumes.length - 1],
      avgVolume: bdpo.mean(volumes.slice(-20)),
      timestamp: Date.now()
    };
  }

  private logVariableState(label: string, variables: any): void {
    if (!this.debugMode) return;
    
    bdpo.logDebug(`${label}:`);
    Object.entries(variables).forEach(([key, value]) => {
      bdpo.logDebug(`  ${key}: ${typeof value === 'number' ? value.toFixed(4) : value}`);
    });
  }

  private makeDecision(marketData: any): any {
    const decision = {
      action: "HOLD",
      confidence: 0,
      reasons: [],
      timestamp: Date.now()
    };
    
    // Example decision logic with detailed logging
    const priceChange = ((marketData.currentPrice - marketData.previousPrice) / marketData.previousPrice) * 100;
    const volumeRatio = marketData.currentVolume / marketData.avgVolume;
    
    bdpo.logDebug(`Price change: ${priceChange.toFixed(2)}%`);
    bdpo.logDebug(`Volume ratio: ${volumeRatio.toFixed(2)}`);
    
    if (priceChange > 1 && volumeRatio > 1.5) {
      decision.action = "BUY";
      decision.confidence = 75;
      decision.reasons.push("Strong upward momentum with high volume");
      bdpo.logInfo(`BUY decision: Price +${priceChange.toFixed(2)}%, Volume ${volumeRatio.toFixed(2)}x`);
    } else if (priceChange < -1 && volumeRatio > 1.5) {
      decision.action = "SELL";
      decision.confidence = 70;
      decision.reasons.push("Strong downward momentum with high volume");
      bdpo.logInfo(`SELL decision: Price ${priceChange.toFixed(2)}%, Volume ${volumeRatio.toFixed(2)}x`);
    } else {
      bdpo.logDebug(`HOLD decision: Insufficient momentum (Price: ${priceChange.toFixed(2)}%, Volume: ${volumeRatio.toFixed(2)}x)`);
    }
    
    return decision;
  }

  private logDecisionFlow(decision: any): void {
    this._decisionLog.push(decision);
    
    if (this.debugMode) {
      bdpo.logDebug(`Decision: ${decision.action} (${decision.confidence}% confidence)`);
      decision.reasons.forEach((reason: string) => {
        bdpo.logDebug(`  Reason: ${reason}`);
      });
    }
    
    // Log decision summary every 50 decisions
    if (this._decisionLog.length % 50 === 0) {
      this.logDecisionSummary();
    }
  }

  private logPerformanceReport(): void {
    const avgTime = bdpo.mean(this._executionTimes);
    const maxTime = bdpo.max(this._executionTimes);
    const minTime = bdpo.min(this._executionTimes);
    
    bdpo.logInfo("=== PERFORMANCE REPORT ===");
    bdpo.logInfo(`Avg execution time: ${avgTime.toFixed(2)}ms`);
    bdpo.logInfo(`Max execution time: ${maxTime.toFixed(2)}ms`);
    bdpo.logInfo(`Min execution time: ${minTime.toFixed(2)}ms`);
    bdpo.logInfo(`Total ticks processed: ${this._executionTimes.length}`);
    
    if (avgTime > 10) {
      bdpo.logWarn("High average execution time detected - consider optimization");
    }
  }

  private logDecisionSummary(): void {
    const recentDecisions = this._decisionLog.slice(-50);
    const buyCount = recentDecisions.filter(d => d.action === "BUY").length;
    const sellCount = recentDecisions.filter(d => d.action === "SELL").length;
    const holdCount = recentDecisions.filter(d => d.action === "HOLD").length;
    
    bdpo.logInfo("=== DECISION SUMMARY (Last 50) ===");
    bdpo.logInfo(`BUY: ${buyCount}, SELL: ${sellCount}, HOLD: ${holdCount}`);
    
    const avgConfidence = bdpo.mean(recentDecisions.map(d => d.confidence));
    bdpo.logInfo(`Average confidence: ${avgConfidence.toFixed(1)}%`);
  }

  private logError(message: string, error: any, context: any): void {
    bdpo.logError(`${message}: ${error.message}`);
    bdpo.logError(`Stack trace: ${error.stack}`);
    
    // Log relevant context
    bdpo.logError("Error context:");
    Object.entries(context).forEach(([key, value]) => {
      bdpo.logError(`  ${key}: ${JSON.stringify(value)}`);
    });
  }
}

Copy

class MovingAverageCrossoverStrategy {
  // Public configuration parameters
  public fastPeriod: number = 12;
  public slowPeriod: number = 26;
  public riskPercentPerTrade: number = 2; // 2% risk per trade
  public stopLossPercent: number = 3;     // 3% stop loss
  public takeProfitPercent: number = 9;   // 3:1 risk/reward ratio
  public maxPositions: number = 1;        // Maximum concurrent positions
  public enableTrailingStop: boolean = true;
  public trailingStopPercent: number = 1.5;

  // Private state variables
  private _positions: any[] = [];
  private _fastMA: number[] = [];
  private _slowMA: number[] = [];
  private _lastCrossover: string | null = null;
  private _tradeCount: number = 0;
  private _winCount: number = 0;

  __init__(): void {
    // Initialize strategy state
    this._positions = [];
    this._lastCrossover = null;
    this._tradeCount = 0;
    this._winCount = 0;
    
    bdpo.logInfo(`MA Crossover Strategy initialized:`);
    bdpo.logInfo(`Fast Period: ${this.fastPeriod}, Slow Period: ${this.slowPeriod}`);
    bdpo.logInfo(`Risk per trade: ${this.riskPercentPerTrade}%, Stop Loss: ${this.stopLossPercent}%`);
  }

  __tick__(): any {
    const prices: number[] = bdpo.getClosePrices();
    const currentPrice: number = prices[prices.length - 1];
    
    if (prices.length < this.slowPeriod + 1) {
      return { status: "warming_up", required: this.slowPeriod + 1, current: prices.length };
    }

    // Calculate moving averages
    this._fastMA = bdpo.ema(prices, this.fastPeriod);
    this._slowMA = bdpo.ema(prices, this.slowPeriod);

    const currentFast: number = this._fastMA[this._fastMA.length - 1];
    const currentSlow: number = this._slowMA[this._slowMA.length - 1];
    const prevFast: number = this._fastMA[this._fastMA.length - 2];
    const prevSlow: number = this._slowMA[this._slowMA.length - 2];

    // Check for crossover signals
    const openPositions = this.getOpenPositions();
    let signal: any = null;

    // Bullish crossover (fast MA crosses above slow MA)
    if (prevFast <= prevSlow && currentFast > currentSlow && openPositions.length === 0) {
      signal = this.generateBuySignal(currentPrice);
      this._lastCrossover = 'bullish';
    }
    // Bearish crossover (fast MA crosses below slow MA) 
    else if (prevFast >= prevSlow && currentFast < currentSlow && openPositions.length > 0) {
      signal = this.generateSellSignal(currentPrice);
      this._lastCrossover = 'bearish';
    }

    // Update trailing stops
    if (this.enableTrailingStop) {
      this.updateTrailingStops(currentPrice);
    }

    // Plot indicators
    bdpo.plot("splines", [this._fastMA], { splineColor: "#4CAF50", splineWidth: 2, skipNan: true }, { title: `Fast EMA ${this.fastPeriod}` });
    bdpo.plot("splines", [this._slowMA], { splineColor: "#F44336", splineWidth: 2, skipNan: true }, { title: `Slow EMA ${this.slowPeriod}` });

    return {
      signal: signal,
      indicators: {
        fastMA: currentFast,
        slowMA: currentSlow,
        spread: ((currentFast - currentSlow) / currentSlow * 100).toFixed(2)
      },
      positions: openPositions.length,
      lastCrossover: this._lastCrossover,
      performance: {
        totalTrades: this._tradeCount,
        winRate: this._tradeCount > 0 ? (this._winCount / this._tradeCount * 100).toFixed(1) : 0
      }
    };
  }

  private generateBuySignal(price: number): any {
    const positionSize = this.calculatePositionSize(price);
    const stopLoss = price * (1 - this.stopLossPercent / 100);
    const takeProfit = price * (1 + this.takeProfitPercent / 100);

    try {
      const order = bdpo.orderSend({
        orderType: "BUY",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: "MA Crossover Bullish Entry"
      });

      if (order) {
        this._positions.push({
          ...order,
          entryPrice: price,
          initialStopLoss: stopLoss,
          trailingStop: this.enableTrailingStop ? stopLoss : null,
          entryTime: Date.now()
        });

        bdpo.logSuccess(`BUY order placed: Size=${positionSize}, Entry=${price.toFixed(4)}, SL=${stopLoss.toFixed(4)}, TP=${takeProfit.toFixed(4)}`);
        
        return {
          type: "BUY",
          price: price,
          size: positionSize,
          stopLoss: stopLoss,
          takeProfit: takeProfit
        };
      }
    } catch (error) {
      bdpo.logError(`Failed to place BUY order: ${error.message}`);
    }

    return null;
  }

  private generateSellSignal(price: number): any {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      try {
        const closeOrder = bdpo.orderClose(position.ticket, position.volume, price, 3);
        
        if (closeOrder) {
          const profit = (price - position.entryPrice) * position.volume;
          this._tradeCount++;
          
          if (profit > 0) {
            this._winCount++;
            bdpo.logSuccess(`Position closed with profit: +$${profit.toFixed(2)}`);
          } else {
            bdpo.logWarn(`Position closed with loss: -$${Math.abs(profit).toFixed(2)}`);
          }

          // Remove from positions array
          this._positions = this._positions.filter(p => p.ticket !== position.ticket);
        }
      } catch (error) {
        bdpo.logError(`Failed to close position: ${error.message}`);
      }
    });

    return {
      type: "SELL",
      price: price,
      closedPositions: openPositions.length
    };
  }

  private calculatePositionSize(price: number): number {
    const accountBalance = bdpo.getBalance();
    const riskAmount = accountBalance * (this.riskPercentPerTrade / 100);
    const stopLossDistance = price * (this.stopLossPercent / 100);
    
    const positionSize = riskAmount / stopLossDistance;
    
    // Apply position size limits
    const minSize = bdpo.getMinQty() || 0.01;
    const maxSize = bdpo.getMaxQty() || 10;
    
    return Math.max(minSize, Math.min(maxSize, positionSize));
  }

  private updateTrailingStops(currentPrice: number): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      if (position.trailingStop) {
        const trailingDistance = currentPrice * (this.trailingStopPercent / 100);
        const newTrailingStop = currentPrice - trailingDistance;
        
        // Only update if new trailing stop is higher than current
        if (newTrailingStop > position.trailingStop) {
          position.trailingStop = newTrailingStop;
          
          // Update the actual stop loss order
          try {
            bdpo.orderModify(position.ticket, position.openPrice, newTrailingStop, position.takeProfit);
            bdpo.logDebug(`Trailing stop updated to ${newTrailingStop.toFixed(4)} for position ${position.ticket}`);
          } catch (error) {
            bdpo.logError(`Failed to update trailing stop: ${error.message}`);
          }
        }
      }
    });
  }

  private getOpenPositions(): any[] {
    return this._positions.filter(pos => pos.closeTime === 0 || pos.closeTime === undefined);
  }

  __shutdown__(): void {
    // Close all open positions
    const openPositions = this.getOpenPositions();
    
    if (openPositions.length > 0) {
      bdpo.logInfo(`Closing ${openPositions.length} open positions during shutdown`);
      
      openPositions.forEach(position => {
        try {
          bdpo.orderClose(position.ticket, position.volume, bdpo.getAsk(), 5);
        } catch (error) {
          bdpo.logError(`Failed to close position during shutdown: ${error.message}`);
        }
      });
    }

    // Log final performance statistics
    const winRate = this._tradeCount > 0 ? (this._winCount / this._tradeCount * 100) : 0;
    bdpo.logInfo("=== STRATEGY PERFORMANCE SUMMARY ===");
    bdpo.logInfo(`Total Trades: ${this._tradeCount}`);
    bdpo.logInfo(`Winning Trades: ${this._winCount}`);
    bdpo.logInfo(`Win Rate: ${winRate.toFixed(1)}%`);
    bdpo.logSuccess("MA Crossover Strategy shutdown completed");
  }
}

Copy

class BreakoutStrategy {
  // Public configuration
  public lookbackPeriod: number = 20;     // Donchian Channel period
  public minConsolidation: number = 10;   // Minimum bars in consolidation
  public volatilityPeriod: number = 14;   // ATR period for volatility
  public riskPercentPerTrade: number = 2; // Risk per trade
  public atrMultiplier: number = 2;       // ATR multiplier for stops
  public maxPositionsPerSide: number = 1; // Max long/short positions
  public enableVolumeFilter: boolean = true;
  public minVolumeRatio: number = 1.5;    // Minimum volume spike for breakout

  // Private state
  private _positions: any[] = [];
  private _donchianUpper: number[] = [];
  private _donchianLower: number[] = [];
  private _atr: number[] = [];
  private _consolidationBars: number = 0;
  private _lastBreakout: string | null = null;

  __init__(): void {
    this._positions = [];
    this._consolidationBars = 0;
    this._lastBreakout = null;
    
    bdpo.logInfo("Breakout Strategy initialized");
    bdpo.logInfo(`Lookback: ${this.lookbackPeriod}, Min Consolidation: ${this.minConsolidation}`);
    bdpo.logInfo(`Risk per trade: ${this.riskPercentPerTrade}%, ATR Multiplier: ${this.atrMultiplier}`);
  }

  __tick__(): any {
    const highs: number[] = bdpo.getHighPrices();
    const lows: number[] = bdpo.getLowPrices();
    const closes: number[] = bdpo.getClosePrices();
    const volumes: number[] = bdpo.getVolumePrices();
    
    if (closes.length < this.lookbackPeriod + this.volatilityPeriod) {
      return { status: "warming_up" };
    }

    const currentHigh = highs[highs.length - 1];
    const currentLow = lows[lows.length - 1];
    const currentClose = closes[closes.length - 1];
    const currentVolume = volumes[volumes.length - 1];

    // Calculate indicators
    this._donchianUpper = this.calculateDonchianUpper(highs, this.lookbackPeriod);
    this._donchianLower = this.calculateDonchianLower(lows, this.lookbackPeriod);
    this._atr = bdpo.atr(highs, lows, closes, this.volatilityPeriod);

    const upperChannel = this._donchianUpper[this._donchianUpper.length - 1];
    const lowerChannel = this._donchianLower[this._donchianLower.length - 1];
    const currentATR = this._atr[this._atr.length - 1];

    // Check for consolidation
    const channelRange = upperChannel - lowerChannel;
    const avgRange = bdpo.mean(this._atr.slice(-20));
    const isConsolidating = channelRange < avgRange * 1.5;

    if (isConsolidating) {
      this._consolidationBars++;
    } else {
      this._consolidationBars = 0;
    }

    // Volume filter
    let volumeConfirmed = true;
    if (this.enableVolumeFilter) {
      const avgVolume = bdpo.mean(volumes.slice(-20));
      volumeConfirmed = currentVolume > avgVolume * this.minVolumeRatio;
    }

    // Check for breakout signals
    let signal: any = null;
    const longPositions = this.getLongPositions();
    const shortPositions = this.getShortPositions();

    // Bullish breakout
    if (currentHigh > upperChannel && 
        this._consolidationBars >= this.minConsolidation && 
        volumeConfirmed && 
        longPositions.length < this.maxPositionsPerSide) {
      
      signal = this.generateLongEntry(currentClose, currentATR);
      this._lastBreakout = 'bullish';
      this._consolidationBars = 0;
    }
    // Bearish breakout
    else if (currentLow < lowerChannel && 
             this._consolidationBars >= this.minConsolidation && 
             volumeConfirmed && 
             shortPositions.length < this.maxPositionsPerSide) {
      
      signal = this.generateShortEntry(currentClose, currentATR);
      this._lastBreakout = 'bearish';
      this._consolidationBars = 0;
    }

    // Exit management
    this.manageExits(currentClose, currentATR);

    // Plot channels
    bdpo.plot("splines", [this._donchianUpper], { splineColor: "#FF5722", splineWidth: 1, skipNan: true }, { title: "Upper Channel" });
    bdpo.plot("splines", [this._donchianLower], { splineColor: "#4CAF50", splineWidth: 1, skipNan: true }, { title: "Lower Channel" });

    return {
      signal: signal,
      indicators: {
        upperChannel: upperChannel,
        lowerChannel: lowerChannel,
        channelRange: channelRange.toFixed(4),
        consolidationBars: this._consolidationBars,
        atr: currentATR.toFixed(4)
      },
      positions: {
        long: longPositions.length,
        short: shortPositions.length
      },
      lastBreakout: this._lastBreakout
    };
  }

  private generateLongEntry(price: number, atr: number): any {
    const stopLoss = price - (atr * this.atrMultiplier);
    const takeProfit = price + (atr * this.atrMultiplier * 2); // 1:2 risk/reward
    const positionSize = this.calculatePositionSize(price, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "BUY",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: "Bullish Breakout Entry"
      });

      if (order) {
        this._positions.push({
          ...order,
          direction: "LONG",
          entryPrice: price,
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          entryTime: Date.now()
        });

        bdpo.logSuccess(`LONG breakout entry: Price=${price.toFixed(4)}, SL=${stopLoss.toFixed(4)}, TP=${takeProfit.toFixed(4)}`);
        
        return { type: "BUY", price: price, stopLoss: stopLoss, takeProfit: takeProfit };
      }
    } catch (error) {
      bdpo.logError(`Failed to place LONG order: ${error.message}`);
    }

    return null;
  }

  private generateShortEntry(price: number, atr: number): any {
    const stopLoss = price + (atr * this.atrMultiplier);
    const takeProfit = price - (atr * this.atrMultiplier * 2); // 1:2 risk/reward
    const positionSize = this.calculatePositionSize(price, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "SELL",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: "Bearish Breakout Entry"
      });

      if (order) {
        this._positions.push({
          ...order,
          direction: "SHORT",
          entryPrice: price,
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          entryTime: Date.now()
        });

        bdpo.logSuccess(`SHORT breakout entry: Price=${price.toFixed(4)}, SL=${stopLoss.toFixed(4)}, TP=${takeProfit.toFixed(4)}`);
        
        return { type: "SELL", price: price, stopLoss: stopLoss, takeProfit: takeProfit };
      }
    } catch (error) {
      bdpo.logError(`Failed to place SHORT order: ${error.message}`);
    }

    return null;
  }

  private calculatePositionSize(entryPrice: number, stopLoss: number): number {
    const accountBalance = bdpo.getBalance();
    const riskAmount = accountBalance * (this.riskPercentPerTrade / 100);
    const riskPerUnit = Math.abs(entryPrice - stopLoss);
    
    const positionSize = riskAmount / riskPerUnit;
    
    const minSize = bdpo.getMinQty() || 0.01;
    const maxSize = bdpo.getMaxQty() || 10;
    
    return Math.max(minSize, Math.min(maxSize, positionSize));
  }

  private calculateDonchianUpper(highs: number[], period: number): number[] {
    const result: number[] = [];
    
    for (let i = period - 1; i < highs.length; i++) {
      const periodHighs = highs.slice(i - period + 1, i + 1);
      result.push(Math.max(...periodHighs));
    }
    
    return result;
  }

  private calculateDonchianLower(lows: number[], period: number): number[] {
    const result: number[] = [];
    
    for (let i = period - 1; i < lows.length; i++) {
      const periodLows = lows.slice(i - period + 1, i + 1);
      result.push(Math.min(...periodLows));
    }
    
    return result;
  }

  private manageExits(currentPrice: number, currentATR: number): void {
    // Implementation for exit management
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      const holdingTime = Date.now() - position.entryTime;
      const holdingHours = holdingTime / (1000 * 60 * 60);
      
      // Exit if position held too long without progress
      if (holdingHours > 24) {
        this.closePosition(position, "Time-based exit");
      }
    });
  }

  private closePosition(position: any, reason: string): void {
    try {
      const currentPrice = position.direction === "LONG" ? bdpo.getBid() : bdpo.getAsk();
      const closeOrder = bdpo.orderClose(position.ticket, position.volume, currentPrice, 3);
      
      if (closeOrder) {
        bdpo.logInfo(`Position closed: ${reason}`);
        this._positions = this._positions.filter(p => p.ticket !== position.ticket);
      }
    } catch (error) {
      bdpo.logError(`Failed to close position: ${error.message}`);
    }
  }

  private getLongPositions(): any[] {
    return this._positions.filter(pos => pos.direction === "LONG" && (pos.closeTime === 0 || pos.closeTime === undefined));
  }

  private getShortPositions(): any[] {
    return this._positions.filter(pos => pos.direction === "SHORT" && (pos.closeTime === 0 || pos.closeTime === undefined));
  }

  private getOpenPositions(): any[] {
    return this._positions.filter(pos => pos.closeTime === 0 || pos.closeTime === undefined);
  }

  __shutdown__(): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      this.closePosition(position, "Strategy shutdown");
    });

    bdpo.logSuccess("Breakout Strategy shutdown completed");
  }
}

Copy

class RSIMeanReversionStrategy {
  // Public parameters
  public rsiPeriod: number = 14;
  public rsiOversold: number = 30;
  public rsiOverbought: number = 70;
  public bbPeriod: number = 20;
  public bbStdDev: number = 2;
  public riskPercentPerTrade: number = 1.5;
  public maxPositions: number = 2;
  public requireBBConfirmation: boolean = true;
  public enableScaleIn: boolean = true;     // Scale into positions
  public maxScaleIns: number = 3;

  // Private state
  private _positions: any[] = [];
  private _rsi: number[] = [];
  private _bbands: any = null;
  private _scaleInCount: Map = new Map();

  __init__(): void {
    this._positions = [];
    this._scaleInCount.clear();
    
    bdpo.logInfo("RSI Mean Reversion Strategy initialized");
    bdpo.logInfo(`RSI: ${this.rsiPeriod}, Oversold: ${this.rsiOversold}, Overbought: ${this.rsiOverbought}`);
    bdpo.logInfo(`BB: ${this.bbPeriod} period, ${this.bbStdDev} std dev`);
  }

  __tick__(): any {
    const closes: number[] = bdpo.getClosePrices();
    const currentPrice = closes[closes.length - 1];
    
    if (closes.length < Math.max(this.rsiPeriod, this.bbPeriod) + 1) {
      return { status: "warming_up" };
    }

    // Calculate indicators
    this._rsi = bdpo.rsi(closes, this.rsiPeriod);
    this._bbands = bdpo.bbands(closes, this.bbPeriod, this.bbStdDev);

    const currentRSI = this._rsi[this._rsi.length - 1];
    const prevRSI = this._rsi[this._rsi.length - 2];
    const upperBB = this._bbands.upper[this._bbands.upper.length - 1];
    const lowerBB = this._bbands.lower[this._bbands.lower.length - 1];
    const middleBB = this._bbands.middle[this._bbands.middle.length - 1];

    let signal: any = null;
    const openPositions = this.getOpenPositions();

    // Entry signals
    if (openPositions.length < this.maxPositions) {
      // Oversold condition - potential buy
      if (currentRSI < this.rsiOversold && prevRSI >= this.rsiOversold) {
        const bbConfirmed = !this.requireBBConfirmation || currentPrice <= lowerBB;
        
        if (bbConfirmed) {
          signal = this.generateBuySignal(currentPrice, middleBB);
        }
      }
      // Overbought condition - potential sell
      else if (currentRSI > this.rsiOverbought && prevRSI <= this.rsiOverbought) {
        const bbConfirmed = !this.requireBBConfirmation || currentPrice >= upperBB;
        
        if (bbConfirmed) {
          signal = this.generateSellSignal(currentPrice, middleBB);
        }
      }
    }

    // Scale-in management
    if (this.enableScaleIn) {
      this.manageScaleIns(currentPrice, currentRSI, upperBB, lowerBB);
    }

    // Exit management
    this.manageExits(currentPrice, currentRSI, middleBB);

    // Plot indicators
    bdpo.plot("splines", [this._rsi], { splineColor: "#9C27B0", splineWidth: 2, skipNan: true }, { title: `RSI ${this.rsiPeriod}` });
    bdpo.plot("splines", [this._bbands.upper], { splineColor: "#2196F3", splineWidth: 1, skipNan: true }, { title: "BB Upper" });
    bdpo.plot("splines", [this._bbands.lower], { splineColor: "#2196F3", splineWidth: 1, skipNan: true }, { title: "BB Lower" });
    bdpo.plot("splines", [this._bbands.middle], { splineColor: "#2196F3", splineWidth: 1, skipNan: true }, { title: "BB Middle" });

    return {
      signal: signal,
      indicators: {
        rsi: currentRSI.toFixed(2),
        bbUpper: upperBB.toFixed(4),
        bbLower: lowerBB.toFixed(4),
        bbPosition: this.getBBPosition(currentPrice, upperBB, lowerBB, middleBB)
      },
      positions: openPositions.length,
      scaleIns: Array.from(this._scaleInCount.values()).reduce((a, b) => a + b, 0)
    };
  }

  private generateBuySignal(price: number, target: number): any {
    const stopLoss = price * 0.97; // 3% stop loss
    const takeProfit = target; // Target middle BB
    const positionSize = this.calculatePositionSize(price, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "BUY",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: "RSI Oversold Mean Reversion"
      });

      if (order) {
        const positionId = `LONG_${Date.now()}`;
        this._positions.push({
          ...order,
          id: positionId,
          direction: "LONG",
          entryPrice: price,
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          entryTime: Date.now(),
          strategy: "mean_reversion"
        });

        this._scaleInCount.set(positionId, 0);
        bdpo.logSuccess(`BUY signal: RSI oversold entry at ${price.toFixed(4)}`);
        
        return { type: "BUY", price: price, reason: "RSI oversold" };
      }
    } catch (error) {
      bdpo.logError(`Failed to place BUY order: ${error.message}`);
    }

    return null;
  }

  private generateSellSignal(price: number, target: number): any {
    const stopLoss = price * 1.03; // 3% stop loss
    const takeProfit = target; // Target middle BB
    const positionSize = this.calculatePositionSize(price, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "SELL",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: "RSI Overbought Mean Reversion"
      });

      if (order) {
        const positionId = `SHORT_${Date.now()}`;
        this._positions.push({
          ...order,
          id: positionId,
          direction: "SHORT",
          entryPrice: price,
          stopLoss: stopLoss,
          takeProfit: takeProfit,
          entryTime: Date.now(),
          strategy: "mean_reversion"
        });

        this._scaleInCount.set(positionId, 0);
        bdpo.logSuccess(`SELL signal: RSI overbought entry at ${price.toFixed(4)}`);
        
        return { type: "SELL", price: price, reason: "RSI overbought" };
      }
    } catch (error) {
      bdpo.logError(`Failed to place SELL order: ${error.message}`);
    }

    return null;
  }

  private manageScaleIns(currentPrice: number, currentRSI: number, upperBB: number, lowerBB: number): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      const scaleInCount = this._scaleInCount.get(position.id) || 0;
      
      if (scaleInCount < this.maxScaleIns) {
        let shouldScaleIn = false;
        
        if (position.direction === "LONG") {
          // Scale in if RSI gets more oversold or price drops further below lower BB
          shouldScaleIn = (currentRSI < this.rsiOversold - 5) || 
                         (currentPrice < lowerBB * 0.995);
        } else if (position.direction === "SHORT") {
          // Scale in if RSI gets more overbought or price rises further above upper BB
          shouldScaleIn = (currentRSI > this.rsiOverbought + 5) || 
                         (currentPrice > upperBB * 1.005);
        }
        
        if (shouldScaleIn) {
          this.executeScaleIn(position, currentPrice);
        }
      }
    });
  }

  private executeScaleIn(position: any, price: number): void {
    const scaleInSize = position.volume * 0.5; // 50% of original position
    
    try {
      const scaleInOrder = bdpo.orderSend({
        orderType: position.direction === "LONG" ? "BUY" : "SELL",
        lotSize: scaleInSize,
        stopLoss: position.stopLoss,
        takeProfit: position.takeProfit,
        note: `Scale-in for ${position.id}`
      });

      if (scaleInOrder) {
        const currentCount = this._scaleInCount.get(position.id) || 0;
        this._scaleInCount.set(position.id, currentCount + 1);
        
        bdpo.logInfo(`Scale-in executed for ${position.direction} position: Size=${scaleInSize}, Price=${price.toFixed(4)}`);
      }
    } catch (error) {
      bdpo.logError(`Failed to execute scale-in: ${error.message}`);
    }
  }

  private manageExits(currentPrice: number, currentRSI: number, middleBB: number): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      let shouldExit = false;
      let exitReason = "";
      
      if (position.direction === "LONG") {
        // Exit long if RSI normalizes above 50 or price reaches middle BB
        if (currentRSI > 50 || currentPrice >= middleBB) {
          shouldExit = true;
          exitReason = currentRSI > 50 ? "RSI normalized" : "Target reached";
        }
      } else if (position.direction === "SHORT") {
        // Exit short if RSI normalizes below 50 or price reaches middle BB
        if (currentRSI < 50 || currentPrice <= middleBB) {
          shouldExit = true;
          exitReason = currentRSI < 50 ? "RSI normalized" : "Target reached";
        }
      }
      
      if (shouldExit) {
        this.closePosition(position, exitReason);
      }
    });
  }

  private closePosition(position: any, reason: string): void {
    try {
      const currentPrice = position.direction === "LONG" ? bdpo.getBid() : bdpo.getAsk();
      const closeOrder = bdpo.orderClose(position.ticket, position.volume, currentPrice, 3);
      
      if (closeOrder) {
        bdpo.logSuccess(`Position closed: ${reason}`);
        this._positions = this._positions.filter(p => p.id !== position.id);
        this._scaleInCount.delete(position.id);
      }
    } catch (error) {
      bdpo.logError(`Failed to close position: ${error.message}`);
    }
  }

  private calculatePositionSize(entryPrice: number, stopLoss: number): number {
    const accountBalance = bdpo.getBalance();
    const riskAmount = accountBalance * (this.riskPercentPerTrade / 100);
    const riskPerUnit = Math.abs(entryPrice - stopLoss);
    
    const positionSize = riskAmount / riskPerUnit;
    
    const minSize = bdpo.getMinQty() || 0.01;
    const maxSize = bdpo.getMaxQty() || 5;
    
    return Math.max(minSize, Math.min(maxSize, positionSize));
  }

  private getBBPosition(price: number, upper: number, lower: number, middle: number): string {
    if (price > upper) return "Above Upper";
    if (price < lower) return "Below Lower";
    if (price > middle) return "Upper Half";
    return "Lower Half";
  }

  private getOpenPositions(): any[] {
    return this._positions.filter(pos => pos.closeTime === 0 || pos.closeTime === undefined);
  }

  __shutdown__(): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      this.closePosition(position, "Strategy shutdown");
    });

    bdpo.logSuccess("RSI Mean Reversion Strategy shutdown completed");
  }
}

Copy

class MultiTimeframeStrategy {
  // Public configuration
  public trendTimeframe: string = "1h";      // Higher timeframe for trend
  public entryTimeframe: string = "15m";     // Lower timeframe for entries
  public trendMAPeriod: number = 50;         // Trend MA period
  public entryMAPeriod: number = 20;         // Entry MA period
  public riskPercentPerTrade: number = 2;
  public maxPositions: number = 2;
  public requireTrendAlignment: boolean = true;

  // Private state
  private _positions: any[] = [];
  private _trendDirection: string | null = null;
  private _lastAnalysis: any = null;

  __init__(): void {
    this._positions = [];
    this._trendDirection = null;
    this._lastAnalysis = null;
    
    bdpo.logInfo("Multi-Timeframe Strategy initialized");
    bdpo.logInfo(`Trend TF: ${this.trendTimeframe}, Entry TF: ${this.entryTimeframe}`);
    bdpo.logInfo(`Trend MA: ${this.trendMAPeriod}, Entry MA: ${this.entryMAPeriod}`);
  }

  __tick__(): any {
    // Get data for both timeframes
    const trendData = bdpo.getTimeframeData(this.trendTimeframe);
    const entryData = bdpo.getTimeframeData(this.entryTimeframe);
    
    if (!trendData || !entryData) {
      return { status: "waiting_for_data" };
    }

    // Analyze higher timeframe trend
    const trendAnalysis = this.analyzeTrend(trendData);
    this._trendDirection = trendAnalysis.direction;

    // Analyze entry timeframe
    const entryAnalysis = this.analyzeEntry(entryData);

    // Generate signals
    let signal: any = null;
    const openPositions = this.getOpenPositions();

    if (openPositions.length < this.maxPositions && this._trendDirection !== "SIDEWAYS") {
      if (this.requireTrendAlignment) {
        // Only trade in direction of higher timeframe trend
        if (this._trendDirection === "BULLISH" && entryAnalysis.signal === "BUY") {
          signal = this.generateBuySignal(entryAnalysis);
        } else if (this._trendDirection === "BEARISH" && entryAnalysis.signal === "SELL") {
          signal = this.generateSellSignal(entryAnalysis);
        }
      } else {
        // Trade any signal
        if (entryAnalysis.signal === "BUY") {
          signal = this.generateBuySignal(entryAnalysis);
        } else if (entryAnalysis.signal === "SELL") {
          signal = this.generateSellSignal(entryAnalysis);
        }
      }
    }

    // Manage exits
    this.manageExits(entryAnalysis);

    this._lastAnalysis = {
      trend: trendAnalysis,
      entry: entryAnalysis,
      timestamp: Date.now()
    };

    return {
      signal: signal,
      trendDirection: this._trendDirection,
      trendStrength: trendAnalysis.strength,
      entrySignal: entryAnalysis.signal,
      entryStrength: entryAnalysis.strength,
      positions: openPositions.length,
      alignment: this._trendDirection === entryAnalysis.trendBias ? "ALIGNED" : "DIVERGENT"
    };
  }

  private analyzeTrend(trendData: any[]): any {
    const closes = bdpo.getClose(trendData);
    const highs = bdpo.getHigh(trendData);
    const lows = bdpo.getLow(trendData);
    
    if (closes.length < this.trendMAPeriod + 20) {
      return { direction: "UNKNOWN", strength: 0 };
    }

    const trendMA = bdpo.ema(closes, this.trendMAPeriod);
    const currentPrice = closes[closes.length - 1];
    const currentMA = trendMA[trendMA.length - 1];
    const prevMA = trendMA[trendMA.length - 2];

    // Calculate trend strength using various factors
    const maSlope = (currentMA - prevMA) / prevMA * 100;
    const priceToMADistance = (currentPrice - currentMA) / currentMA * 100;
    
    // Higher highs and higher lows for uptrend
    const recentHighs = highs.slice(-10);
    const recentLows = lows.slice(-10);
    const hhhl = this.calculateTrendPattern(recentHighs, recentLows);
    
    let direction: string;
    let strength: number;

    if (currentPrice > currentMA && maSlope > 0.1 && hhhl.score > 0.6) {
      direction = "BULLISH";
      strength = Math.min(100, (Math.abs(maSlope) + Math.abs(priceToMADistance) + hhhl.score * 50));
    } else if (currentPrice < currentMA && maSlope < -0.1 && hhhl.score < -0.6) {
      direction = "BEARISH";
      strength = Math.min(100, (Math.abs(maSlope) + Math.abs(priceToMADistance) + Math.abs(hhhl.score) * 50));
    } else {
      direction = "SIDEWAYS";
      strength = 0;
    }

    return {
      direction: direction,
      strength: strength,
      maSlope: maSlope,
      priceToMA: priceToMADistance,
      patternScore: hhhl.score
    };
  }

  private analyzeEntry(entryData: any[]): any {
    const closes = bdpo.getClose(entryData);
    const currentPrice = closes[closes.length - 1];
    
    if (closes.length < this.entryMAPeriod + 5) {
      return { signal: "WAIT", strength: 0, trendBias: "UNKNOWN" };
    }

    const entryMA = bdpo.ema(closes, this.entryMAPeriod);
    const rsi = bdpo.rsi(closes, 14);
    
    const currentMA = entryMA[entryMA.length - 1];
    const prevMA = entryMA[entryMA.length - 2];
    const currentRSI = rsi[rsi.length - 1];
    
    // Determine entry timeframe bias
    const trendBias = currentPrice > currentMA ? "BULLISH" : "BEARISH";
    
    let signal: string = "WAIT";
    let strength: number = 0;

    // Look for pullback opportunities in trend direction
    if (this._trendDirection === "BULLISH") {
      // Look for dips to buy in uptrend
      if (currentPrice < currentMA && currentPrice > prevMA && currentRSI < 60) {
        signal = "BUY";
        strength = 60 + (60 - currentRSI); // Stronger signal if more oversold
      }
    } else if (this._trendDirection === "BEARISH") {
      // Look for rallies to sell in downtrend
      if (currentPrice > currentMA && currentPrice < prevMA && currentRSI > 40) {
        signal = "SELL";
        strength = 40 + (currentRSI - 40); // Stronger signal if more overbought
      }
    }

    return {
      signal: signal,
      strength: strength,
      trendBias: trendBias,
      rsi: currentRSI,
      priceToMA: ((currentPrice - currentMA) / currentMA * 100)
    };
  }

  private calculateTrendPattern(highs: number[], lows: number[]): any {
    // Simplified trend pattern calculation
    let bullishPoints = 0;
    let bearishPoints = 0;
    
    for (let i = 1; i < highs.length; i++) {
      if (highs[i] > highs[i-1]) bullishPoints++;
      else bearishPoints++;
      
      if (lows[i] > lows[i-1]) bullishPoints++;
      else bearishPoints++;
    }
    
    const totalPoints = bullishPoints + bearishPoints;
    const score = totalPoints > 0 ? (bullishPoints - bearishPoints) / totalPoints : 0;
    
    return { score: score, bullish: bullishPoints, bearish: bearishPoints };
  }

  private generateBuySignal(entryAnalysis: any): any {
    const currentPrice = bdpo.getAsk();
    const stopLoss = currentPrice * 0.98; // 2% stop loss
    const takeProfit = currentPrice * 1.06; // 3:1 risk/reward
    const positionSize = this.calculatePositionSize(currentPrice, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "BUY",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: `Multi-TF Bullish Entry (Strength: ${entryAnalysis.strength})`
      });

      if (order) {
        this._positions.push({
          ...order,
          direction: "LONG",
          entryPrice: currentPrice,
          entryAnalysis: entryAnalysis,
          entryTime: Date.now()
        });

        bdpo.logSuccess(`Multi-TF BUY: Price=${currentPrice.toFixed(4)}, Trend=${this._trendDirection}, Strength=${entryAnalysis.strength}`);
        
        return { 
          type: "BUY", 
          price: currentPrice, 
          trendAlignment: true,
          strength: entryAnalysis.strength
        };
      }
    } catch (error) {
      bdpo.logError(`Failed to place BUY order: ${error.message}`);
    }

    return null;
  }

  private generateSellSignal(entryAnalysis: any): any {
    const currentPrice = bdpo.getBid();
    const stopLoss = currentPrice * 1.02; // 2% stop loss
    const takeProfit = currentPrice * 0.94; // 3:1 risk/reward
    const positionSize = this.calculatePositionSize(currentPrice, stopLoss);

    try {
      const order = bdpo.orderSend({
        orderType: "SELL",
        lotSize: positionSize,
        stopLoss: stopLoss,
        takeProfit: takeProfit,
        note: `Multi-TF Bearish Entry (Strength: ${entryAnalysis.strength})`
      });

      if (order) {
        this._positions.push({
          ...order,
          direction: "SHORT",
          entryPrice: currentPrice,
          entryAnalysis: entryAnalysis,
          entryTime: Date.now()
        });

        bdpo.logSuccess(`Multi-TF SELL: Price=${currentPrice.toFixed(4)}, Trend=${this._trendDirection}, Strength=${entryAnalysis.strength}`);
        
        return { 
          type: "SELL", 
          price: currentPrice, 
          trendAlignment: true,
          strength: entryAnalysis.strength
        };
      }
    } catch (error) {
      bdpo.logError(`Failed to place SELL order: ${error.message}`);
    }

    return null;
  }

  private manageExits(entryAnalysis: any): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      let shouldExit = false;
      let exitReason = "";
      
      // Exit if trend changes against position
      if (position.direction === "LONG" && this._trendDirection === "BEARISH") {
        shouldExit = true;
        exitReason = "Trend reversal";
      } else if (position.direction === "SHORT" && this._trendDirection === "BULLISH") {
        shouldExit = true;
        exitReason = "Trend reversal";
      }
      
      // Exit if RSI shows extreme opposite conditions
      if (position.direction === "LONG" && entryAnalysis.rsi > 80) {
        shouldExit = true;
        exitReason = "RSI overbought";
      } else if (position.direction === "SHORT" && entryAnalysis.rsi < 20) {
        shouldExit = true;
        exitReason = "RSI oversold";
      }
      
      if (shouldExit) {
        this.closePosition(position, exitReason);
      }
    });
  }

  private closePosition(position: any, reason: string): void {
    try {
      const currentPrice = position.direction === "LONG" ? bdpo.getBid() : bdpo.getAsk();
      const closeOrder = bdpo.orderClose(position.ticket, position.volume, currentPrice, 3);
      
      if (closeOrder) {
        bdpo.logInfo(`Multi-TF position closed: ${reason}`);
        this._positions = this._positions.filter(p => p.ticket !== position.ticket);
      }
    } catch (error) {
      bdpo.logError(`Failed to close position: ${error.message}`);
    }
  }

  private calculatePositionSize(entryPrice: number, stopLoss: number): number {
    const accountBalance = bdpo.getBalance();
    const riskAmount = accountBalance * (this.riskPercentPerTrade / 100);
    const riskPerUnit = Math.abs(entryPrice - stopLoss);
    
    const positionSize = riskAmount / riskPerUnit;
    
    const minSize = bdpo.getMinQty() || 0.01;
    const maxSize = bdpo.getMaxQty() || 5;
    
    return Math.max(minSize, Math.min(maxSize, positionSize));
  }

  private getOpenPositions(): any[] {
    return this._positions.filter(pos => pos.closeTime === 0 || pos.closeTime === undefined);
  }

  __shutdown__(): void {
    const openPositions = this.getOpenPositions();
    
    openPositions.forEach(position => {
      this.closePosition(position, "Strategy shutdown");
    });

    bdpo.logSuccess("Multi-Timeframe Strategy shutdown completed");
  }
}

Copy

class SimpleRSI {
  public rsiLength: number = 14;

  __init__(): void {
    console.log("RSI Indicator started");
  }

  __tick__(): any {
    // Calculate RSI with configurable length
    let candles = bdpo.getChartData()
    let closes = bdpo.getClose(candles)
    const rsi = bdpo.rsi(closes, this.rsiLength);
    
    // Plot the RSI line
    bdpo.plot("spline", rsi);
    
  }

  __shutdown__(): void {
    console.log("RSI Indicator stopped");
  }
}

Copy

class SimpleMovingAverageCrossover {
  __init__(): void {
    console.log("MA Crossover Indicator started");
  }

  __tick__(): any {
    // Calculate fast and slow moving averages
    const fastMA = bdpo.sma(bdpo.getClose(), 10);
    const slowMA = bdpo.sma(bdpo.getClose(), 20);

    // Plot both lines
    bdpo.plot("splines", [fastMA]);
    bdpo.plot("splines", [slowMA]);

    // Check for crossover signals
    const currentFast = fastMA[fastMA.length - 1];
    const currentSlow = slowMA[slowMA.length - 1];
    
    if (currentFast > currentSlow) {
      console.log("BUY signal - Fast MA above Slow MA");
    } else {
      console.log("SELL signal - Fast MA below Slow MA");
    }

    return { fastMA: currentFast, slowMA: currentSlow };
  }

  __shutdown__(): void {
    console.log("MA Crossover Indicator stopped");
  }
}

Copy

class SimplePriceLine {
  __init__(): void {
    console.log("Price Line Indicator started");
  }

  __tick__(): any {
    // Get price data
    const prices = bdpo.getClose();
    
    // Plot the price line
    bdpo.plot("splines", [prices]);

    // Show if price is going up or down
    const currentPrice = prices[prices.length - 1];
    const previousPrice = prices[prices.length - 2];
    
    if (currentPrice > previousPrice) {
      console.log("Price going UP");
    } else if (currentPrice < previousPrice) {
      console.log("Price going DOWN");
    }

    return { price: currentPrice };
  }

  __shutdown__(): void {
    console.log("Price Line Indicator stopped");
  }
}