perp-cli 0.6.4 → 0.7.2

package/dist/bot/strategies/funding-auto.js

@@ -0,0 +1,572 @@
+import { registerStrategy } from "../strategy-registry.js";
+import { toHourlyRate, computeAnnualSpread } from "../../funding/normalize.js";
+/**
+ * Minimum notional per exchange (USD):
+ * - HL: ~$2 (0.001 ETH)
+ * - PAC: $10
+ * - LT: ~$21 (0.01 ETH)
+ * Use $12 as safe minimum across all exchanges.
+ */
+const MIN_NOTIONAL_USD = 12;
+/** Size precision per asset price range */
+function formatSizeForPrice(rawSize, price) {
+    // Higher price → fewer decimals (BTC: 4, ETH: 3, SOL: 1, small coins: 0)
+    if (price > 10000)
+        return rawSize.toFixed(4); // BTC
+    if (price > 1000)
+        return rawSize.toFixed(3); // ETH
+    if (price > 10)
+        return rawSize.toFixed(2); // SOL, AVAX
+    if (price > 1)
+        return rawSize.toFixed(1); // DOGE, etc
+    return rawSize.toFixed(0); // sub-$1 tokens
+}
+/** Normalize exchange symbol to base asset: "ETH-PERP" → "ETH", "ETHUSDT" → "ETH" */
+function normalizeSymbol(raw) {
+    return raw.toUpperCase().replace(/-PERP$/, "").replace(/USDT$/, "").replace(/USD$/, "").replace(/-USD$/, "");
+}
+// ── Cost helpers ──
+function calculateCosts(notional, feeA, feeB, slippageA, slippageB) {
+    const entryCost = (feeA + feeB + slippageA + slippageB) * notional;
+    const totalCost = entryCost * 2; // entry + exit
+    return { entryCost, totalCost };
+}
+function calculateBreakEven(totalCost, hourlyIncome) {
+    if (hourlyIncome <= 0)
+        return Infinity;
+    return totalCost / hourlyIncome;
+}
+// ── Strategy ──
+class FundingAutoStrategy {
+    name = "funding-auto";
+    _config = {};
+    // Config accessors
+    get spotPerpRatio() { return Number(this._config.spotPerpRatio ?? 0.7); }
+    get perpPerpRatio() { return Number(this._config.perpPerpRatio ?? 0.3); }
+    get perpPerpMinSpread() { return Number(this._config.perpPerpMinSpread ?? 20); }
+    get spotPerpMinSpread() { return Number(this._config.spotPerpMinSpread ?? 5); }
+    get perpPerpCloseSpread() { return Number(this._config.perpPerpCloseSpread ?? 5); }
+    get maxBreakEvenHours() { return Number(this._config.maxBreakEvenHours ?? 48); }
+    get maxPositions() { return Number(this._config.maxPositions ?? 5); }
+    get maxCapitalPct() { return Number(this._config.maxCapitalPct ?? 20); }
+    get defaultFeeRate() { return Number(this._config.defaultFeeRate ?? 0.0005); }
+    get defaultSlippage() { return Number(this._config.defaultSlippage ?? 0.001); }
+    get scanIntervalTicks() { return Number(this._config.scanIntervalTicks ?? 1); }
+    /** Position size: min of sizeUsd (if set) and maxCapitalPct% of total equity */
+    _cachedEquity = 0;
+    /** Symbols managed by this strategy instance (persists across ticks, prevents adopting unrelated positions) */
+    _managedSymbols = new Set();
+    getSizeUsd() {
+        const fixedSize = Number(this._config.sizeUsd ?? 0);
+        const capitalLimit = this._cachedEquity * (this.maxCapitalPct / 100);
+        if (fixedSize > 0 && capitalLimit > 0)
+            return Math.min(fixedSize, capitalLimit);
+        if (capitalLimit > 0)
+            return capitalLimit;
+        return fixedSize > 0 ? fixedSize : 100; // fallback
+    }
+    describe() {
+        return {
+            description: "Automated funding rate trading - perp-perp + spot-perp dual mode",
+            params: [
+                { name: "spotPerpRatio", type: "number", required: false, default: 0.7, description: "Capital ratio for spot-perp mode" },
+                { name: "perpPerpRatio", type: "number", required: false, default: 0.3, description: "Capital ratio for perp-perp mode" },
+                { name: "perpPerpMinSpread", type: "number", required: false, default: 20, description: "Min annualized spread % for perp-perp entry" },
+                { name: "spotPerpMinSpread", type: "number", required: false, default: 5, description: "Min annualized spread % for spot-perp entry" },
+                { name: "perpPerpCloseSpread", type: "number", required: false, default: 0, description: "Close perp-perp when spread reverses below this % (0 = only on reversal)" },
+                { name: "maxBreakEvenHours", type: "number", required: false, default: 48, description: "Max break-even hours to enter" },
+                { name: "maxPositions", type: "number", required: false, default: 5, description: "Max concurrent positions" },
+                { name: "maxCapitalPct", type: "number", required: false, default: 20, description: "Max % of total capital per position (e.g., 20 = 20%)" },
+                { name: "defaultFeeRate", type: "number", required: false, default: 0.0005, description: "Default taker fee rate (0.05%)" },
+                { name: "defaultSlippage", type: "number", required: false, default: 0.001, description: "Default slippage estimate (0.1%)" },
+                { name: "scanIntervalTicks", type: "number", required: false, default: 1, description: "Scan every N ticks" },
+                { name: "sizeUsd", type: "number", required: false, default: 0, description: "Fixed position size in USD (0 = use maxCapitalPct instead)" },
+            ],
+        };
+    }
+    async init(ctx, _snapshot) {
+        this._config = ctx.config;
+        ctx.state.set("lastScan", 0);
+        ctx.state.set("priceCache", new Map());
+        ctx.log(`[funding-auto] Starting with ${this.spotPerpRatio}/${this.perpPerpRatio} spot-perp/perp-perp split`);
+    }
+    async onTick(ctx, _snapshot) {
+        // Cache total equity across ALL exchanges for capital-based sizing
+        try {
+            const adapters = this.getAdapters(ctx);
+            let totalEquity = 0;
+            for (const [, adapter] of adapters) {
+                try {
+                    const bal = await adapter.getBalance();
+                    totalEquity += Number(bal.equity) || 0;
+                }
+                catch { /* skip */ }
+            }
+            this._cachedEquity = totalEquity > 0 ? totalEquity : this._cachedEquity;
+        }
+        catch { /* keep previous cached value */ }
+        // Get all adapters
+        const adapters = this.getAdapters(ctx);
+        if (adapters.size < 2) {
+            ctx.log(`[funding-auto] Need 2+ exchanges, have ${adapters.size}. Skipping.`);
+            return [];
+        }
+        // ── Discover existing arb pairs from live exchange positions ──
+        const positions = await this.discoverArbPairs(adapters);
+        // Fetch funding rates from all exchanges (price data cached for position sizing)
+        const ratesByExchange = new Map();
+        const priceCache = new Map(); // "exchange:symbol" -> price
+        for (const [name, adapter] of adapters) {
+            try {
+                const markets = await adapter.getMarkets();
+                const map = new Map();
+                for (const m of markets) {
+                    const raw = m.symbol.toUpperCase();
+                    const sym = normalizeSymbol(raw);
+                    const price = parseFloat(m.markPrice);
+                    map.set(sym, {
+                        rate: parseFloat(m.fundingRate),
+                        price,
+                        exchange: name,
+                    });
+                    if (price > 0) {
+                        priceCache.set(`${name}:${sym}`, price);
+                        priceCache.set(`${name}:${raw}`, price); // keep raw for order execution
+                    }
+                }
+                ratesByExchange.set(name, map);
+            }
+            catch {
+                // Skip unavailable exchange
+            }
+        }
+        // Store priceCache for use by openPosition/closePosition
+        ctx.state.set("priceCache", priceCache);
+        // Calculate notional for discovered positions (using current price)
+        for (const pos of positions) {
+            const price = priceCache.get(`${pos.longExchange}:${pos.symbol}`)
+                || priceCache.get(`${pos.shortExchange}:${pos.symbol}`) || 0;
+            if (price > 0) {
+                pos.notional = Math.max(pos.longSize, pos.shortSize) * price;
+            }
+        }
+        // ── Phase 1: Monitor existing positions for exit ──
+        const surviving = [];
+        for (const pos of positions) {
+            if (pos.mode === "perp-perp") {
+                // Check if spread has converged below close threshold
+                const longRates = ratesByExchange.get(pos.longExchange);
+                const shortRates = ratesByExchange.get(pos.shortExchange);
+                if (!longRates || !shortRates) {
+                    surviving.push(pos);
+                    continue;
+                }
+                const longInfo = longRates.get(pos.symbol);
+                const shortInfo = shortRates.get(pos.symbol);
+                if (!longInfo || !shortInfo) {
+                    surviving.push(pos);
+                    continue;
+                }
+                const currentSpread = computeAnnualSpread(shortInfo.rate, pos.shortExchange, longInfo.rate, pos.longExchange);
+                // Calculate real P&L from exchange history
+                const [longPnl, shortPnl] = await Promise.all([
+                    this.calculateRealPnl(adapters.get(pos.longExchange), pos.symbol),
+                    this.calculateRealPnl(adapters.get(pos.shortExchange), pos.symbol),
+                ]);
+                const totalFees = longPnl.fees + shortPnl.fees;
+                const totalFunding = longPnl.funding + shortPnl.funding;
+                pos.accumulatedFunding = totalFunding;
+                pos.totalCost = totalFees;
+                ctx.log(`[funding-auto] ${pos.symbol} spread ${currentSpread.toFixed(1)}% | ` +
+                    `fees $${totalFees.toFixed(4)} | funding $${totalFunding.toFixed(4)} | ` +
+                    `net $${(totalFunding - totalFees).toFixed(4)} (${pos.longExchange}↔${pos.shortExchange})`);
+                // Only close when spread REVERSES (≤ 0%) — never close a profitable position
+                // A spread of 5% or even 2% still earns funding. Closing costs more than keeping.
+                if (currentSpread <= 0) {
+                    ctx.log(`[funding-auto] Closing perp-perp ${pos.symbol}: spread REVERSED to ${currentSpread.toFixed(1)}%`);
+                    await this.closePosition(ctx, pos, adapters);
+                }
+                else {
+                    surviving.push(pos);
+                }
+            }
+            else if (pos.mode === "spot-perp") {
+                // Spot-perp: exit if perp funding flips negative (we are short perp)
+                const shortRates = ratesByExchange.get(pos.shortExchange);
+                if (!shortRates) {
+                    surviving.push(pos);
+                    continue;
+                }
+                const shortInfo = shortRates.get(pos.symbol);
+                if (!shortInfo) {
+                    surviving.push(pos);
+                    continue;
+                }
+                const hourlyRate = toHourlyRate(shortInfo.rate, pos.shortExchange);
+                const annualized = Math.abs(hourlyRate) * 8760 * 100;
+                const pnl = await this.calculateRealPnl(adapters.get(pos.shortExchange), pos.symbol);
+                pos.accumulatedFunding = pnl.funding;
+                pos.totalCost = pnl.fees;
+                ctx.log(`[funding-auto] ${pos.symbol} rate ${annualized.toFixed(1)}% | ` +
+                    `fees $${pnl.fees.toFixed(4)} | funding $${pnl.funding.toFixed(4)} | ` +
+                    `net $${(pnl.funding - pnl.fees).toFixed(4)} (${pos.shortExchange})`);
+                // Exit if funding flipped (rate went negative — shorts would pay instead of receive)
+                if (shortInfo.rate < 0) {
+                    ctx.log(`[funding-auto] Closing spot-perp ${pos.symbol}: funding flipped negative (${(shortInfo.rate * 100).toFixed(4)}%)`);
+                    await this.closePosition(ctx, pos, adapters);
+                }
+                else {
+                    if (annualized < this.spotPerpMinSpread) {
+                        ctx.log(`[funding-auto] Spot-perp ${pos.symbol} annualized rate dropped to ${annualized.toFixed(1)}% — monitoring`);
+                    }
+                    surviving.push(pos);
+                }
+            }
+        }
+        // ── Phase 2: Scan for new opportunities ──
+        if (ctx.tick % this.scanIntervalTicks !== 0)
+            return surviving.length > 0 ? [{ type: "noop" }] : [];
+        if (surviving.length >= this.maxPositions)
+            return [{ type: "noop" }];
+        ctx.state.set("lastScan", Date.now());
+        ctx.log(`[funding-auto] Scanning ${ratesByExchange.size} exchanges, equity: $${this._cachedEquity.toFixed(2)}, size: $${this.getSizeUsd().toFixed(2)}/pos, active: ${surviving.length}`);
+        const activeSymbols = new Set(surviving.map(p => `${p.symbol}:${p.mode}`));
+        // Also block symbols we already tried to enter (prevents re-entry on failed/tiny orders)
+        const attempted = ctx.state.get("attemptedSymbols") ?? new Set();
+        for (const sym of attempted)
+            activeSymbols.add(sym);
+        const opportunities = [];
+        // Collect all symbols across exchanges
+        const allSymbols = new Set();
+        for (const [, map] of ratesByExchange) {
+            for (const sym of map.keys())
+                allSymbols.add(sym);
+        }
+        const exchangeNames = [...ratesByExchange.keys()];
+        // ── Perp-Perp opportunities ──
+        for (const sym of allSymbols) {
+            if (activeSymbols.has(`${sym}:perp-perp`))
+                continue;
+            let minRate = Infinity, maxRate = -Infinity;
+            let minExchange = "", maxExchange = "";
+            for (const exName of exchangeNames) {
+                const info = ratesByExchange.get(exName)?.get(sym);
+                if (!info)
+                    continue;
+                const hourly = toHourlyRate(info.rate, exName);
+                if (hourly < minRate) {
+                    minRate = hourly;
+                    minExchange = exName;
+                }
+                if (hourly > maxRate) {
+                    maxRate = hourly;
+                    maxExchange = exName;
+                }
+            }
+            if (!minExchange || !maxExchange || minExchange === maxExchange)
+                continue;
+            // Need raw rates for computeAnnualSpread
+            const longInfo = ratesByExchange.get(minExchange).get(sym);
+            const shortInfo = ratesByExchange.get(maxExchange).get(sym);
+            const annualSpread = computeAnnualSpread(shortInfo.rate, maxExchange, longInfo.rate, minExchange);
+            if (annualSpread < this.perpPerpMinSpread)
+                continue;
+            // Calculate cost and break-even
+            const notional = this.getSizeUsd();
+            const hourlyIncome = Math.abs(maxRate - minRate) * notional;
+            const { totalCost } = calculateCosts(notional, this.defaultFeeRate, this.defaultFeeRate, this.defaultSlippage, this.defaultSlippage);
+            const breakEvenHours = calculateBreakEven(totalCost, hourlyIncome);
+            if (breakEvenHours >= this.maxBreakEvenHours)
+                continue;
+            if (hourlyIncome <= 0)
+                continue;
+            opportunities.push({
+                symbol: sym,
+                longExchange: minExchange,
+                shortExchange: maxExchange,
+                longRate: longInfo.rate,
+                shortRate: shortInfo.rate,
+                annualSpread,
+                hourlyIncome,
+                breakEvenHours,
+                mode: "perp-perp",
+            });
+        }
+        // ── Spot-Perp opportunities ──
+        // DISABLED: spot-perp requires SpotAdapter to buy spot (not yet integrated).
+        // Opening perp short without spot buy creates naked short = directional risk.
+        // TODO: Enable when SpotAdapter is wired into the strategy context.
+        // Sort by break-even hours ascending (best opportunities first)
+        opportunities.sort((a, b) => a.breakEvenHours - b.breakEvenHours);
+        if (opportunities.length > 0) {
+            const top = opportunities.slice(0, 3);
+            for (const o of top) {
+                ctx.log(`[funding-auto] ${o.mode} ${o.symbol}: spread ${o.annualSpread.toFixed(1)}%, BE ${o.breakEvenHours.toFixed(0)}h, income $${(o.hourlyIncome * 24).toFixed(4)}/day (${o.longExchange}↔${o.shortExchange})`);
+            }
+        }
+        else {
+            ctx.log(`[funding-auto] No opportunities found (perp-perp min ${this.perpPerpMinSpread}%, spot-perp min ${this.spotPerpMinSpread}%, BE max ${this.maxBreakEvenHours}h)`);
+        }
+        // ── Phase 3: Enter new positions ──
+        const slotsAvailable = this.maxPositions - surviving.length;
+        // Allocate slots by ratio
+        const perpPerpSlots = Math.max(1, Math.floor(slotsAvailable * this.perpPerpRatio));
+        const spotPerpSlots = Math.max(1, slotsAvailable - perpPerpSlots);
+        let perpPerpOpened = 0;
+        let spotPerpOpened = 0;
+        let currentCount = surviving.length;
+        for (const opp of opportunities) {
+            if (currentCount >= this.maxPositions)
+                break;
+            if (opp.mode === "perp-perp" && perpPerpOpened >= perpPerpSlots)
+                continue;
+            if (opp.mode === "spot-perp" && spotPerpOpened >= spotPerpSlots)
+                continue;
+            // Track attempted symbols to prevent re-entry on same tick cycle
+            attempted.add(`${opp.symbol}:${opp.mode}`);
+            ctx.state.set("attemptedSymbols", attempted);
+            const success = await this.openPosition(ctx, opp, adapters);
+            if (success) {
+                currentCount++;
+                this._managedSymbols.add(`${opp.symbol}:${opp.mode}`);
+                if (opp.mode === "perp-perp")
+                    perpPerpOpened++;
+                else
+                    spotPerpOpened++;
+                ctx.log(`[funding-auto] Opened ${opp.mode} ${opp.symbol}: spread ${opp.annualSpread.toFixed(1)}% | ` +
+                    `BE ${opp.breakEvenHours.toFixed(1)}h | income $${opp.hourlyIncome.toFixed(4)}/h | ` +
+                    `long ${opp.longExchange}, short ${opp.shortExchange} (${currentCount}/${this.maxPositions})`);
+            }
+        }
+        return [{ type: "noop" }];
+    }
+    async onStop(ctx) {
+        const adapters = this.getAdapters(ctx);
+        const positions = await this.discoverArbPairs(adapters);
+        if (positions.length === 0) {
+            ctx.log("[funding-auto] No positions to close.");
+            return [];
+        }
+        ctx.log(`[funding-auto] Stopping - closing ${positions.length} positions`);
+        for (const pos of positions) {
+            try {
+                await this.closePosition(ctx, pos, adapters);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`[funding-auto] Failed to close ${pos.symbol}: ${msg}`);
+            }
+        }
+        return [{ type: "cancel_all" }];
+    }
+    // ── Helpers ──
+    getAdapters(ctx) {
+        const adapters = new Map();
+        adapters.set(ctx.adapter.name.toLowerCase(), ctx.adapter);
+        const extra = ctx.state.get("extraAdapters");
+        if (extra) {
+            for (const [name, a] of extra)
+                adapters.set(name, a);
+        }
+        return adapters;
+    }
+    /** Resolve cached price for a symbol on a given exchange */
+    getCachedPrice(ctx, exchange, symbol) {
+        const cache = ctx.state.get("priceCache");
+        return cache?.get(`${exchange}:${symbol}`) ?? 0;
+    }
+    /** Format size with exchange-appropriate precision based on asset price */
+    formatSize(rawSize, _symbol) {
+        // Use price to determine precision
+        const price = rawSize > 0 ? this.getSizeUsd() / rawSize : 0;
+        return formatSizeForPrice(rawSize, price);
+    }
+    /** Discover existing arb pairs from live exchange positions */
+    async discoverArbPairs(adapters) {
+        const allPositions = new Map();
+        for (const [name, adapter] of adapters) {
+            try {
+                const exchangePositions = await adapter.getPositions();
+                for (const p of exchangePositions) {
+                    const sym = normalizeSymbol(p.symbol);
+                    if (!allPositions.has(sym))
+                        allPositions.set(sym, []);
+                    allPositions.get(sym).push({
+                        exchange: name,
+                        side: p.side,
+                        size: Math.abs(Number(p.size)),
+                        symbol: p.symbol, // raw for order execution
+                    });
+                }
+            }
+            catch { /* skip unavailable exchange */ }
+        }
+        // Find arb pairs: same symbol, opposite sides, different exchanges = perp-perp
+        const pairs = [];
+        const matchedShorts = new Set(); // track shorts already matched to perp-perp
+        for (const [sym, positionList] of allPositions) {
+            const longs = positionList.filter(p => p.side === "long");
+            const shorts = positionList.filter(p => p.side === "short");
+            for (const long of longs) {
+                for (const short of shorts) {
+                    if (long.exchange !== short.exchange) {
+                        pairs.push({
+                            id: `${sym}-${long.exchange}-${short.exchange}`,
+                            symbol: sym,
+                            mode: "perp-perp",
+                            longExchange: long.exchange,
+                            shortExchange: short.exchange,
+                            longSize: long.size,
+                            shortSize: short.size,
+                            longSymbol: long.symbol,
+                            shortSymbol: short.symbol,
+                            entrySpread: 0,
+                            entryTime: 0,
+                            notional: 0,
+                            totalCost: 0,
+                            accumulatedFunding: 0,
+                        });
+                        matchedShorts.add(`${sym}:${short.exchange}`);
+                    }
+                }
+            }
+            // Unmatched shorts = spot-perp ONLY if funding-auto previously entered them
+            // (prevents adopting unrelated positions like manual PURR short)
+            for (const short of shorts) {
+                if (!matchedShorts.has(`${sym}:${short.exchange}`) && this._managedSymbols.has(`${sym}:spot-perp`)) {
+                    pairs.push({
+                        id: `${sym}-spot-${short.exchange}`,
+                        symbol: sym,
+                        mode: "spot-perp",
+                        longExchange: short.exchange,
+                        shortExchange: short.exchange,
+                        longSize: 0,
+                        shortSize: short.size,
+                        longSymbol: "",
+                        shortSymbol: short.symbol,
+                        entrySpread: 0,
+                        entryTime: 0,
+                        notional: 0,
+                        totalCost: 0,
+                        accumulatedFunding: 0,
+                    });
+                }
+            }
+        }
+        return pairs;
+    }
+    /** Calculate actual P&L from exchange trade/funding history */
+    async calculateRealPnl(adapter, symbol) {
+        try {
+            const [trades, funding] = await Promise.all([
+                adapter.getTradeHistory(50),
+                adapter.getFundingPayments(50),
+            ]);
+            const symTrades = trades.filter(t => normalizeSymbol(t.symbol) === symbol);
+            const symFunding = funding.filter(f => normalizeSymbol(f.symbol) === symbol);
+            const totalFees = symTrades.reduce((s, t) => s + Math.abs(Number(t.fee)), 0);
+            const totalFunding = symFunding.reduce((s, f) => s + Number(f.payment), 0);
+            return { fees: totalFees, funding: totalFunding };
+        }
+        catch {
+            return { fees: 0, funding: 0 };
+        }
+    }
+    async openPosition(ctx, opp, adapters) {
+        if (opp.mode === "perp-perp") {
+            const longAdapter = adapters.get(opp.longExchange);
+            const shortAdapter = adapters.get(opp.shortExchange);
+            if (!longAdapter || !shortAdapter)
+                return false;
+            const price = this.getCachedPrice(ctx, opp.longExchange, opp.symbol)
+                || this.getCachedPrice(ctx, opp.shortExchange, opp.symbol);
+            if (price <= 0)
+                return false;
+            const notionalUsd = this.getSizeUsd();
+            const size = this.formatSize(notionalUsd / price, opp.symbol);
+            // Minimum notional check — skip if below exchange minimums
+            if (notionalUsd < MIN_NOTIONAL_USD) {
+                ctx.log(`[funding-auto] Skip ${opp.symbol}: notional $${notionalUsd.toFixed(0)} < min $${MIN_NOTIONAL_USD}`);
+                return false;
+            }
+            try {
+                await Promise.all([
+                    longAdapter.marketOrder(opp.symbol, "buy", size),
+                    shortAdapter.marketOrder(opp.symbol, "sell", size),
+                ]);
+                return true;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`[funding-auto] Perp-perp entry failed ${opp.symbol}: ${msg}`);
+                return false;
+            }
+        }
+        else {
+            // spot-perp: short perp (spot buy would need spot adapter — use perp adapter for now)
+            const shortAdapter = adapters.get(opp.shortExchange);
+            if (!shortAdapter)
+                return false;
+            const price = this.getCachedPrice(ctx, opp.shortExchange, opp.symbol);
+            if (price <= 0)
+                return false;
+            const notionalUsd = this.getSizeUsd();
+            const size = this.formatSize(notionalUsd / price, opp.symbol);
+            if (notionalUsd < MIN_NOTIONAL_USD) {
+                ctx.log(`[funding-auto] Skip ${opp.symbol}: notional $${notionalUsd.toFixed(0)} < min $${MIN_NOTIONAL_USD}`);
+                return false;
+            }
+            try {
+                // Short perp leg — spot buy is out-of-scope for perp-only adapters
+                await shortAdapter.marketOrder(opp.symbol, "sell", size);
+                ctx.log(`[funding-auto] Spot-perp ${opp.symbol}: perp short opened (spot leg requires manual hedge or spot adapter)`);
+                return true;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`[funding-auto] Spot-perp entry failed ${opp.symbol}: ${msg}`);
+                return false;
+            }
+        }
+    }
+    async closePosition(ctx, pos, adapters) {
+        if (pos.mode === "perp-perp") {
+            const longAdapter = adapters.get(pos.longExchange);
+            const shortAdapter = adapters.get(pos.shortExchange);
+            if (longAdapter && shortAdapter) {
+                // Use actual sizes from exchange positions, with raw exchange symbols
+                const longSize = formatSizeForPrice(pos.longSize, pos.longSize > 0 && pos.notional > 0 ? pos.notional / pos.longSize : 0);
+                const shortSize = formatSizeForPrice(pos.shortSize, pos.shortSize > 0 && pos.notional > 0 ? pos.notional / pos.shortSize : 0);
+                try {
+                    await Promise.all([
+                        longAdapter.marketOrder(pos.longSymbol, "sell", longSize),
+                        shortAdapter.marketOrder(pos.shortSymbol, "buy", shortSize),
+                    ]);
+                    const netPnl = pos.accumulatedFunding - pos.totalCost;
+                    ctx.log(`[funding-auto] Closed perp-perp ${pos.symbol} | funding $${pos.accumulatedFunding.toFixed(4)} - fees $${pos.totalCost.toFixed(4)} = net $${netPnl.toFixed(4)}`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    ctx.log(`[funding-auto] Close failed ${pos.symbol}: ${msg}`);
+                }
+            }
+        }
+        else {
+            // spot-perp: close perp short
+            const shortAdapter = adapters.get(pos.shortExchange);
+            if (!shortAdapter)
+                return;
+            const shortSize = formatSizeForPrice(pos.shortSize, pos.shortSize > 0 && pos.notional > 0 ? pos.notional / pos.shortSize : 0);
+            try {
+                await shortAdapter.marketOrder(pos.shortSymbol, "buy", shortSize);
+                const netPnl = pos.accumulatedFunding - pos.totalCost;
+                ctx.log(`[funding-auto] Closed spot-perp ${pos.symbol} | funding $${pos.accumulatedFunding.toFixed(4)} - fees $${pos.totalCost.toFixed(4)} = net $${netPnl.toFixed(4)}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.log(`[funding-auto] Close failed ${pos.symbol}: ${msg}`);
+            }
+        }
+    }
+}
+registerStrategy("funding-auto", (_config) => new FundingAutoStrategy());

package/dist/bot/strategies/grid-mm.d.ts

@@ -0,0 +1,25 @@
+import type { Strategy, StrategyContext, StrategyAction, EnrichedSnapshot } from "../strategy-types.js";
+export declare class GridMmStrategy implements Strategy {
+    readonly name = "grid-mm";
+    describe(): {
+        description: string;
+        params: ({
+            name: string;
+            type: "number";
+            required: boolean;
+            description: string;
+            default?: undefined;
+        } | {
+            name: string;
+            type: "number";
+            required: boolean;
+            default: number;
+            description: string;
+        })[];
+    };
+    private get params();
+    private _config;
+    init(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<void>;
+    onTick(ctx: StrategyContext, snapshot: EnrichedSnapshot): Promise<StrategyAction[]>;
+    onStop(_ctx: StrategyContext): Promise<StrategyAction[]>;
+}