perp-cli 0.4.2 → 0.4.8

package/dist/exchanges/hyperliquid.js

@@ -1,23 +1,30 @@
 import { Hyperliquid } from "hyperliquid";
+import { LocalEvmSigner } from "../signer/evm-local.js";
 export class HyperliquidAdapter {
     name = "hyperliquid";
     sdk;
     _address;
     _privateKey;
     _testnet;
+    _evmSigner;
     _assetMap = new Map();
     _assetMapReverse = new Map();
+    _szDecimalsMap = new Map(); // symbol → szDecimals
     /** HIP-3 deployed perp dex name. Empty string = native (validator) perps. */
     _dex = "";
     // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
     constructor(privateKey, testnet = false) {
+        // Disable WebSocket in SDK — we use REST for all info calls and raw
+        // fetch for /exchange. This avoids the false "Please install ws" warning
+        // caused by the SDK's require('ws') failing in ESM context.
         this.sdk = new Hyperliquid({
             privateKey,
             testnet,
             walletAddress: undefined,
+            enableWs: false,
         });
         this._address = "";
-        this._privateKey = privateKey;
+        this._privateKey = privateKey ?? "";
         this._testnet = testnet;
     }
     /** Set the HIP-3 deployed perp dex to query/trade on. */
@@ -39,6 +46,10 @@ export class HyperliquidAdapter {
     get isTestnet() {
         return this._testnet;
     }
+    /** Inject an external EVM signer. Call before init() to skip LocalEvmSigner creation. */
+    setSigner(signer) {
+        this._evmSigner = signer;
+    }
     async init() {
         // Suppress "WebSocket connected" noise from hyperliquid SDK
         const origLog = console.log;
@@ -49,14 +60,10 @@ export class HyperliquidAdapter {
         finally {
             console.log = origLog;
         }
-        // Derive address from SDK or from private key directly
-        const wallet = this.sdk.wallet;
-        if (wallet && typeof wallet === "object" && "address" in wallet) {
-            this._address = String(wallet.address);
-        }
-        if (!this._address) {
-            const { ethers } = await import("ethers");
-            this._address = new ethers.Wallet(this._privateKey).address;
+        // Initialize EVM signer if not externally injected (skip if no key — read-only mode)
+        if (!this._evmSigner && this._privateKey) {
+            this._evmSigner = await LocalEvmSigner.create(this._privateKey);
+            this._address = this._evmSigner.getAddress();
         }
         // Build asset index map
         await this._loadAssetMap();
@@ -85,12 +92,15 @@ export class HyperliquidAdapter {
                     meta.universe.forEach((asset, idx) => {
                         this._assetMap.set(asset.name, idx);
                         this._assetMapReverse.set(idx, asset.name);
+                        if (asset.szDecimals !== undefined) {
+                            this._szDecimalsMap.set(asset.name, asset.szDecimals);
+                        }
                     });
                 }
             }
         }
-        catch {
-            // non-critical
+        catch (e) {
+            console.error("[hyperliquid] Failed to load asset map:", e instanceof Error ? e.message : e);
         }
     }
     /**
@@ -115,7 +125,24 @@ export class HyperliquidAdapter {
         }
         return sym; // return as-is, let downstream error
     }
-    getAssetIndex(symbol) {
+    /** Get szDecimals for a symbol (cached from init/getMeta) */
+    getSzDecimals(symbol) {
+        const resolved = this.resolveSymbol(symbol.toUpperCase());
+        return this._szDecimalsMap.get(resolved) ?? 2; // 2 is safe middle ground
+    }
+    /** HL official price rounding: 5 significant figures */
+    _hlRoundPrice(px, szDecimals, maxDecimals = 6) {
+        if (px > 100_000)
+            return String(Math.round(px));
+        const sig5 = Number(px.toPrecision(5));
+        const priceDec = Math.max(0, maxDecimals - szDecimals);
+        return Number(sig5.toFixed(priceDec)).toString();
+    }
+    async getAssetIndex(symbol) {
+        // Retry once if asset map is empty (e.g. init failed silently)
+        if (this._assetMap.size === 0) {
+            await this._loadAssetMap();
+        }
         const resolved = this.resolveSymbol(symbol);
         const idx = this._assetMap.get(resolved);
         if (idx !== undefined)
@@ -177,8 +204,14 @@ export class HyperliquidAdapter {
             ]),
         };
     }
+    ensureAddress() {
+        if (!this._address) {
+            throw new Error("No private key configured — account data unavailable. Run: perp init");
+        }
+    }
     /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
     async _getClearinghouseState() {
+        this.ensureAddress();
         const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
         const key = this._dex ? `acct:hl:chs:${this._address}:${this._dex}` : `acct:hl:chs:${this._address}`;
         return fetchAndCache(key, TTL_ACCOUNT, async () => {
@@ -210,10 +243,10 @@ export class HyperliquidAdapter {
                 const spotState = await this.sdk.info.spot.getSpotClearinghouseState(this._address);
                 const balances = spotState?.balances ?? [];
                 const usdc = balances.find((b) => String(b.coin).startsWith("USDC"));
-                const spotTotal = Number(usdc?.total ?? 0);
+                const spotTotal = usdc?.total !== undefined ? Number(usdc.total) : NaN;
                 const spotHold = Number(usdc?.hold ?? 0);
-                equity = spotTotal > 0 ? spotTotal : Number(margin.accountValue ?? cross.accountValue ?? 0);
-                available = spotTotal > 0 ? spotTotal - spotHold : Number(s?.withdrawable ?? 0);
+                equity = !isNaN(spotTotal) ? spotTotal : Number(margin.accountValue ?? cross.accountValue ?? 0);
+                available = !isNaN(spotTotal) ? spotTotal - spotHold : Number(s?.withdrawable ?? 0);
             }
             catch {
                 // Spot API failed — fall back to perp-only values
@@ -249,7 +282,7 @@ export class HyperliquidAdapter {
                 side: szi > 0 ? "long" : "short",
                 size: String(Math.abs(szi)),
                 entryPrice: String(pos.entryPx ?? "0"),
-                markPrice: String(pos.positionValue ? (Number(pos.positionValue) / Math.abs(szi)).toFixed(2) : "0"),
+                markPrice: String(pos.positionValue ? Number(pos.positionValue) / Math.abs(szi) : "0"),
                 liquidationPrice: String(pos.liquidationPx ?? "N/A"),
                 unrealizedPnl: String(pos.unrealizedPnl ?? "0"),
                 leverage: Number(pos.leverage?.value ?? 1),
@@ -257,11 +290,13 @@ export class HyperliquidAdapter {
         });
     }
     async getOpenOrders() {
+        this.ensureAddress();
         const orders = await this.sdk.info.getUserOpenOrders(this._address);
         return (orders ?? []).map((o) => ({
             orderId: String(o.oid ?? ""),
             symbol: String(o.coin ?? ""),
-            side: o.side === "B" ? "buy" : "sell",
+            // SDK convertSymbolsInObject already converts "B"→"buy", "A"→"sell"
+            side: String(o.side) === "B" ? "buy" : String(o.side) === "A" ? "sell" : o.side,
             price: String(o.limitPx ?? "0"),
             size: String(o.sz ?? "0"),
             filled: "0",
@@ -277,6 +312,7 @@ export class HyperliquidAdapter {
         catch { /* ignore */ }
     }
     async marketOrder(symbol, side, size) {
+        this.ensureSigner();
         if (this._dex) {
             const r = await this._dexMarketOrder(symbol, side, size);
             await this._invalidateAccountCache();
@@ -300,8 +336,8 @@ export class HyperliquidAdapter {
      * and constructs + signs the order action directly.
      */
     async _dexMarketOrder(symbol, side, size) {
-        const assetIndex = this.getAssetIndex(symbol.toUpperCase());
-        // Get current mark price from dex meta
+        const assetIndex = await this.getAssetIndex(symbol.toUpperCase());
+        // Get current mark price + szDecimals from dex meta
         const meta = await this._infoPost({
             type: "metaAndAssetCtxs",
             dex: this._dex,
@@ -310,57 +346,41 @@ export class HyperliquidAdapter {
         const midPrice = Number(ctx?.markPx ?? 0);
         if (midPrice <= 0)
             throw new Error(`Cannot get price for ${symbol} on dex ${this._dex}`);
-        // Apply 5% slippage (same as SDK default)
+        const szDec = meta[0]?.universe?.[assetIndex]?.szDecimals ?? 2;
+        // HL official rounding: 5 significant figures, max 6 decimals for perps
+        const MAX_DECIMALS_PERP = 6;
         const slippage = 0.05;
         const isBuy = side === "buy";
         const slippagePrice = isBuy ? midPrice * (1 + slippage) : midPrice * (1 - slippage);
-        const decimals = midPrice.toString().split(".")[1]?.length || 0;
-        const limitPrice = slippagePrice.toFixed(Math.max(0, decimals - 1));
+        const limitPrice = slippagePrice > 100_000
+            ? String(Math.round(slippagePrice))
+            : Number(Number(slippagePrice.toPrecision(5)).toFixed(Math.max(0, MAX_DECIMALS_PERP - szDec))).toString();
         return this._rawPlaceOrder({
             assetIndex,
             isBuy,
             price: limitPrice,
-            size,
+            size: Number(size).toFixed(szDec),
             orderType: { limit: { tif: "Ioc" } },
             reduceOnly: false,
         });
     }
     /**
-     * Place an order via raw exchange API with EIP-712 signing.
-     * This bypasses the SDK's symbolConversion and supports dex-specific orders.
+     * Sign and send any exchange action via raw EIP-712 signing.
+     * Bypasses the SDK entirely — works for order, batchModify, twapOrder, etc.
      */
-    async _rawPlaceOrder(opts) {
+    ensureSigner() {
+        if (!this._evmSigner) {
+            throw new Error("No private key configured. Run: perp init");
+        }
+    }
+    async _signAndSendAction(action) {
+        this.ensureSigner();
         const { encode } = await import("@msgpack/msgpack");
         const { ethers, keccak256 } = await import("ethers");
-        const wallet = new ethers.Wallet(this._privateKey);
         const isMainnet = !this._testnet;
         const baseUrl = isMainnet
             ? "https://api.hyperliquid.xyz"
             : "https://api.hyperliquid-testnet.xyz";
-        // Remove trailing zeros (HL API requirement)
-        const trimZeros = (s) => {
-            if (!s.includes("."))
-                return s;
-            const n = s.replace(/\.?0+$/, "");
-            return n === "-0" ? "0" : n;
-        };
-        const orderWire = {
-            a: opts.assetIndex,
-            b: opts.isBuy,
-            p: trimZeros(opts.price),
-            s: trimZeros(opts.size),
-            r: opts.reduceOnly,
-            t: opts.orderType,
-        };
-        const action = {
-            type: "order",
-            orders: [orderWire],
-            grouping: "na",
-        };
-        // Add dex field for HIP-3 deployed perps
-        if (this._dex) {
-            action.dex = this._dex;
-        }
         // Sign L1 action (replicates SDK's signL1Action)
         const nonce = Date.now();
         const msgPackBytes = encode(action);
@@ -386,7 +406,7 @@ export class HyperliquidAdapter {
             source: isMainnet ? "a" : "b",
             connectionId: hash,
         };
-        const sig = await wallet.signTypedData(phantomDomain, agentTypes, phantomAgent);
+        const sig = await this._evmSigner.signTypedData(phantomDomain, agentTypes, phantomAgent);
         const parsed = ethers.Signature.from(sig);
         const payload = {
             action,
@@ -405,18 +425,53 @@ export class HyperliquidAdapter {
         }
         return result;
     }
+    /**
+     * Place an order via raw exchange API with EIP-712 signing.
+     * This bypasses the SDK's symbolConversion and supports dex-specific orders.
+     */
+    async _rawPlaceOrder(opts) {
+        // Remove trailing zeros (HL API requirement)
+        const trimZeros = (s) => {
+            if (!s.includes("."))
+                return s;
+            const n = s.replace(/\.?0+$/, "");
+            return n === "-0" ? "0" : n;
+        };
+        const orderWire = {
+            a: opts.assetIndex,
+            b: opts.isBuy,
+            p: trimZeros(opts.price),
+            s: trimZeros(opts.size),
+            r: opts.reduceOnly,
+            t: opts.orderType,
+        };
+        const action = {
+            type: "order",
+            orders: [orderWire],
+            grouping: "na",
+        };
+        // Add dex field for HIP-3 deployed perps
+        if (this._dex) {
+            action.dex = this._dex;
+        }
+        return this._signAndSendAction(action);
+    }
     async limitOrder(symbol, side, price, size, opts) {
         // Normalize TIF: accept "IOC"/"GTC"/"ALO" (uppercase) or native "Ioc"/"Gtc"/"Alo"
         const rawTif = opts?.tif ?? "Gtc";
         const tifMap = { IOC: "Ioc", GTC: "Gtc", ALO: "Alo" };
         const tif = (tifMap[rawTif.toUpperCase()] ?? rawTif);
         const reduceOnly = opts?.reduceOnly ?? false;
+        // Round price/size to HL-supported decimals
+        const szDec = this.getSzDecimals(symbol);
+        const roundedPrice = this._hlRoundPrice(Number(price), szDec);
+        const roundedSize = Number(size).toFixed(szDec);
         // Use _rawPlaceOrder for both DEX and non-DEX (SDK exchange.placeOrder is unavailable)
         const result = await this._rawPlaceOrder({
-            assetIndex: this.getAssetIndex(symbol.toUpperCase()),
+            assetIndex: await this.getAssetIndex(symbol.toUpperCase()),
             isBuy: side === "buy",
-            price,
-            size,
+            price: roundedPrice,
+            size: roundedSize,
             orderType: { limit: { tif } },
             reduceOnly,
         });
@@ -424,17 +479,24 @@ export class HyperliquidAdapter {
         return result;
     }
     async cancelOrder(symbol, orderId) {
+        this.ensureSigner();
+        // HL SDK expects coin in "ETH-PERP" format (internal symbol convention)
+        const resolved = this.resolveSymbol(symbol);
         const result = await this.sdk.exchange.cancelOrder({
-            coin: symbol.toUpperCase(),
+            coin: resolved,
             o: parseInt(orderId),
         });
         await this._invalidateAccountCache();
         return result;
     }
     async cancelAllOrders(symbol) {
+        this.ensureSigner();
         const orders = await this.getOpenOrders();
         const toCancel = symbol
-            ? orders.filter((o) => o.symbol.toUpperCase() === symbol.toUpperCase())
+            ? orders.filter((o) => {
+                const norm = (s) => s.toUpperCase().replace(/-PERP$/, "");
+                return norm(o.symbol) === norm(symbol);
+            })
             : orders;
         const results = [];
         for (const o of toCancel) {
@@ -447,7 +509,11 @@ export class HyperliquidAdapter {
     }
     // ── Interface methods ──
     async editOrder(symbol, orderId, price, size) {
-        return this.modifyOrder(symbol, parseInt(orderId), "buy", price, size);
+        // Look up the existing order's side to preserve it (avoid flipping buy↔sell)
+        const openOrders = await this.getOpenOrders();
+        const existing = openOrders.find(o => o.orderId === orderId);
+        const side = existing?.side ?? "buy";
+        return this.modifyOrder(symbol, parseInt(orderId), side, price, size);
     }
     async setLeverage(symbol, leverage, marginMode = "cross") {
         return this.updateLeverage(symbol, leverage, marginMode === "cross");
@@ -484,11 +550,13 @@ export class HyperliquidAdapter {
         }));
     }
     async getOrderHistory(limit = 30) {
+        this.ensureAddress();
         const fills = await this.client.info.getUserFills(this._address);
         return (fills ?? []).slice(0, limit).map((f) => ({
             orderId: String(f.oid ?? ""),
             symbol: String(f.coin ?? ""),
-            side: String(f.side) === "B" ? "buy" : "sell",
+            // SDK convertSymbolsInObject already converts "B"→"buy", "A"→"sell"
+            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : f.side,
             price: String(f.px ?? "0"),
             size: String(f.sz ?? ""),
             filled: String(f.sz ?? ""),
@@ -497,17 +565,20 @@ export class HyperliquidAdapter {
         }));
     }
     async getTradeHistory(limit = 30) {
+        this.ensureAddress();
         const fills = await this.client.info.getUserFills(this._address);
         return (fills ?? []).slice(0, limit).map((f) => ({
             time: Number(f.time ?? 0),
             symbol: String(f.coin ?? ""),
-            side: String(f.side) === "B" ? "buy" : "sell",
+            // SDK convertSymbolsInObject already converts "B"→"buy", "A"→"sell"
+            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : f.side,
             price: String(f.px ?? "0"),
             size: String(f.sz ?? ""),
             fee: String(f.fee ?? "0"),
         }));
     }
     async getFundingPayments(limit = 30) {
+        this.ensureAddress();
         const now = Date.now();
         const history = await this.client.info.perpetuals.getUserFunding(this._address, now - 7 * 24 * 60 * 60 * 1000);
         return (history ?? []).slice(0, limit).map((h) => {
@@ -525,7 +596,7 @@ export class HyperliquidAdapter {
         return (history ?? []).slice(-limit).map((h) => ({
             time: Number(h.time ?? 0),
             rate: String(h.fundingRate ?? "0"),
-            price: "-",
+            price: null,
         }));
     }
     // ────────────────────────────────────────────────────────────
@@ -536,6 +607,7 @@ export class HyperliquidAdapter {
      * Python SDK: order() with trigger type {"trigger": {triggerPx, isMarket, tpsl: "tp"|"sl"}}
      */
     async triggerOrder(symbol, side, size, triggerPrice, tpsl, opts) {
+        this.ensureSigner();
         const orderParams = {
             coin: symbol.toUpperCase(),
             is_buy: side === "buy",
@@ -559,7 +631,7 @@ export class HyperliquidAdapter {
      * nktkas TS SDK: twapOrder({twap: {a, b, s, r, m, t}})
      */
     async twapOrder(symbol, side, size, durationMinutes, opts) {
-        const assetIndex = this.getAssetIndex(symbol);
+        const assetIndex = await this.getAssetIndex(symbol);
         const action = {
             type: "twapOrder",
             twap: {
@@ -577,7 +649,7 @@ export class HyperliquidAdapter {
      * Cancel a TWAP order.
      */
     async twapCancel(symbol, twapId) {
-        const assetIndex = this.getAssetIndex(symbol);
+        const assetIndex = await this.getAssetIndex(symbol);
         const action = {
             type: "twapCancel",
             a: assetIndex,
@@ -590,6 +662,7 @@ export class HyperliquidAdapter {
      * Uses SDK's built-in updateLeverage method.
      */
     async updateLeverage(symbol, leverage, isCross = true) {
+        this.ensureSigner();
         return this.sdk.exchange.updateLeverage(this.resolveSymbol(symbol), isCross ? "cross" : "isolated", leverage);
     }
     /**
@@ -597,6 +670,7 @@ export class HyperliquidAdapter {
      * amount > 0 to add margin, amount < 0 to remove
      */
     async updateIsolatedMargin(symbol, amount) {
+        this.ensureSigner();
         return this.sdk.exchange.updateIsolatedMargin(this.resolveSymbol(symbol), amount > 0, Math.round(Math.abs(amount) * 1e6));
     }
     /**
@@ -604,6 +678,7 @@ export class HyperliquidAdapter {
      * Python SDK: withdraw_from_bridge(amount, destination) → action type "withdraw3"
      */
     async withdraw(amount, destination) {
+        this.ensureSigner();
         try {
             return await this.sdk.exchange.initiateWithdrawal(destination, parseFloat(amount));
         }
@@ -625,6 +700,7 @@ export class HyperliquidAdapter {
      * Python SDK: usd_transfer(amount, destination)
      */
     async usdTransfer(amount, destination) {
+        this.ensureSigner();
         return this.sdk.exchange.usdTransfer(destination, amount);
     }
     /**
@@ -653,7 +729,15 @@ export class HyperliquidAdapter {
      * Modify an existing order.
      */
     async modifyOrder(symbol, orderId, newSide, newPrice, newSize, opts) {
-        const assetIndex = this.getAssetIndex(symbol);
+        const assetIndex = await this.getAssetIndex(symbol);
+        const szDec = this.getSzDecimals(symbol);
+        // Remove trailing zeros (HL API requirement)
+        const trimZeros = (s) => {
+            if (!s.includes("."))
+                return s;
+            const n = s.replace(/\.?0+$/, "");
+            return n === "-0" ? "0" : n;
+        };
         const action = {
             type: "batchModify",
             modifies: [{
@@ -661,14 +745,14 @@ export class HyperliquidAdapter {
                     order: {
                         a: assetIndex,
                         b: newSide === "buy",
-                        p: newPrice,
-                        s: newSize,
+                        p: trimZeros(this._hlRoundPrice(Number(newPrice), szDec)),
+                        s: trimZeros(Number(newSize).toFixed(szDec)),
                         r: opts?.reduceOnly ?? false,
                         t: { limit: { tif: "Gtc" } },
                     },
                 }],
         };
-        return this._sendExchangeAction(action);
+        return this._signAndSendAction(action);
     }
     /**
      * Schedule cancel: cancel all orders at a future time.
@@ -722,6 +806,7 @@ export class HyperliquidAdapter {
      * Get user trade fills.
      */
     async getUserFills(startTime, endTime) {
+        this.ensureAddress();
         const baseUrl = this._testnet
             ? "https://api.hyperliquid-testnet.xyz"
             : "https://api.hyperliquid.xyz";
@@ -744,6 +829,7 @@ export class HyperliquidAdapter {
      * Get user portfolio analytics.
      */
     async getPortfolio() {
+        this.ensureAddress();
         const baseUrl = this._testnet
             ? "https://api.hyperliquid-testnet.xyz"
             : "https://api.hyperliquid.xyz";
@@ -758,6 +844,7 @@ export class HyperliquidAdapter {
      * Query a specific order by OID.
      */
     async queryOrder(orderId) {
+        this.ensureAddress();
         const baseUrl = this._testnet
             ? "https://api.hyperliquid-testnet.xyz"
             : "https://api.hyperliquid.xyz";
@@ -847,42 +934,49 @@ export class HyperliquidAdapter {
      * Get referral info.
      */
     async getReferralInfo() {
+        this.ensureAddress();
         return this._infoPost({ type: "referral", user: this._address });
     }
     /**
      * Get fee info.
      */
     async getUserFees() {
+        this.ensureAddress();
         return this._infoPost({ type: "userFees", user: this._address });
     }
     /**
      * Get sub-accounts.
      */
     async getSubAccounts() {
+        this.ensureAddress();
         return this._infoPost({ type: "subAccounts", user: this._address });
     }
     /**
      * Get historical orders (up to 2000).
      */
     async getHistoricalOrders() {
+        this.ensureAddress();
         return this._infoPost({ type: "historicalOrders", user: this._address });
     }
     /**
      * Get approved builders.
      */
     async getApprovedBuilders() {
+        this.ensureAddress();
         return this._infoPost({ type: "approvedBuilders", user: this._address });
     }
     /**
      * Get vault details.
      */
     async getVaultDetails(vaultAddress) {
+        this.ensureAddress();
         return this._infoPost({ type: "vaultDetails", vaultAddress, user: this._address });
     }
     /**
      * Get delegations (staking).
      */
     async getDelegations() {
+        this.ensureAddress();
         return this._infoPost({ type: "delegations", user: this._address });
     }
     /**
@@ -899,20 +993,24 @@ export class HyperliquidAdapter {
         });
         return res.json();
     }
+    /**
+     * Public entry point for sending signed exchange actions.
+     * Used by HyperliquidSpotAdapter to delegate signing.
+     */
+    async exchangeAction(action) {
+        return this._signAndSendAction(action);
+    }
     /**
      * Send a raw exchange action through the SDK.
      * Used for methods not directly exposed by the SDK.
      */
     async _sendExchangeAction(action) {
         const exchange = this.sdk.exchange;
-        // Try using the SDK's internal _postAction if available
+        // Try using the SDK's internal postAction if available
         if (typeof exchange.postAction === "function") {
             return exchange.postAction(action);
         }
-        // Fallback: direct POST to /exchange
-        // This requires signing which the SDK normally handles internally
-        // If we get here, the SDK doesn't expose the method we need
-        throw new Error(`Hyperliquid SDK does not expose postAction(). ` +
-            `Action "${action.type}" may need a newer SDK version.`);
+        // Fallback: sign and send directly (bypasses SDK)
+        return this._signAndSendAction(action);
     }
 }

package/dist/exchanges/interface.d.ts

@@ -70,7 +70,7 @@ export interface 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[]>;
     getBalance(): Promise<ExchangeBalance>;

package/dist/exchanges/lighter-spot.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+import type { SpotAdapter, SpotMarketInfo, SpotBalance } from "./spot-interface.js";
+import type { LighterAdapter } from "./lighter.js";
+export declare class LighterSpotAdapter implements SpotAdapter {
+    readonly name = "lighter";
+    private _lt;
+    private _spotMarketMap;
+    private _spotBaseMap;
+    private _spotDecimals;
+    private _spotMinSize;
+    private _initialized;
+    constructor(ltAdapter: LighterAdapter);
+    init(): Promise<void>;
+    private _loadSpotMarkets;
+    /** Resolve a symbol (e.g., "ETH" or "ETH/USDC") to the full spot symbol */
+    private resolveSymbol;
+    getSpotMarkets(): Promise<SpotMarketInfo[]>;
+    getSpotOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getSpotBalances(): Promise<SpotBalance[]>;
+    spotMarketOrder(symbol: string, side: "buy" | "sell", size: string): Promise<unknown>;
+    spotLimitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        tif?: string;
+    }): Promise<unknown>;
+    spotCancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    /** Transfer USDC from perp account to spot account (required before spot buys) */
+    transferUsdcToSpot(amount: number): Promise<unknown>;
+    /** Transfer USDC from spot account back to perp account */
+    transferUsdcToPerp(amount: number): Promise<unknown>;
+    /**
+     * 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
+     */
+    private _selfTransfer;
+    /** Get the spot market ID for a symbol */
+    getSpotMarketId(symbol: string): number | undefined;
+    /** Check if a base token has a spot market */
+    hasSpotMarket(base: string): boolean;
+    private _placeOrder;
+    private _getNextNonce;
+    private _sendTx;
+    private _restGet;
+    private _restGetAuth;
+}