perp-cli 0.4.2 → 0.4.9

package/dist/exchanges/lighter-spot.js

@@ -0,0 +1,415 @@
+/**
+ * Lighter Spot Adapter.
+ *
+ * Uses the same `/api/v1/sendTx` endpoint as perps — the only difference
+ * is the market_id (spot markets have different IDs from perp markets).
+ *
+ * Composes with LighterAdapter for signing and API access.
+ */
+export class LighterSpotAdapter {
+    name = "lighter";
+    _lt;
+    _spotMarketMap = new Map(); // "ETH/USDC" → market_id
+    _spotBaseMap = new Map(); // "ETH" → "ETH/USDC"
+    _spotDecimals = new Map();
+    _spotMinSize = new Map(); // min order sizes
+    _initialized = false;
+    constructor(ltAdapter) {
+        this._lt = ltAdapter;
+    }
+    async init() {
+        if (this._initialized)
+            return;
+        await this._loadSpotMarkets();
+        this._initialized = true;
+    }
+    async _loadSpotMarkets() {
+        try {
+            // Use orderBooks API with filter=spot for accurate market config
+            const res = await this._restGet("/orderBooks", { filter: "spot" });
+            for (const ob of res.order_books ?? []) {
+                if (ob.status !== "active")
+                    continue;
+                const symbol = ob.symbol.toUpperCase(); // e.g., "ETH/USDC"
+                this._spotMarketMap.set(symbol, ob.market_id);
+                this._spotDecimals.set(symbol, {
+                    size: ob.supported_size_decimals,
+                    price: ob.supported_price_decimals,
+                });
+                this._spotMinSize.set(symbol, {
+                    base: parseFloat(ob.min_base_amount || "0"),
+                    quote: parseFloat(ob.min_quote_amount || "0"),
+                });
+                const base = symbol.split("/")[0];
+                if (base)
+                    this._spotBaseMap.set(base, symbol);
+            }
+        }
+        catch (e) {
+            // Fallback: use explorer API if orderBooks fails
+            try {
+                const res = await fetch("https://explorer.elliot.ai/api/markets");
+                const markets = (await res.json());
+                for (const m of markets) {
+                    if (!m.symbol.includes("/"))
+                        continue;
+                    const symbol = m.symbol.toUpperCase();
+                    this._spotMarketMap.set(symbol, m.market_index);
+                    this._spotDecimals.set(symbol, { size: 2, price: 4 });
+                    const base = symbol.split("/")[0];
+                    if (base)
+                        this._spotBaseMap.set(base, symbol);
+                }
+            }
+            catch {
+                console.error("[lt-spot] Failed to load spot markets:", e instanceof Error ? e.message : e);
+            }
+        }
+    }
+    /** Resolve a symbol (e.g., "ETH" or "ETH/USDC") to the full spot symbol */
+    resolveSymbol(symbol) {
+        const upper = symbol.toUpperCase();
+        if (this._spotMarketMap.has(upper))
+            return upper;
+        // Try base token → full symbol
+        const full = this._spotBaseMap.get(upper);
+        if (full)
+            return full;
+        // Try adding /USDC
+        const withUsdc = `${upper}/USDC`;
+        if (this._spotMarketMap.has(withUsdc))
+            return withUsdc;
+        return upper;
+    }
+    async getSpotMarkets() {
+        await this.init();
+        const entries = Array.from(this._spotMarketMap.entries());
+        // Fetch all orderbooks in parallel (instead of sequential per-market)
+        const obResults = await Promise.allSettled(entries.map(([symbol]) => this.getSpotOrderbook(symbol).then(ob => {
+            if (ob.bids.length > 0 && ob.asks.length > 0) {
+                return String((Number(ob.bids[0][0]) + Number(ob.asks[0][0])) / 2);
+            }
+            return "0";
+        })));
+        return entries.map(([symbol], i) => {
+            const parts = symbol.split("/");
+            const base = parts[0] ?? "";
+            const quote = parts[1] ?? "USDC";
+            const dec = this._spotDecimals.get(symbol) ?? { size: 4, price: 2 };
+            const markPrice = obResults[i].status === "fulfilled" ? obResults[i].value : "0";
+            return {
+                symbol, baseToken: base, quoteToken: quote,
+                markPrice, volume24h: "0",
+                sizeDecimals: dec.size, priceDecimals: dec.price,
+            };
+        });
+    }
+    async getSpotOrderbook(symbol) {
+        await this.init();
+        const resolved = this.resolveSymbol(symbol);
+        const marketId = this._spotMarketMap.get(resolved);
+        if (marketId === undefined) {
+            throw new Error(`Unknown Lighter spot market: ${symbol}`);
+        }
+        try {
+            const res = await this._restGet("/orderBookOrders", {
+                market_id: String(marketId),
+                limit: "50",
+            });
+            return {
+                bids: (res.bids ?? []).map((l) => [l.price, l.remaining_base_amount ?? l.size ?? "0"]),
+                asks: (res.asks ?? []).map((l) => [l.price, l.remaining_base_amount ?? l.size ?? "0"]),
+            };
+        }
+        catch {
+            return { bids: [], asks: [] };
+        }
+    }
+    async getSpotBalances() {
+        try {
+            await this.init();
+            const balances = [];
+            const address = this._lt.address;
+            if (!address)
+                return [];
+            const res = await this._restGet("/account", {
+                by: "l1_address",
+                value: address,
+            });
+            const acct = res.accounts?.find(a => a.account_index === this._lt.accountIndex)
+                ?? res.accounts?.[0];
+            if (!acct)
+                return [];
+            // Perp USDC balance (collateral / available for perp trading)
+            balances.push({
+                token: "USDC",
+                total: String(acct.collateral ?? 0),
+                available: String(acct.available_balance ?? 0),
+                held: String(Math.max(0, Number(acct.collateral ?? 0) - Number(acct.available_balance ?? 0))),
+            });
+            // Spot token balances from the assets array
+            if (acct.assets && acct.assets.length > 0) {
+                for (const asset of acct.assets) {
+                    const bal = parseFloat(asset.balance || "0");
+                    const locked = parseFloat(asset.locked_balance || "0");
+                    if (asset.symbol === "USDC") {
+                        // Add spot USDC as separate entry so caller can distinguish
+                        balances.push({
+                            token: "USDC_SPOT",
+                            total: asset.balance,
+                            available: String(bal - locked),
+                            held: asset.locked_balance,
+                        });
+                    }
+                    else if (bal > 0) {
+                        balances.push({
+                            token: asset.symbol,
+                            total: asset.balance,
+                            available: String(bal - locked),
+                            held: asset.locked_balance,
+                        });
+                    }
+                }
+            }
+            return balances;
+        }
+        catch {
+            return [];
+        }
+    }
+    async spotMarketOrder(symbol, side, size) {
+        await this.init();
+        const resolved = this.resolveSymbol(symbol);
+        const marketId = this._spotMarketMap.get(resolved);
+        if (marketId === undefined) {
+            throw new Error(`Unknown Lighter spot market: ${symbol}`);
+        }
+        // Validate min order size
+        const minSize = this._spotMinSize.get(resolved);
+        const sizeNum = parseFloat(size);
+        if (minSize && sizeNum < minSize.base) {
+            throw new Error(`Size ${size} below min_base_amount ${minSize.base} for ${resolved}`);
+        }
+        // Use orderbook-based price with 5% slippage (like Hyperliquid spot adapter)
+        const ob = await this.getSpotOrderbook(resolved);
+        let refPrice;
+        if (side === "buy") {
+            if (ob.asks.length === 0)
+                throw new Error(`No asks in ${resolved} spot orderbook`);
+            refPrice = Number(ob.asks[0][0]);
+        }
+        else {
+            if (ob.bids.length === 0)
+                throw new Error(`No bids in ${resolved} spot orderbook`);
+            refPrice = Number(ob.bids[0][0]);
+        }
+        // Validate min quote amount (size × price ≥ min_quote)
+        if (minSize && sizeNum * refPrice < minSize.quote) {
+            throw new Error(`Order value $${(sizeNum * refPrice).toFixed(2)} below min_quote_amount $${minSize.quote} for ${resolved}`);
+        }
+        const slippagePrice = side === "buy" ? refPrice * 1.05 : refPrice * 0.95;
+        const dec = this._spotDecimals.get(resolved) ?? { size: 2, price: 4 };
+        const baseAmount = Math.round(sizeNum * Math.pow(10, dec.size));
+        const priceTicks = Math.round(slippagePrice * Math.pow(10, dec.price));
+        return this._placeOrder({
+            marketIndex: marketId,
+            baseAmount,
+            price: Math.max(priceTicks, 1),
+            isAsk: side === "sell" ? 1 : 0,
+            orderType: 1, // MARKET
+            timeInForce: 0, // IOC
+        });
+    }
+    async spotLimitOrder(symbol, side, price, size, opts) {
+        await this.init();
+        const resolved = this.resolveSymbol(symbol);
+        const marketId = this._spotMarketMap.get(resolved);
+        if (marketId === undefined) {
+            throw new Error(`Unknown Lighter spot market: ${symbol}`);
+        }
+        // Validate min order size
+        const sizeNum = parseFloat(size);
+        const priceNum = parseFloat(price);
+        const minSize = this._spotMinSize.get(resolved);
+        if (minSize) {
+            if (sizeNum < minSize.base) {
+                throw new Error(`Size ${size} below min_base_amount ${minSize.base} for ${resolved}`);
+            }
+            if (sizeNum * priceNum < minSize.quote) {
+                throw new Error(`Order value $${(sizeNum * priceNum).toFixed(2)} below min_quote_amount $${minSize.quote} for ${resolved}`);
+            }
+        }
+        const dec = this._spotDecimals.get(resolved) ?? { size: 2, price: 4 };
+        const baseAmount = Math.round(sizeNum * Math.pow(10, dec.size));
+        const priceTicks = Math.round(priceNum * Math.pow(10, dec.price));
+        const isIoc = opts?.tif?.toUpperCase() === "IOC";
+        return this._placeOrder({
+            marketIndex: marketId,
+            baseAmount,
+            price: priceTicks,
+            isAsk: side === "sell" ? 1 : 0,
+            orderType: 0, // LIMIT
+            timeInForce: isIoc ? 0 : 1,
+        });
+    }
+    async spotCancelOrder(symbol, orderId) {
+        await this.init();
+        const resolved = this.resolveSymbol(symbol);
+        const marketId = this._spotMarketMap.get(resolved);
+        if (marketId === undefined) {
+            throw new Error(`Unknown Lighter spot market: ${symbol}`);
+        }
+        // Access signer through the adapter
+        const signer = this._lt.signer;
+        const nonce = await this._getNextNonce();
+        const signed = await signer.signCancelOrder({
+            marketIndex: marketId,
+            orderIndex: parseInt(orderId),
+            nonce,
+            apiKeyIndex: this._lt._apiKeyIndex,
+            accountIndex: this._lt.accountIndex,
+        });
+        return this._sendTx(signed);
+    }
+    /** Transfer USDC from perp account to spot account (required before spot buys) */
+    async transferUsdcToSpot(amount) {
+        return this._selfTransfer(amount, 0, 1); // route: Perp(0) → Spot(1)
+    }
+    /** Transfer USDC from spot account back to perp account */
+    async transferUsdcToPerp(amount) {
+        return this._selfTransfer(amount, 1, 0); // route: Spot(1) → Perp(0)
+    }
+    /**
+     * Internal self-transfer using raw WASM signTransfer.
+     * TS SDK's is_spot_account mapping is buggy (sets both fromRoute and toRoute
+     * to the same value), so we call the WASM module directly with explicit routes.
+     * Route types: 0 = Perp, 1 = Spot
+     */
+    async _selfTransfer(amount, fromRoute, toRoute) {
+        if (this._lt.isReadOnly)
+            throw new Error("Transfer requires API key");
+        const nonce = await this._getNextNonce();
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        const USDC_SCALE = 1_000_000; // 6 decimals
+        const scaledAmount = Math.floor(amount * USDC_SCALE);
+        const memo = "0x" + "00".repeat(32);
+        // Access the raw WASM module to bypass SDK's buggy route mapping
+        // Path: signer → WasmSignerClient → wallet (WasmSigner) → wasmModule
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const signerAny = this._lt.signer;
+        const wasmModule = (signerAny.wallet?.wasmModule ?? signerAny.wasmModule);
+        if (wasmModule?.signTransfer) {
+            const result = wasmModule.signTransfer(this._lt.accountIndex, 3, // toAccountIndex (self), assetIndex = USDC
+            fromRoute, toRoute, scaledAmount, 0, memo, nonce, apiKeyIndex, this._lt.accountIndex);
+            if (result.error)
+                throw new Error(`Transfer sign error: ${result.error}`);
+            return this._sendTx({ txType: result.txType ?? 12, txInfo: result.txInfo });
+        }
+        // Fallback: use SDK signTransfer with explicit route_from/route_to
+        // The SDK's signTransfer internally calls wasmModule.signTransfer with 10 args
+        const signer = this._lt.signer;
+        // Try SDK's higher-level transferSameMasterAccount first (if available)
+        const client = signer;
+        if (client.transferSameMasterAccount) {
+            const [txInfo, txHash, err] = await client.transferSameMasterAccount({
+                toAccountIndex: this._lt.accountIndex,
+                usdcAmount: amount, // SDK scales internally
+                asset_id: 3,
+                fee: 0, memo,
+            });
+            if (err)
+                throw new Error(`Transfer error: ${err}`);
+            return { code: 200, tx_hash: txHash };
+        }
+        // Last resort: SDK signTransfer
+        const signed = await signer.signTransfer({
+            toAccountIndex: this._lt.accountIndex,
+            usdcAmount: scaledAmount, asset_id: 3,
+            is_spot_account: toRoute === 1,
+            fee: 0, memo, nonce, apiKeyIndex,
+            accountIndex: this._lt.accountIndex,
+        });
+        return this._sendTx(signed);
+    }
+    /** Get the spot market ID for a symbol */
+    getSpotMarketId(symbol) {
+        return this._spotMarketMap.get(this.resolveSymbol(symbol));
+    }
+    /** Check if a base token has a spot market */
+    hasSpotMarket(base) {
+        return this._spotBaseMap.has(base.toUpperCase()) ||
+            this._spotMarketMap.has(`${base.toUpperCase()}/USDC`);
+    }
+    // ── Private helpers ──
+    async _placeOrder(opts) {
+        if (this._lt.isReadOnly) {
+            throw new Error("Spot trading requires a Lighter API key. Run `perp -e lighter manage setup-api-key` first.");
+        }
+        const nonce = await this._getNextNonce();
+        const signer = this._lt.signer;
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        const signed = await signer.signCreateOrder({
+            marketIndex: opts.marketIndex,
+            clientOrderIndex: 0,
+            baseAmount: opts.baseAmount,
+            price: opts.price,
+            isAsk: opts.isAsk,
+            orderType: opts.orderType,
+            timeInForce: opts.timeInForce,
+            reduceOnly: 0,
+            triggerPrice: 0,
+            orderExpiry: opts.timeInForce === 0 ? 0 : -1,
+            nonce,
+            apiKeyIndex,
+            accountIndex: this._lt.accountIndex,
+        });
+        if (signed.error) {
+            throw new Error(`Signer: ${signed.error}`);
+        }
+        return this._sendTx(signed);
+    }
+    async _getNextNonce() {
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        const res = await this._restGet("/nextNonce", {
+            account_index: String(this._lt.accountIndex),
+            api_key_index: String(apiKeyIndex),
+        });
+        return res.nonce ?? res.next_nonce ?? 0;
+    }
+    async _sendTx(signed) {
+        if (signed.error)
+            throw new Error(`Signer error: ${signed.error}`);
+        if (!signed.txInfo)
+            throw new Error("Signer returned empty txInfo");
+        const baseUrl = this._lt._baseUrl;
+        const res = await fetch(`${baseUrl}/api/v1/sendTx`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                tx_type: String(signed.txType ?? 0),
+                tx_info: signed.txInfo,
+            }),
+        });
+        const json = await res.json();
+        if (json.code !== 200)
+            throw new Error(`sendTx failed: ${json.message ?? JSON.stringify(json)}`);
+        return json;
+    }
+    async _restGet(path, params) {
+        const baseUrl = this._lt._baseUrl;
+        const url = new URL(`${baseUrl}/api/v1${path}`);
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+        const res = await fetch(url.toString());
+        if (!res.ok)
+            throw new Error(`GET ${path} failed (${res.status}): ${await res.text()}`);
+        return res.json();
+    }
+    async _restGetAuth(path, params) {
+        if (this._lt.isReadOnly)
+            throw new Error("Auth requires API key");
+        const auth = await this._lt.getAuthToken();
+        params.auth = auth;
+        return this._restGet(path, params);
+    }
+}

