bitbank-lab-mcp 0.1.0

package/tools/trading_process/lib/fetch_candles.ts

@@ -0,0 +1,181 @@
+/**
+ * lib/fetch_candles.ts - バックテスト用ローソク足取得
+ *
+ * 【データ品質保証】
+ * - time でソート（古い順）
+ * - time をキーに重複排除
+ * - 数値 NaN / time欠損は除外
+ */
+
+import { dayjs } from '../../../lib/datetime.js';
+import getCandles from '../../get_candles.js';
+import type { Candle, Period, Timeframe } from '../types.js';
+
+// 期間 → 必要本数のマッピング（バックテスト対象期間）
+// 1D: 日足 → 1M=30日, 3M=90日, 6M=180日
+// 4H: 4時間足 → 1M=180本(30日×6), 3M=540本, 6M=1080本
+// 1H: 1時間足 → 1M=720本(30日×24), 3M=2160本, 6M=4320本
+const PERIOD_TO_BARS: Record<Timeframe, Record<Period, number>> = {
+	'1D': { '1M': 30, '3M': 90, '6M': 180 },
+	'4H': { '1M': 180, '3M': 540, '6M': 1080 },
+	'1H': { '1M': 720, '3M': 2160, '6M': 4320 },
+};
+
+// timeframe → get_candles の type マッピング
+const TIMEFRAME_TO_CANDLE_TYPE: Record<Timeframe, string> = {
+	'1D': '1day',
+	'4H': '4hour',
+	'1H': '1hour',
+};
+
+/**
+ * 期間に対応するバックテスト対象本数を取得
+ */
+export function getPeriodBars(timeframe: Timeframe, period: Period): number {
+	return PERIOD_TO_BARS[timeframe]?.[period] ?? 90;
+}
+
+/**
+ * ローソク足データのバリデーション
+ *
+ * @param candle 検証対象
+ * @returns 有効なデータの場合 true
+ */
+function isValidCandle(candle: Candle): boolean {
+	// time が空でないこと
+	if (!candle.time || candle.time.trim() === '') {
+		return false;
+	}
+
+	// time が有効な日付であること
+	const timestamp = dayjs(candle.time).valueOf();
+	if (Number.isNaN(timestamp)) {
+		return false;
+	}
+
+	// 数値が NaN でないこと
+	if (
+		Number.isNaN(candle.open) ||
+		Number.isNaN(candle.high) ||
+		Number.isNaN(candle.low) ||
+		Number.isNaN(candle.close)
+	) {
+		return false;
+	}
+
+	// 価格が 0 以上であること
+	if (candle.open <= 0 || candle.high <= 0 || candle.low <= 0 || candle.close <= 0) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * バックテスト用にローソク足を取得
+ *
+ * 返すデータ構成:
+ * - 直近 `periodBars` 本 = バックテスト対象期間
+ * - その前に `smaLong` 本 = SMA計算用ウォームアップ期間
+ * - 合計: `periodBars + smaLong + buffer` 本
+ *
+ * 【データ品質保証】
+ * - time でソート（古い順）
+ * - time をキーに重複排除
+ * - 数値 NaN / time欠損は除外
+ *
+ * @param pair 通貨ペア
+ * @param timeframe 時間軸
+ * @param period 期間
+ * @param smaLong 長期SMAの期間（ウォームアップ用）
+ * @returns ローソク足配列（古い順、ウォームアップ込み）
+ */
+export async function fetchCandlesForBacktest(
+	pair: string,
+	timeframe: Timeframe,
+	period: Period,
+	smaLong: number,
+): Promise<Candle[]> {
+	const periodBars = PERIOD_TO_BARS[timeframe]?.[period];
+	if (!periodBars) {
+		throw new Error(`Unsupported timeframe/period: ${timeframe}/${period}`);
+	}
+
+	// 必要な本数: バックテスト期間 + SMAウォームアップ + バッファ
+	const neededBars = periodBars + smaLong + 10;
+
+	// 日足の場合は複数年取得を発動させるため最低400を指定
+	// 時間足の場合はそのまま必要本数を指定
+	const fetchLimit = timeframe === '1D' ? Math.max(neededBars, 400) : neededBars;
+
+	const candleType = TIMEFRAME_TO_CANDLE_TYPE[timeframe];
+	if (!candleType) {
+		throw new Error(`Unsupported timeframe: ${timeframe}`);
+	}
+
+	const result = await getCandles(pair, candleType, undefined, fetchLimit);
+
+	if (!result.ok) {
+		throw new Error(`Failed to fetch candles: ${result.summary}`);
+	}
+
+	const normalized = result.data?.normalized;
+	if (!normalized || !Array.isArray(normalized) || normalized.length === 0) {
+		throw new Error('No candle data returned');
+	}
+
+	// 全データをCandle形式に変換
+	const rawCandles: Candle[] = normalized.map(
+		(c: {
+			isoTime?: string | null;
+			open: number;
+			high: number;
+			low: number;
+			close: number;
+			volume?: number | null;
+		}) => ({
+			time: c.isoTime || '',
+			open: Number(c.open),
+			high: Number(c.high),
+			low: Number(c.low),
+			close: Number(c.close),
+			volume: c.volume != null ? Number(c.volume) : undefined,
+		}),
+	);
+
+	// 1. バリデーション（無効データを除外）
+	const validCandles = rawCandles.filter(isValidCandle);
+
+	if (validCandles.length === 0) {
+		throw new Error('No valid candle data after filtering');
+	}
+
+	// 2. time でソート（古い順）
+	validCandles.sort((a, b) => {
+		const timeA = dayjs(a.time).valueOf();
+		const timeB = dayjs(b.time).valueOf();
+		return timeA - timeB;
+	});
+
+	// 3. 重複排除（time をキーに、後の方を優先）
+	const uniqueMap = new Map<string, Candle>();
+	for (const candle of validCandles) {
+		uniqueMap.set(candle.time, candle);
+	}
+	const uniqueCandles = Array.from(uniqueMap.values());
+
+	// 4. 再ソート（Map は順序を保証するが念のため）
+	uniqueCandles.sort((a, b) => {
+		const timeA = dayjs(a.time).valueOf();
+		const timeB = dayjs(b.time).valueOf();
+		return timeA - timeB;
+	});
+
+	// 5. 直近の必要な本数だけ切り出す（古い順を維持）
+	if (uniqueCandles.length <= neededBars) {
+		return uniqueCandles;
+	}
+
+	const startIdx = uniqueCandles.length - neededBars;
+	return uniqueCandles.slice(startIdx);
+}

package/tools/trading_process/lib/sma.ts

@@ -0,0 +1,62 @@
+/**
+ * lib/sma.ts - 単純移動平均計算（lib/indicators.ts への委譲）
+ *
+ * 【計算仕様】
+ * - 入力: prices[0..n-1]（古い順）
+ * - 出力: sma[0..n-1]
+ *   - sma[0..period-2] = NaN（データ不足）
+ *   - sma[period-1] = 最初の有効なSMA値
+ *   - sma[i] = prices[i-period+1..i] の平均（i >= period-1）
+ *
+ * 【売買ループでの使用法】
+ * - SMA(period) が有効なのは index >= period-1
+ * - クロスオーバー判定には sma[i-1] と sma[i] が必要
+ * - したがって startIdx = period（安全マージンを含む）から開始
+ */
+
+import { sma } from '../../../lib/indicators.js';
+
+/**
+ * 単純移動平均を計算
+ *
+ * @param prices 価格配列（古い順）
+ * @param period 期間（正の整数）
+ * @returns SMA配列
+ *          - 先頭 period-1 個は NaN
+ *          - result[period-1] が最初の有効なSMA値
+ *          - result[i] (i >= period-1) は prices[i-period+1..i] の平均
+ *
+ * @example
+ * const prices = [100, 102, 104, 103, 105];
+ * const sma3 = calculateSMA(prices, 3);
+ * // sma3 = [NaN, NaN, 102, 103, 104]
+ * // sma3[2] = (100 + 102 + 104) / 3 = 102
+ * // sma3[3] = (102 + 104 + 103) / 3 = 103
+ * // sma3[4] = (104 + 103 + 105) / 3 = 104
+ */
+export function calculateSMA(prices: number[], period: number): number[] {
+	return sma(prices, period);
+}
+
+/**
+ * SMAが有効になる最初のインデックスを返す
+ *
+ * @param period SMAの期間
+ * @returns 最初の有効インデックス（= period - 1）
+ */
+export function getFirstValidIndex(period: number): number {
+	return period - 1;
+}
+
+/**
+ * 売買ループで安全に使用できる開始インデックスを返す
+ *
+ * クロスオーバー判定には sma[i-1] と sma[i] が必要なため、
+ * period から開始するのが安全（period-1 は有効だが、period-2 は NaN）
+ *
+ * @param period SMAの期間（通常は長期SMAの期間を使用）
+ * @returns 売買ループの開始インデックス（= period）
+ */
+export function getSafeStartIndex(period: number): number {
+	return period;
+}

package/tools/trading_process/lib/strategies/bb_breakout.ts

@@ -0,0 +1,141 @@
+/**
+ * strategies/bb_breakout.ts - ボリンジャーバンドブレイクアウト戦略
+ *
+ * エントリー: 価格が下部バンド（-stddev σ）を下回った後、中央線（SMA）を上抜け
+ * エグジット: 価格が上部バンド（+stddev σ）に到達
+ */
+
+import { bollingerBands } from '../../../../lib/indicators.js';
+import type { Candle } from '../../types.js';
+import type { Overlay, ParamValidationResult, Signal, Strategy } from './types.js';
+
+/**
+ * BB戦略のデフォルトパラメータ
+ */
+const DEFAULT_PARAMS = {
+	period: 20,
+	stddev: 2,
+};
+
+/**
+ * パラメータのバリデーション
+ */
+export function validateParams(params: Record<string, number>): ParamValidationResult {
+	const errors: string[] = [];
+	const normalized = { ...DEFAULT_PARAMS, ...params };
+
+	if (normalized.period < 5) {
+		errors.push('period must be at least 5');
+	}
+	if (normalized.stddev <= 0) {
+		errors.push('stddev must be positive');
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+		normalizedParams: normalized,
+	};
+}
+
+/**
+ * ボリンジャーバンドブレイクアウト戦略
+ */
+export const bbBreakoutStrategy: Strategy = {
+	name: 'Bollinger Bands Breakout',
+	type: 'bb_breakout',
+	requiredBars: 25,
+	defaultParams: DEFAULT_PARAMS,
+
+	generate(candles: Candle[], params: Record<string, number>): Signal[] {
+		const { period, stddev } = { ...DEFAULT_PARAMS, ...params };
+		const closes = candles.map((c) => c.close);
+		const { middle, upper, lower } = bollingerBands(closes, period, stddev);
+
+		const signals: Signal[] = [];
+		const startIdx = period + 1;
+
+		// 下部バンドを下回ったかどうかを追跡
+		let belowLowerBand = false;
+
+		for (let i = 0; i < candles.length; i++) {
+			if (i < startIdx) {
+				signals.push({ time: candles[i].time, action: 'hold' });
+				continue;
+			}
+
+			const close = closes[i];
+			const prevClose = closes[i - 1];
+			const mid = middle[i];
+			const prevMid = middle[i - 1];
+			const up = upper[i];
+			const low = lower[i];
+			const prevLow = lower[i - 1];
+
+			if (
+				Number.isNaN(mid) ||
+				Number.isNaN(up) ||
+				Number.isNaN(low) ||
+				Number.isNaN(prevMid) ||
+				Number.isNaN(prevLow)
+			) {
+				signals.push({ time: candles[i].time, action: 'hold' });
+				continue;
+			}
+
+			// 下部バンドを下回ったら追跡開始
+			if (prevClose <= prevLow) {
+				belowLowerBand = true;
+			}
+
+			// エントリー: 下部バンドを下回った後、中央線を上抜け
+			if (belowLowerBand && prevClose <= prevMid && close > mid) {
+				signals.push({
+					time: candles[i].time,
+					action: 'buy',
+					reason: `BB Breakout: Price crossed above middle band (${mid.toFixed(0)})`,
+				});
+				belowLowerBand = false; // リセット
+			}
+			// エグジット: 上部バンドに到達
+			else if (close >= up) {
+				signals.push({
+					time: candles[i].time,
+					action: 'sell',
+					reason: `BB Upper Band reached: ${up.toFixed(0)}`,
+				});
+				belowLowerBand = false; // リセット
+			}
+			// シグナルなし
+			else {
+				signals.push({ time: candles[i].time, action: 'hold' });
+			}
+		}
+
+		return signals;
+	},
+
+	getOverlays(candles: Candle[], params: Record<string, number>): Overlay[] {
+		const { period, stddev } = { ...DEFAULT_PARAMS, ...params };
+		const closes = candles.map((c) => c.close);
+		const { middle, upper, lower } = bollingerBands(closes, period, stddev);
+
+		return [
+			{
+				type: 'line',
+				name: `BB Middle(${period})`,
+				color: '#fbbf24', // yellow（Closeの青と区別）
+				data: middle,
+			},
+			{
+				type: 'band',
+				name: `BB ±${stddev}σ`,
+				color: '#a855f7', // purple
+				fillColor: 'rgba(168, 85, 247, 0.15)',
+				data: { upper, middle, lower },
+			},
+		];
+	},
+};
+
+export default bbBreakoutStrategy;

package/tools/trading_process/lib/strategies/index.ts

@@ -0,0 +1,52 @@
+/**
+ * strategies/index.ts - 戦略レジストリ
+ */
+
+import { bbBreakoutStrategy } from './bb_breakout.js';
+import { macdCrossStrategy } from './macd_cross.js';
+import { rsiStrategy } from './rsi.js';
+import { smaCrossStrategy } from './sma_cross.js';
+import type { Strategy, StrategyRegistry, StrategyType } from './types.js';
+
+/**
+ * 戦略レジストリ
+ */
+const registry: StrategyRegistry = new Map<StrategyType, Strategy>();
+
+// 戦略を登録
+registry.set('sma_cross', smaCrossStrategy);
+registry.set('rsi', rsiStrategy);
+registry.set('macd_cross', macdCrossStrategy);
+registry.set('bb_breakout', bbBreakoutStrategy);
+
+/**
+ * 戦略を取得
+ */
+export function getStrategy(type: StrategyType): Strategy | undefined {
+	return registry.get(type);
+}
+
+/**
+ * 利用可能な戦略タイプを取得
+ */
+export function getAvailableStrategies(): StrategyType[] {
+	return Array.from(registry.keys());
+}
+
+/**
+ * 戦略を登録
+ */
+export function registerStrategy(strategy: Strategy): void {
+	registry.set(strategy.type, strategy);
+}
+
+/**
+ * 戦略のデフォルトパラメータを取得
+ */
+export function getStrategyDefaults(type: StrategyType): Record<string, number> | undefined {
+	const strategy = registry.get(type);
+	return strategy?.defaultParams;
+}
+
+export * from './types.js';
+export { bbBreakoutStrategy, macdCrossStrategy, rsiStrategy, smaCrossStrategy };

package/tools/trading_process/lib/strategies/macd_cross.ts

@@ -0,0 +1,256 @@
+/**
+ * strategies/macd_cross.ts - MACDクロスオーバー戦略
+ *
+ * エントリー: MACDラインがシグナルラインを上抜け（ゴールデンクロス）
+ * エグジット: MACDラインがシグナルラインを下抜け（デッドクロス）
+ *
+ * オプションフィルター:
+ *   - sma_filter_period: SMAトレンドフィルター（例: 200）。価格がSMA上の場合のみ買い
+ *   - zero_line_filter: ゼロラインフィルター（-1=ゼロ以下のみ, 0=なし, 1=ゼロ以上のみ）
+ *   - rsi_filter_period: RSIフィルター期間（例: 14）。0で無効
+ *   - rsi_filter_max: RSI上限（例: 70）。RSIがこの値未満の場合のみ買い
+ */
+
+import { macd as sharedMacd } from '../../../../lib/indicators.js';
+import type { Candle } from '../../types.js';
+import { calculateSMA } from '../sma.js';
+import { calculateRSI } from './rsi.js';
+import type { Overlay, ParamValidationResult, Signal, Strategy } from './types.js';
+
+/**
+ * MACD戦略のデフォルトパラメータ
+ */
+const DEFAULT_PARAMS: Record<string, number> = {
+	fast: 12,
+	slow: 26,
+	signal: 9,
+	// フィルター（0 = 無効）
+	sma_filter_period: 0,
+	zero_line_filter: 0, // -1=below zero only, 0=none, 1=above zero only
+	rsi_filter_period: 0,
+	rsi_filter_max: 100, // RSI < この値 の場合のみ買い（100=フィルター無効）
+};
+
+/**
+ * MACDを計算（lib/indicators.ts への委譲）
+ */
+function calculateMACD(
+	closes: number[],
+	fastPeriod: number,
+	slowPeriod: number,
+	signalPeriod: number,
+): { macd: number[]; signal: number[]; histogram: number[] } {
+	const result = sharedMacd(closes, fastPeriod, slowPeriod, signalPeriod);
+	return { macd: result.line, signal: result.signal, histogram: result.hist };
+}
+
+/**
+ * パラメータのバリデーション
+ */
+export function validateParams(params: Record<string, number>): ParamValidationResult {
+	const errors: string[] = [];
+	const normalized = { ...DEFAULT_PARAMS, ...params };
+
+	if (normalized.fast >= normalized.slow) {
+		errors.push('fast period must be less than slow period');
+	}
+	if (normalized.fast < 2) {
+		errors.push('fast period must be at least 2');
+	}
+	if (normalized.signal < 2) {
+		errors.push('signal period must be at least 2');
+	}
+	if (normalized.sma_filter_period < 0) {
+		errors.push('sma_filter_period must be >= 0');
+	}
+	if (![-1, 0, 1].includes(normalized.zero_line_filter)) {
+		errors.push('zero_line_filter must be -1, 0, or 1');
+	}
+	if (normalized.rsi_filter_period < 0) {
+		errors.push('rsi_filter_period must be >= 0');
+	}
+	if (normalized.rsi_filter_max < 0 || normalized.rsi_filter_max > 100) {
+		errors.push('rsi_filter_max must be 0-100');
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+		normalizedParams: normalized,
+	};
+}
+
+/**
+ * フィルター条件の説明文を生成
+ */
+function describeFilters(params: Record<string, number>): string {
+	const parts: string[] = [];
+	if (params.sma_filter_period > 0) {
+		parts.push(`SMA${params.sma_filter_period} trend filter`);
+	}
+	if (params.zero_line_filter === 1) {
+		parts.push('zero-line: above only');
+	} else if (params.zero_line_filter === -1) {
+		parts.push('zero-line: below only');
+	}
+	if (params.rsi_filter_period > 0 && params.rsi_filter_max < 100) {
+		parts.push(`RSI(${params.rsi_filter_period})<${params.rsi_filter_max}`);
+	}
+	return parts.length > 0 ? ` [${parts.join(', ')}]` : '';
+}
+
+/**
+ * MACDクロスオーバー戦略
+ */
+export const macdCrossStrategy: Strategy = {
+	name: 'MACD Crossover',
+	type: 'macd_cross',
+	requiredBars: 35, // slow(26) + signal(9)
+	defaultParams: DEFAULT_PARAMS,
+
+	generate(candles: Candle[], params: Record<string, number>): Signal[] {
+		const p = { ...DEFAULT_PARAMS, ...params };
+		const { fast, slow, signal: signalPeriod } = p;
+		const closes = candles.map((c) => c.close);
+		const { macd, signal, histogram: _histogram } = calculateMACD(closes, fast, slow, signalPeriod);
+
+		// フィルター用の指標を事前計算
+		const sma = p.sma_filter_period > 0 ? calculateSMA(closes, p.sma_filter_period) : null;
+		const rsi = p.rsi_filter_period > 0 ? calculateRSI(closes, p.rsi_filter_period) : null;
+
+		const signals: Signal[] = [];
+		// SMAフィルターが有効な場合、開始インデックスをその分遅らせる
+		const baseStartIdx = slow + signalPeriod;
+		const startIdx = sma ? Math.max(baseStartIdx, p.sma_filter_period) : baseStartIdx;
+
+		for (let i = 0; i < candles.length; i++) {
+			if (i < startIdx) {
+				signals.push({ time: candles[i].time, action: 'hold' });
+				continue;
+			}
+
+			const prevMACD = macd[i - 1];
+			const prevSignal = signal[i - 1];
+			const currMACD = macd[i];
+			const currSignal = signal[i];
+
+			if (Number.isNaN(prevMACD) || Number.isNaN(prevSignal) || Number.isNaN(currMACD) || Number.isNaN(currSignal)) {
+				signals.push({ time: candles[i].time, action: 'hold' });
+				continue;
+			}
+
+			// ゴールデンクロス: MACDがシグナルを上抜け
+			if (prevMACD <= prevSignal && currMACD > currSignal) {
+				// フィルター適用（買いシグナルのみにフィルターを適用）
+				const filterReasons: string[] = [];
+				let filtered = false;
+
+				// SMAトレンドフィルター: 価格がSMA上の場合のみ
+				if (sma && !Number.isNaN(sma[i]) && closes[i] < sma[i]) {
+					filtered = true;
+					filterReasons.push(`price(${closes[i].toFixed(0)}) < SMA${p.sma_filter_period}(${sma[i].toFixed(0)})`);
+				}
+
+				// ゼロラインフィルター
+				if (p.zero_line_filter === 1 && currMACD < 0) {
+					filtered = true;
+					filterReasons.push(`MACD(${currMACD.toFixed(0)}) below zero`);
+				} else if (p.zero_line_filter === -1 && currMACD > 0) {
+					filtered = true;
+					filterReasons.push(`MACD(${currMACD.toFixed(0)}) above zero`);
+				}
+
+				// RSIフィルター
+				if (rsi && !Number.isNaN(rsi[i]) && rsi[i] >= p.rsi_filter_max) {
+					filtered = true;
+					filterReasons.push(`RSI(${rsi[i].toFixed(1)}) >= ${p.rsi_filter_max}`);
+				}
+
+				if (filtered) {
+					signals.push({ time: candles[i].time, action: 'hold' });
+				} else {
+					const filterDesc = describeFilters(p);
+					signals.push({
+						time: candles[i].time,
+						action: 'buy',
+						reason: `MACD Golden Cross: MACD(${currMACD.toFixed(0)}) > Signal(${currSignal.toFixed(0)})${filterDesc}`,
+					});
+				}
+			}
+			// デッドクロス: MACDがシグナルを下抜け（エグジットなのでフィルター適用しない）
+			else if (prevMACD >= prevSignal && currMACD < currSignal) {
+				signals.push({
+					time: candles[i].time,
+					action: 'sell',
+					reason: `MACD Dead Cross: MACD(${currMACD.toFixed(0)}) < Signal(${currSignal.toFixed(0)})`,
+				});
+			}
+			// シグナルなし
+			else {
+				signals.push({ time: candles[i].time, action: 'hold' });
+			}
+		}
+
+		return signals;
+	},
+
+	getOverlays(candles: Candle[], params: Record<string, number>): Overlay[] {
+		const p = { ...DEFAULT_PARAMS, ...params };
+		const { fast, slow, signal: signalPeriod } = p;
+		const closes = candles.map((c) => c.close);
+		const { macd, signal, histogram } = calculateMACD(closes, fast, slow, signalPeriod);
+
+		const overlays: Overlay[] = [
+			{
+				type: 'line' as const,
+				name: `MACD(${fast},${slow})`,
+				color: '#22c55e',
+				data: macd,
+				panel: 'indicator' as const,
+			},
+			{
+				type: 'line' as const,
+				name: `Signal(${signalPeriod})`,
+				color: '#f97316',
+				data: signal,
+				panel: 'indicator' as const,
+			},
+			{
+				type: 'histogram' as const,
+				name: 'Histogram',
+				positiveColor: 'rgba(34, 197, 94, 0.7)',
+				negativeColor: 'rgba(239, 68, 68, 0.7)',
+				data: histogram,
+				panel: 'indicator' as const,
+			},
+		];
+
+		// SMAフィルターが有効な場合、SMAラインを価格チャートに表示
+		if (p.sma_filter_period > 0) {
+			const sma = calculateSMA(closes, p.sma_filter_period);
+			overlays.push({
+				type: 'line' as const,
+				name: `SMA${p.sma_filter_period} (filter)`,
+				color: '#facc15',
+				data: sma,
+				panel: 'price' as const,
+			});
+		}
+
+		// RSIフィルターが有効な場合、RSIラインをインジケータパネルに表示
+		if (p.rsi_filter_period > 0 && p.rsi_filter_max < 100) {
+			const rsi = calculateRSI(closes, p.rsi_filter_period);
+			overlays.push({
+				type: 'line' as const,
+				name: `RSI(${p.rsi_filter_period})`,
+				color: '#a78bfa',
+				data: rsi,
+				panel: 'indicator' as const,
+			});
+		}
+
+		return overlays;
+	},
+};
+
+export default macdCrossStrategy;