perp-cli 0.4.0 → 0.4.8

package/dist/exchanges/lighter.js

@@ -1,3 +1,4 @@
+import { LocalEvmSigner } from "../signer/evm-local.js";
 export class LighterAdapter {
     name = "lighter";
     _signer;
@@ -13,6 +14,7 @@ export class LighterAdapter {
     _chainId;
     _testnet;
     _readOnly;
+    _evmSigner;
     // In-memory cache removed — using file-based cache (src/cache.ts) for cross-process dedup
     /**
      * @param evmKey    EVM private key (0x-prefixed, 32 bytes) — for deposits & key registration
@@ -23,7 +25,7 @@ export class LighterAdapter {
         this._evmKey = evmKey;
         this._apiKey = opts?.apiKey || process.env.LIGHTER_API_KEY || "";
         this._accountIndexInit = opts?.accountIndex ?? parseInt(process.env.LIGHTER_ACCOUNT_INDEX || "-1");
-        this._apiKeyIndex = parseInt(process.env.LIGHTER_API_KEY_INDEX || "2");
+        this._apiKeyIndex = parseInt(process.env.LIGHTER_API_KEY_INDEX || "4");
         this._address = "";
         this._testnet = testnet;
         this._readOnly = !this._apiKey;
@@ -56,12 +58,21 @@ export class LighterAdapter {
     get isReadOnly() {
         return this._readOnly;
     }
+    /** Inject an external EVM signer. Call before init() to skip LocalEvmSigner creation. */
+    setSigner(signer) {
+        this._evmSigner = signer;
+    }
     async init() {
-        // Resolve address and account index from EVM key via REST
-        const { ethers } = await import("ethers");
-        const wallet = new ethers.Wallet(this._evmKey);
-        this._address = wallet.address;
-        // Fetch account index from REST API
+        // Initialize EVM signer if not externally injected (skip if no key — read-only mode)
+        if (!this._evmSigner && this._evmKey) {
+            this._evmSigner = await LocalEvmSigner.create(this._evmKey);
+            this._address = this._evmSigner.getAddress();
+        }
+        // Fetch account index from REST API (skip if no address — read-only mode)
+        if (!this._address) {
+            await this._refreshMarketMap();
+            return;
+        }
         const res = await fetch(`${this._baseUrl}/api/v1/account?by=l1_address&value=${this._address}`);
         const json = await res.json();
         if (json.accounts && json.accounts.length > 0) {
@@ -73,7 +84,7 @@ export class LighterAdapter {
         let signerReady = false;
         if (!this._apiKey && this._accountIndex >= 0) {
             try {
-                const autoKeyIndex = 2; // default for auto-setup
+                const autoKeyIndex = 4; // default for auto-setup (0-3 reserved by Lighter frontend)
                 const { privateKey: apiKey } = await this.setupApiKey(autoKeyIndex);
                 this._apiKey = apiKey;
                 this._apiKeyIndex = autoKeyIndex;
@@ -108,6 +119,11 @@ export class LighterAdapter {
             else if (cleanKey.length === 0) {
                 this._apiKey = "";
             }
+            else if (this._accountIndex < 0) {
+                // Account lookup failed or returned no accounts — cannot initialize WASM signer
+                console.error(`[lighter] Account index not available (got ${this._accountIndex}). Trading will be read-only. Ensure the wallet has a Lighter account or set LIGHTER_ACCOUNT_INDEX.`);
+                this._apiKey = "";
+            }
             else {
                 this._apiKey = cleanKey;
                 const client = await LighterAdapter.getWasmClient();
@@ -121,22 +137,59 @@ export class LighterAdapter {
                 this._signer = client;
             }
         }
-        if (this._apiKey) {
-            this._readOnly = false;
-        }
+        this._readOnly = !this._apiKey;
         // Build symbol → marketIndex map + decimals from orderBookDetails
-        try {
-            const res = await this.restGet("/orderBookDetails", {});
-            for (const d of res.order_book_details ?? []) {
-                this._marketMap.set(d.symbol.toUpperCase(), d.market_id);
-                this._marketDecimals.set(d.symbol.toUpperCase(), {
-                    size: d.size_decimals ?? 0,
-                    price: d.price_decimals ?? 0,
-                });
+        await this._refreshMarketMap();
+    }
+    /** Populate marketMap + decimals from /orderBooks API (safe to call multiple times) */
+    async _refreshMarketMap() {
+        // Retry up to 2 times with 1s delay on failure
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                // Prefer /orderBooks which has supported_size_decimals / supported_price_decimals
+                const res = await this.restGet("/orderBooks", {});
+                const books = res.order_books ?? [];
+                if (books.length === 0 && attempt === 0) {
+                    // Empty response (possible rate limit) — retry after delay
+                    await new Promise(r => setTimeout(r, 1000));
+                    continue;
+                }
+                for (const d of books) {
+                    const sym = d.symbol.toUpperCase();
+                    // Skip spot markets (id ≥ 2048) — those are handled by lighter-spot.ts
+                    if (d.market_id >= 2048)
+                        continue;
+                    this._marketMap.set(sym, d.market_id);
+                    this._marketDecimals.set(sym, {
+                        size: d.supported_size_decimals,
+                        price: d.supported_price_decimals,
+                    });
+                }
+                if (this._marketMap.size > 0)
+                    return; // success
             }
-        }
-        catch {
-            // Market map will be empty, use fallback
+            catch {
+                // /orderBooks failed — try fallback below
+            }
+            // Fallback to /orderBookDetails
+            try {
+                const res = await this.restGet("/orderBookDetails", {});
+                for (const d of res.order_book_details ?? []) {
+                    this._marketMap.set(d.symbol.toUpperCase(), d.market_id);
+                    this._marketDecimals.set(d.symbol.toUpperCase(), {
+                        size: d.size_decimals ?? 0,
+                        price: d.price_decimals ?? 0,
+                    });
+                }
+                if (this._marketMap.size > 0)
+                    return; // success
+            }
+            catch {
+                // Both APIs failed this attempt
+            }
+            // Delay before retry
+            if (attempt === 0)
+                await new Promise(r => setTimeout(r, 1000));
         }
     }
     getMarketIndex(symbol) {
@@ -145,18 +198,32 @@ export class LighterAdapter {
             throw new Error(`Unknown Lighter market: ${symbol}`);
         return idx;
     }
+    /** Ensure market map is populated; lazy-refresh if empty */
+    async ensureMarketMap() {
+        if (this._marketMap.size === 0) {
+            await this._refreshMarketMap();
+        }
+    }
     async getMarkPrice(symbol) {
         try {
             const res = await this.restGet("/orderBookDetails", {});
             const m = res.order_book_details?.find(d => d.symbol.toUpperCase() === symbol.toUpperCase());
-            return m?.last_trade_price ?? 0;
+            const price = m?.last_trade_price ?? 0;
+            if (price <= 0)
+                throw new Error(`Cannot determine mark price for ${symbol}`);
+            return price;
         }
-        catch {
-            return 0;
+        catch (e) {
+            if (e instanceof Error && e.message.startsWith("Cannot determine"))
+                throw e;
+            throw new Error(`Cannot determine mark price for ${symbol}`);
         }
     }
     toTicks(symbol, size, price) {
-        const dec = this._marketDecimals.get(symbol.toUpperCase()) ?? { size: 0, price: 0 };
+        const dec = this._marketDecimals.get(symbol.toUpperCase());
+        if (!dec) {
+            throw new Error(`No market decimals loaded for ${symbol}. Market data may not be initialized.`);
+        }
         return {
             baseAmount: Math.round(size * Math.pow(10, dec.size)),
             priceTicks: Math.round(price * Math.pow(10, dec.price)),
@@ -203,6 +270,7 @@ export class LighterAdapter {
     }
     async getOrderbook(symbol) {
         try {
+            await this.ensureMarketMap();
             const marketId = this.getMarketIndex(symbol);
             const res = await this.restGet("/orderBookOrders", {
                 market_id: String(marketId),
@@ -246,12 +314,12 @@ export class LighterAdapter {
                 size: String(Math.abs(posSize)),
                 entryPrice: String(p.avg_entry_price || "0"),
                 markPrice: String(posSize !== 0
-                    ? (Number(p.position_value || 0) / Math.abs(posSize)).toFixed(4)
+                    ? (Number(p.position_value || 0) / Math.abs(posSize)).toFixed(this._marketDecimals.get(String(p.symbol || "").toUpperCase())?.price ?? 4)
                     : "0"),
                 liquidationPrice: String(p.liquidation_price || "N/A"),
                 unrealizedPnl: String(p.unrealized_pnl || "0"),
                 leverage: Number(p.initial_margin_fraction || 0) > 0
-                    ? Math.round(100 / Number(p.initial_margin_fraction))
+                    ? Math.round(10000 / Number(p.initial_margin_fraction))
                     : 1,
             };
         });
@@ -307,6 +375,7 @@ export class LighterAdapter {
     }
     async marketOrder(symbol, side, size) {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount } = this.toTicks(symbol, parseFloat(size), 0);
@@ -331,9 +400,12 @@ export class LighterAdapter {
     }
     async limitOrder(symbol, side, price, size, opts) {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
+        // Map TIF string → Lighter numeric: IOC=0, GTT/GTC=1
+        const isIoc = opts?.tif?.toUpperCase() === "IOC";
         const signed = await this.signOrder({
             marketIndex,
             clientOrderIndex: 0,
@@ -341,16 +413,17 @@ export class LighterAdapter {
             price: priceTicks,
             isAsk: side === "sell" ? 1 : 0,
             orderType: 0, // ORDER_TYPE_LIMIT
-            timeInForce: 1, // GTT (Good Till Time) — rests on orderbook
+            timeInForce: isIoc ? 0 : 1, // 0=IOC (immediate fill or cancel), 1=GTT (rests on book)
             reduceOnly: opts?.reduceOnly ? 1 : 0,
             triggerPrice: 0,
-            orderExpiry: -1, // DEFAULT_28_DAY_ORDER_EXPIRY (WASM auto-computes 28 days)
+            orderExpiry: isIoc ? 0 : -1, // IOC: no expiry; GTT: 28-day default
             nonce,
         });
         return this.sendTx(signed);
     }
     async cancelOrder(symbol, orderId) {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const signed = await this._signer.signCancelOrder({
@@ -359,8 +432,18 @@ export class LighterAdapter {
         });
         return this.sendTx(signed);
     }
-    async cancelAllOrders(_symbol) {
+    async cancelAllOrders(symbol) {
         this.ensureSigner();
+        if (symbol) {
+            // Cancel only orders for this symbol: fetch open orders, filter, cancel individually
+            const orders = await this.getOpenOrders();
+            const filtered = orders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase());
+            const results = [];
+            for (const o of filtered) {
+                results.push(await this.cancelOrder(o.symbol, o.orderId));
+            }
+            return results;
+        }
         const nonce = await this.getNextNonce();
         const signed = await this._signer.signCancelAllOrders({
             timeInForce: 0, time: Math.floor(Date.now() / 1000) + 86400, nonce,
@@ -370,6 +453,7 @@ export class LighterAdapter {
     }
     async modifyOrder(symbol, orderId, price, size) {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
@@ -390,6 +474,7 @@ export class LighterAdapter {
     }
     async stopOrder(symbol, side, size, triggerPrice, opts) {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount } = this.toTicks(symbol, parseFloat(size), 0);
@@ -422,6 +507,7 @@ export class LighterAdapter {
     }
     async updateLeverage(symbol, leverage, marginMode = "cross") {
         this.ensureSigner();
+        await this.ensureMarketMap();
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         // fraction = initial margin fraction in basis points: 10000/leverage
@@ -453,13 +539,15 @@ export class LighterAdapter {
         return this.updateLeverage(symbol, leverage, marginMode);
     }
     async getRecentTrades(symbol, limit = 20) {
+        await this.ensureMarketMap();
         const marketId = this.getMarketIndex(symbol);
         const res = await this.restGet("/recentTrades", { market_id: String(marketId), limit: String(limit) });
         const trades = (res.trades ?? []);
         return trades.map((t) => ({
             time: Number(t.timestamp ?? 0) * 1000,
             symbol,
-            side: t.is_ask ? "sell" : "buy",
+            // /recentTrades returns is_maker_ask: maker was asking → taker bought
+            side: t.is_maker_ask ? "buy" : "sell",
             price: String(t.price ?? "0"),
             size: String(t.base_amount ?? t.amount ?? ""),
             fee: String(t.fee ?? "0"),
@@ -550,6 +638,7 @@ export class LighterAdapter {
      * Get candle data for a market.
      */
     async getCandles(symbol, resolution, startTime, endTime, countBack = 100) {
+        await this.ensureMarketMap();
         const marketId = this.getMarketIndex(symbol);
         return this.restGet("/candles", {
             market_id: String(marketId),
@@ -586,6 +675,9 @@ export class LighterAdapter {
     async _getTradeHistoryRaw(limit = 100) {
         if (this._accountIndex < 0)
             return { trades: [] };
+        // Ensure market map is populated (init may have been rate-limited)
+        if (this._marketMap.size === 0)
+            await this._refreshMarketMap();
         const allTrades = [];
         const entries = Array.from(this._marketMap.entries());
         const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/trades", {
@@ -610,6 +702,8 @@ export class LighterAdapter {
     async _getPositionFundingRaw() {
         if (this._accountIndex < 0)
             return { funding: [] };
+        if (this._marketMap.size === 0)
+            await this._refreshMarketMap();
         const allFunding = [];
         const entries = Array.from(this._marketMap.entries());
         const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/positionFunding", {
@@ -826,8 +920,10 @@ export class LighterAdapter {
      * Uses WASM signer to sign + ETH key for L1 signature.
      * Returns the generated key pair.
      */
-    async setupApiKey(apiKeyIndex = 2) {
-        const { ethers } = await import("ethers");
+    async setupApiKey(apiKeyIndex = 4) {
+        if (!this._evmSigner) {
+            throw new Error("No EVM private key configured. Run: perp init");
+        }
         // 1. Generate key pair
         const { privateKey, publicKey } = await LighterAdapter.generateApiKey();
         // 2. Get nonce from API
@@ -857,9 +953,8 @@ export class LighterAdapter {
         if (!signed.txInfo || !signed.messageToSign) {
             throw new Error("SignChangePubKey returned incomplete response");
         }
-        // 4. Sign messageToSign with ETH key (EIP-191 personal_sign)
-        const wallet = new ethers.Wallet(this._evmKey);
-        const l1Sig = await wallet.signMessage(signed.messageToSign);
+        // 4. Sign messageToSign with EVM signer (EIP-191 personal_sign)
+        const l1Sig = await this._evmSigner.signMessage(signed.messageToSign);
         // 5. Add L1Sig to txInfo
         const txInfo = JSON.parse(signed.txInfo);
         txInfo.L1Sig = l1Sig;
@@ -898,7 +993,7 @@ export class LighterAdapter {
                         continue;
                     }
                     const retryTxInfo = JSON.parse(retrySigned.txInfo);
-                    retryTxInfo.L1Sig = await wallet.signMessage(retrySigned.messageToSign);
+                    retryTxInfo.L1Sig = await this._evmSigner.signMessage(retrySigned.messageToSign);
                     const retryRes = await fetch(`${this._baseUrl}/api/v1/sendTx`, {
                         method: "POST",
                         headers: { "Content-Type": "application/x-www-form-urlencoded" },

package/dist/exchanges/pacifica.d.ts

@@ -1,13 +1,20 @@
 import { Keypair } from "@solana/web3.js";
 import { PacificaClient, type Network } from "../pacifica/index.js";
 import type { ExchangeAdapter, ExchangeMarketInfo, ExchangePosition, ExchangeOrder, ExchangeBalance, ExchangeTrade, ExchangeFundingPayment, ExchangeKline } from "./interface.js";
+import type { SolanaSigner } from "../signer/interface.js";
 export declare class PacificaAdapter implements ExchangeAdapter {
     readonly name = "pacifica";
     private client;
-    readonly keypair: Keypair;
+    private _solanaSigner;
+    private _hasRealKey;
     private account;
     private signMessage;
-    constructor(keypair: Keypair, network?: Network, builderCode?: string);
+    constructor(keypair: Keypair, network?: Network, builderCode?: string, hasRealKey?: boolean);
+    private ensureSigner;
+    /** Inject an external Solana signer. */
+    setSigner(signer: SolanaSigner): void;
+    /** Access the underlying Keypair (only available with LocalSolanaSigner). */
+    get keypair(): Keypair;
     private _getPrices;
     private _getPositions;
     get publicKey(): string;
@@ -27,7 +34,7 @@ export declare class PacificaAdapter implements ExchangeAdapter {
         tif?: string;
     }): Promise<unknown>;
     cancelOrder(symbol: string, orderId: string): Promise<unknown>;
-    cancelAllOrders(_symbol?: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown>;
     editOrder(symbol: string, orderId: string, price: string, size: string): Promise<unknown>;
     setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<{
         symbol: string;
@@ -42,7 +49,7 @@ export declare class PacificaAdapter 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[]>;

package/dist/exchanges/pacifica.js

@@ -1,22 +1,37 @@
-import nacl from "tweetnacl";
 import { PacificaClient } from "../pacifica/index.js";
-function makeSignMessage(keypair) {
-    return async (message) => {
-        return nacl.sign.detached(message, keypair.secretKey);
-    };
-}
+import { LocalSolanaSigner } from "../signer/solana-local.js";
 export class PacificaAdapter {
     name = "pacifica";
     client;
-    keypair;
+    _solanaSigner;
+    _hasRealKey;
     account;
     signMessage;
     // In-memory caches removed — using file-based cache (src/cache.ts) for cross-process dedup
-    constructor(keypair, network = "mainnet", builderCode) {
-        this.keypair = keypair;
-        this.account = keypair.publicKey.toBase58();
+    constructor(keypair, network = "mainnet", builderCode, hasRealKey = true) {
+        this._solanaSigner = new LocalSolanaSigner(keypair);
+        this._hasRealKey = hasRealKey;
+        this.account = this._solanaSigner.getPublicKeyBase58();
         this.client = new PacificaClient({ network, builderCode });
-        this.signMessage = makeSignMessage(keypair);
+        this.signMessage = (msg) => this._solanaSigner.signMessage(msg);
+    }
+    ensureSigner() {
+        if (!this._hasRealKey) {
+            throw new Error("No private key configured. Run: perp init");
+        }
+    }
+    /** Inject an external Solana signer. */
+    setSigner(signer) {
+        this._solanaSigner = signer;
+        this.account = signer.getPublicKeyBase58();
+        this.signMessage = (msg) => this._solanaSigner.signMessage(msg);
+    }
+    /** Access the underlying Keypair (only available with LocalSolanaSigner). */
+    get keypair() {
+        if (this._solanaSigner instanceof LocalSolanaSigner) {
+            return this._solanaSigner._keypair;
+        }
+        throw new Error("keypair not available with external signer");
     }
     async _getPrices() {
         const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
@@ -62,24 +77,13 @@ export class PacificaAdapter {
         };
     }
     async getBalance() {
-        const [info, positions, prices] = await Promise.all([
+        const [info, positions] = await Promise.all([
             this.client.getAccount(this.account),
             this._getPositions(),
-            this._getPrices(),
         ]);
         const raw = info;
-        const priceMap = new Map(prices.map((p) => [p.symbol, Number(p.mark)]));
-        // Sum actual unrealized PnL from positions (mark vs entry)
-        let totalPnl = 0;
-        for (const p of positions) {
-            const mark = priceMap.get(p.symbol) ?? 0;
-            const entry = Number(p.entry_price);
-            const amount = Number(p.amount);
-            const side = p.side === "bid" ? "long" : "short";
-            totalPnl += side === "long"
-                ? (mark - entry) * amount
-                : (entry - mark) * amount;
-        }
+        // Use API-provided unrealized PnL from positions
+        const totalPnl = positions.reduce((sum, p) => sum + Number(p.unrealized_pnl ?? 0), 0);
         return {
             equity: info.account_equity,
             available: info.available_to_spend,
@@ -104,14 +108,8 @@ export class PacificaAdapter {
             // Settings API may not be available
         }
         return positions.map((p) => {
-            const mark = priceMap.get(p.symbol)?.mark ?? "0";
-            const entryPrice = Number(p.entry_price);
-            const amount = Number(p.amount);
-            const markNum = Number(mark);
+            const mark = priceMap.get(p.symbol)?.mark ?? p.mark_price ?? "0";
             const side = p.side === "bid" ? "long" : "short";
-            const pnl = side === "long"
-                ? (markNum - entryPrice) * amount
-                : (entryPrice - markNum) * amount;
             return {
                 symbol: p.symbol,
                 side: side,
@@ -119,8 +117,8 @@ export class PacificaAdapter {
                 entryPrice: String(p.entry_price),
                 markPrice: mark,
                 liquidationPrice: String(p.liquidation_price ?? "N/A"),
-                unrealizedPnl: pnl.toFixed(4),
-                leverage: levMap.get(String(p.symbol)) ?? 1,
+                unrealizedPnl: String(p.unrealized_pnl ?? "0"),
+                leverage: p.leverage ?? levMap.get(String(p.symbol)) ?? 1,
             };
         });
     }
@@ -141,21 +139,37 @@ export class PacificaAdapter {
         });
     }
     async marketOrder(symbol, side, size) {
+        this.ensureSigner();
         return this.client.createMarketOrder({ symbol, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: false, slippage_percent: "1" }, this.account, this.signMessage);
     }
     async limitOrder(symbol, side, price, size, opts) {
+        this.ensureSigner();
         return this.client.createLimitOrder({ symbol, price, amount: size, side: side === "buy" ? "bid" : "ask", reduce_only: opts?.reduceOnly ?? false, tif: (opts?.tif ?? "GTC") }, this.account, this.signMessage);
     }
     async cancelOrder(symbol, orderId) {
+        this.ensureSigner();
         return this.client.cancelOrder({ symbol, order_id: Number(orderId) }, this.account, this.signMessage);
     }
-    async cancelAllOrders(_symbol) {
+    async cancelAllOrders(symbol) {
+        this.ensureSigner();
+        if (symbol) {
+            // Cancel only orders for this symbol: fetch open orders, filter, cancel individually
+            const orders = await this.getOpenOrders();
+            const filtered = orders.filter(o => o.symbol.toUpperCase() === symbol.toUpperCase());
+            const results = [];
+            for (const o of filtered) {
+                results.push(await this.cancelOrder(o.symbol, o.orderId));
+            }
+            return results;
+        }
         return this.client.cancelAllOrders({ all_symbols: true, exclude_reduce_only: false }, this.account, this.signMessage);
     }
     async editOrder(symbol, orderId, price, size) {
+        this.ensureSigner();
         return this.client.editOrder({ symbol, order_id: Number(orderId), price, amount: size }, this.account, this.signMessage);
     }
     async setLeverage(symbol, leverage, marginMode = "cross") {
+        this.ensureSigner();
         await this.client.updateLeverage({ symbol, leverage }, this.account, this.signMessage);
         if (marginMode === "isolated") {
             await this.client.updateMarginMode({ symbol, is_isolated: true }, this.account, this.signMessage);
@@ -163,6 +177,7 @@ export class PacificaAdapter {
         return { symbol, leverage, marginMode };
     }
     async stopOrder(symbol, side, size, triggerPrice, opts) {
+        this.ensureSigner();
         return this.client.createStopOrder({
             symbol,
             side: side === "buy" ? "bid" : "ask",
@@ -173,12 +188,12 @@ export class PacificaAdapter {
     async getRecentTrades(symbol, _limit = 20) {
         const trades = await this.client.getTrades(symbol);
         return trades.slice(0, _limit).map((t) => ({
-            time: new Date(t.created_at).getTime(),
+            time: Number(t.created_at ?? 0),
             symbol,
             side: t.side === "bid" ? "buy" : "sell",
             price: t.price,
             size: t.amount,
-            fee: "0",
+            fee: String(t.fee ?? "0"),
         }));
     }
     async getFundingHistory(symbol, limit = 10) {

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

@@ -0,0 +1,45 @@
+/**
+ * Spot trading interface for exchanges that support both spot and perp.
+ * Separate from ExchangeAdapter because spot uses balance-based tracking
+ * (not position-based) and has no leverage, liquidation, or funding concepts.
+ *
+ * Supported: Hyperliquid, Lighter (Pacifica is perp-only)
+ */
+export interface SpotMarketInfo {
+    symbol: string;
+    baseToken: string;
+    quoteToken: string;
+    markPrice: string;
+    volume24h: string;
+    sizeDecimals: number;
+    priceDecimals: number;
+}
+export interface SpotBalance {
+    token: string;
+    total: string;
+    available: string;
+    held: string;
+}
+export interface SpotAdapter {
+    readonly name: string;
+    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>;
+}
+/**
+ * U-token (Unit protocol) → underlying perp symbol mapping.
+ * These are bridged tokens on HyperEVM with the same price as the underlying (~0.1% deviation).
+ */
+export declare const SPOT_PERP_TOKEN_MAP: Record<string, string>;
+/** Reverse: perp symbol → U-token spot name on HL */
+export declare const PERP_TO_SPOT_MAP: Record<string, string>;
+/** Maximum price deviation (%) between spot and perp to be considered same underlying */
+export declare const MAX_PRICE_DEVIATION_PCT = 5;

package/dist/exchanges/spot-interface.js

@@ -0,0 +1,22 @@
+/**
+ * Spot trading interface for exchanges that support both spot and perp.
+ * Separate from ExchangeAdapter because spot uses balance-based tracking
+ * (not position-based) and has no leverage, liquidation, or funding concepts.
+ *
+ * Supported: Hyperliquid, Lighter (Pacifica is perp-only)
+ */
+// ── Token mapping & price verification ──
+/**
+ * U-token (Unit protocol) → underlying perp symbol mapping.
+ * These are bridged tokens on HyperEVM with the same price as the underlying (~0.1% deviation).
+ */
+export const SPOT_PERP_TOKEN_MAP = {
+    UBTC: "BTC",
+    UETH: "ETH",
+    USOL: "SOL",
+    UFART: "FARTCOIN",
+};
+/** Reverse: perp symbol → U-token spot name on HL */
+export const PERP_TO_SPOT_MAP = Object.fromEntries(Object.entries(SPOT_PERP_TOKEN_MAP).map(([k, v]) => [v, k]));
+/** Maximum price deviation (%) between spot and perp to be considered same underlying */
+export const MAX_PRICE_DEVIATION_PCT = 5;

package/dist/execution-log.d.ts

@@ -1,14 +1,14 @@
 export interface ExecutionRecord {
     id: string;
     timestamp: string;
-    type: "market_order" | "limit_order" | "cancel" | "stop_order" | "edit_order" | "rebalance" | "arb_entry" | "arb_close" | "bridge";
+    type: "market_order" | "limit_order" | "cancel" | "stop_order" | "edit_order" | "rebalance" | "arb_entry" | "arb_close" | "bridge" | "multi_leg" | "multi_leg_rollback";
     exchange: string;
     symbol: string;
     side: string;
     size: string;
     price?: string;
     notional?: number;
-    status: "success" | "failed" | "simulated";
+    status: "success" | "failed" | "simulated" | "unverified";
     error?: string;
     meta?: Record<string, unknown>;
     dryRun: boolean;