package/dist/exchanges/lighter.d.ts

@@ -1,4 +1,5 @@
 import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+import type { EvmSigner } from "../signer/interface.js";
 import type { WasmSignerClient as WasmSignerClientType } from "lighter-ts-sdk";
 export declare class LighterAdapter implements ExchangeAdapter {
     readonly name = "lighter";
@@ -15,6 +16,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private _chainId;
     private _testnet;
     private _readOnly;
+    private _evmSigner?;
     /**
      * @param evmKey    EVM private key (0x-prefixed, 32 bytes) — for deposits & key registration
      * @param testnet   Use testnet (chain ID 300) instead of mainnet (chain ID 304)
@@ -33,8 +35,14 @@ export declare class LighterAdapter implements ExchangeAdapter {
     get address(): string;
     get evmKey(): string;
     get isReadOnly(): boolean;
+    /** Inject an external EVM signer. Call before init() to skip LocalEvmSigner creation. */
+    setSigner(signer: EvmSigner): void;
     init(): Promise<void>;
+    /** Populate marketMap + decimals from /orderBooks API (safe to call multiple times) */
+    private _refreshMarketMap;
     getMarketIndex(symbol: string): number;
+    /** Ensure market map is populated; lazy-refresh if empty */
+    private ensureMarketMap;
     private getMarkPrice;
     private toTicks;
     getMarkets(): Promise<ExchangeMarketInfo[]>;
@@ -54,7 +62,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
         tif?: string;
     }): Promise<unknown>;
     cancelOrder(symbol: string, orderId: string): Promise<unknown>;
-    cancelAllOrders(_symbol?: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown>;
     modifyOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
     stopOrder(symbol: string, side: "buy" | "sell", size: string, triggerPrice: string, opts?: {
         limitPrice?: string;
@@ -68,7 +76,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
     getFundingHistory(symbol: string, limit?: number): Promise<{
         time: number;
         rate: string;
-        price: string;
+        price: string | null;
     }[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;