perp-cli 0.5.0 → 0.5.3

package/dist/exchanges/hyperliquid-spot.js

@@ -26,6 +26,7 @@ export class HyperliquidSpotAdapter {
     _spotAssetMap = new Map(); // "ETH" → spotIndex (not +10000)
     _spotAssetReverse = new Map(); // spotIndex → "ETH"
     _spotDecimals = new Map();
+    _spotCanonical = new Map(); // "PURR" → true, "UBTC" → false
     _initialized = false;
     _cachedMetaCtx = null;
     constructor(hlAdapter) {
@@ -46,27 +47,36 @@ export class HyperliquidSpotAdapter {
                 return;
             this._cachedMetaCtx = metaCtx;
             const meta = metaCtx[0];
-            // Token index → name map
+            // Token index → name + szDecimals map (szDecimals lives on tokens, not universe)
             const tokenNames = new Map();
+            const tokenSzDecimals = new Map();
             for (const t of meta.tokens ?? []) {
                 tokenNames.set(t.index, t.name);
+                if (t.szDecimals !== undefined)
+                    tokenSzDecimals.set(t.index, t.szDecimals);
             }
             // Find USDC token index for filtering
             const usdcTokenIndex = meta.tokens?.find(t => t.name === "USDC")?.index ?? 0;
+            // HIP-1 meme tokens with low liquidity / unreliable orderbooks — skip for spot trading
+            const SPOT_EXCLUDE = new Set(["TRUMP", "PEPE", "HFUN"]);
             for (const u of meta.universe) {
-                const baseToken = tokenNames.get(u.tokens[0]) ?? "";
+                const baseTokenIndex = u.tokens[0];
+                const baseToken = tokenNames.get(baseTokenIndex) ?? "";
                 if (!baseToken)
                     continue;
                 const key = baseToken.toUpperCase();
+                if (SPOT_EXCLUDE.has(key))
+                    continue;
                 const isUsdcPair = u.tokens[1] === usdcTokenIndex;
                 if (this._spotAssetMap.has(key) && !isUsdcPair)
                     continue;
                 this._spotAssetMap.set(key, u.index);
                 this._spotAssetReverse.set(u.index, key);
                 this._spotDecimals.set(key, {
-                    size: u.szDecimals ?? 2,
+                    size: tokenSzDecimals.get(baseTokenIndex) ?? 2,
                     price: 6,
                 });
+                this._spotCanonical.set(key, u.isCanonical === true);
             }
         }
         catch (e) {
@@ -82,8 +92,11 @@ export class HyperliquidSpotAdapter {
             if (!metaCtx?.[0]?.universe)
                 return [];
             const tokenNames = new Map();
+            const tokenSzDec = new Map();
             for (const t of metaCtx[0].tokens ?? []) {
                 tokenNames.set(t.index, t.name);
+                if (t.szDecimals !== undefined)
+                    tokenSzDec.set(t.index, t.szDecimals);
             }
             const ctxs = metaCtx[1] ?? [];
             const markets = [];
@@ -100,7 +113,7 @@ export class HyperliquidSpotAdapter {
                     quoteToken,
                     markPrice: String(ctx.markPx ?? ctx.midPx ?? "0"),
                     volume24h: String(ctx.dayNtlVlm ?? "0"),
-                    sizeDecimals: u.szDecimals ?? 2,
+                    sizeDecimals: tokenSzDec.get(u.tokens[0]) ?? 2,
                     priceDecimals: 6,
                 });
             }
@@ -112,12 +125,13 @@ export class HyperliquidSpotAdapter {
     }
     async getSpotOrderbook(symbol) {
         await this.init();
-        const { spotIndex } = this._resolveBase(symbol);
-        // HL spot L2 book uses the universe name, which is like "ETH/USDC" internally
-        // But the API takes coin=<name>, where name is from spotMeta universe
+        const { base, spotIndex } = this._resolveBase(symbol);
+        // Canonical tokens (e.g. PURR) use "BASE/USDC", non-canonical (e.g. UBTC) use "@index"
+        const isCanonical = this._spotCanonical.get(base) ?? false;
+        const coin = isCanonical ? `${base}/USDC` : `@${spotIndex}`;
         const book = await this._infoPost({
             type: "l2Book",
-            coin: `@${spotIndex}`,
+            coin,
         });
         const levels = book?.levels ?? [[], []];
         return {
@@ -133,8 +147,9 @@ export class HyperliquidSpotAdapter {
     }
     async getSpotBalances() {
         try {
-            const state = await this._hl.client.info.spot.getSpotClearinghouseState(this._hl.address);
-            const balances = state?.balances ?? [];
+            // Reuse cached spot clearinghouse state (shared with getBalance() — saves 1 API call)
+            const state = await this._hl._getSpotClearinghouseState();
+            const balances = (state?.balances ?? []);
             return balances.map((b) => ({
                 token: String(b.coin ?? ""),
                 total: String(b.total ?? "0"),

package/dist/exchanges/hyperliquid.d.ts

@@ -43,6 +43,8 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     private ensureAddress;
     /** Always fetches live clearinghouseState, writes result to shared cache for dashboard */
     private _getClearinghouseState;
+    /** Cached spot clearinghouse state — shared between getBalance() and HyperliquidSpotAdapter */
+    _getSpotClearinghouseState(): Promise<Record<string, unknown>>;
     getBalance(): Promise<ExchangeBalance>;
     getPositions(): Promise<ExchangePosition[]>;
     getOpenOrders(): Promise<ExchangeOrder[]>;
@@ -59,6 +61,15 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
      * Bypasses the SDK entirely — works for order, batchModify, twapOrder, etc.
      */
     private ensureSigner;
+    /**
+     * Normalize trailing zeros from price ('p') and size ('s') string fields
+     * in an action object, recursively. Matches the SDK's normalizeTrailingZeros.
+     *
+     * The HL validator normalizes these fields before hashing; if we hash without
+     * normalizing, the recovered signer address won't match → "User or API Wallet
+     * does not exist" error.
+     */
+    private static _normalizeAction;
     private _signAndSendAction;
     /**
      * Place an order via raw exchange API with EIP-712 signing.

package/dist/exchanges/hyperliquid.js

@@ -258,6 +258,14 @@ export class HyperliquidAdapter {
             return state;
         });
     }
+    /** Cached spot clearinghouse state — shared between getBalance() and HyperliquidSpotAdapter */
+    async _getSpotClearinghouseState() {
+        this.ensureAddress();
+        const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+        return withCache(`acct:hl:spot_chs:${this._address}`, TTL_ACCOUNT, async () => {
+            return await this.sdk.info.spot.getSpotClearinghouseState(this._address);
+        });
+    }
     async getBalance() {
         const state = await this._getClearinghouseState();
         const s = state;
@@ -277,8 +285,8 @@ export class HyperliquidAdapter {
             // Unified account: spot USDC total IS the true equity (includes perp margin as "hold").
             // perp accountValue is a subset — adding both double-counts.
             try {
-                const spotState = await this.sdk.info.spot.getSpotClearinghouseState(this._address);
-                const balances = spotState?.balances ?? [];
+                const spotState = await this._getSpotClearinghouseState();
+                const balances = (spotState?.balances ?? []);
                 const usdc = balances.find((b) => String(b.coin).startsWith("USDC"));
                 const spotTotal = usdc?.total !== undefined ? Number(usdc.total) : NaN;
                 const spotHold = Number(usdc?.hold ?? 0);
@@ -430,6 +438,40 @@ export class HyperliquidAdapter {
             throw new Error("No private key configured. Run: perp init");
         }
     }
+    /**
+     * Normalize trailing zeros from price ('p') and size ('s') string fields
+     * in an action object, recursively. Matches the SDK's normalizeTrailingZeros.
+     *
+     * The HL validator normalizes these fields before hashing; if we hash without
+     * normalizing, the recovered signer address won't match → "User or API Wallet
+     * does not exist" error.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _normalizeAction(obj) {
+        if (!obj || typeof obj !== "object")
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map(item => HyperliquidAdapter._normalizeAction(item));
+        }
+        const result = { ...obj };
+        for (const key in result) {
+            if (!Object.prototype.hasOwnProperty.call(result, key))
+                continue;
+            const value = result[key];
+            if (value && typeof value === "object") {
+                result[key] = HyperliquidAdapter._normalizeAction(value);
+            }
+            else if ((key === "p" || key === "s") && typeof value === "string") {
+                let v = value;
+                if (v.includes("."))
+                    v = v.replace(/\.?0+$/, "");
+                if (v === "-0")
+                    v = "0";
+                result[key] = v;
+            }
+        }
+        return result;
+    }
     async _signAndSendAction(action) {
         this.ensureSigner();
         const { encode } = await import("@msgpack/msgpack");
@@ -438,9 +480,13 @@ export class HyperliquidAdapter {
         const baseUrl = isMainnet
             ? "https://api.hyperliquid.xyz"
             : "https://api.hyperliquid-testnet.xyz";
+        // Normalize trailing zeros from 'p' and 's' fields before hashing.
+        // The HL validator does the same; without this, the hash differs and the
+        // recovered signer address is wrong → "User or API Wallet does not exist".
+        const normalizedAction = HyperliquidAdapter._normalizeAction(action);
         // Sign L1 action (replicates SDK's signL1Action)
         const nonce = Date.now();
-        const msgPackBytes = encode(action);
+        const msgPackBytes = encode(normalizedAction);
         const data = new Uint8Array(msgPackBytes.length + 9); // +8 nonce +1 vault flag
         data.set(msgPackBytes);
         const view = new DataView(data.buffer);
@@ -707,8 +753,8 @@ export class HyperliquidAdapter {
             r: opts?.reduceOnly ?? true,
             t: {
                 trigger: {
-                    triggerPx: trimZeros(roundedTrigger),
                     isMarket: opts?.isMarket ?? true,
+                    triggerPx: trimZeros(roundedTrigger),
                     tpsl,
                 },
             },

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

@@ -15,7 +15,9 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     private _spotBaseMap;
     private _spotDecimals;
     private _spotMinSize;
+    private _spotPrices;
     private _initialized;
+    private _clientOrderCounter;
     constructor(ltAdapter: LighterAdapter);
     init(): Promise<void>;
     private _loadSpotMarkets;
@@ -32,6 +34,8 @@ export declare class LighterSpotAdapter implements SpotAdapter {
         tif?: string;
     }): Promise<unknown>;
     spotCancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    /** Cancel all orders across all markets (spot + perp) */
+    spotCancelAllOrders(_symbol?: 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 */
@@ -48,6 +52,8 @@ export declare class LighterSpotAdapter implements SpotAdapter {
     /** Check if a base token has a spot market */
     hasSpotMarket(base: string): boolean;
     private _placeOrder;
+    /** Generate a unique client order index (uint48). Uses timestamp + counter. */
+    private _nextClientOrderIndex;
     private _getNextNonce;
     private _sendTx;
     private _restGet;

package/dist/exchanges/lighter-spot.js

@@ -13,7 +13,9 @@ export class LighterSpotAdapter {
     _spotBaseMap = new Map(); // "ETH" → "ETH/USDC"
     _spotDecimals = new Map();
     _spotMinSize = new Map(); // min order sizes
+    _spotPrices = new Map(); // "ETH/USDC" → markPrice (from init)
     _initialized = false;
+    _clientOrderCounter = 0;
     constructor(ltAdapter) {
         this._lt = ltAdapter;
     }
@@ -40,6 +42,11 @@ export class LighterSpotAdapter {
                     base: parseFloat(ob.min_base_amount || "0"),
                     quote: parseFloat(ob.min_quote_amount || "0"),
                 });
+                // Cache price from orderBooks response (avoids N separate orderbook calls in getSpotMarkets)
+                const price = ob.mark_price ?? (ob.best_ask_price && ob.best_bid_price
+                    ? String((parseFloat(ob.best_ask_price) + parseFloat(ob.best_bid_price)) / 2) : "0");
+                if (price !== "0")
+                    this._spotPrices.set(symbol, price);
                 const base = symbol.split("/")[0];
                 if (base)
                     this._spotBaseMap.set(base, symbol);
@@ -84,22 +91,25 @@ export class LighterSpotAdapter {
     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) => {
+        // Use prices cached from init's /orderBooks response (0 extra API calls).
+        // Only fetch individual orderbooks if no cached price available.
+        const missingPrices = entries.filter(([sym]) => !this._spotPrices.has(sym));
+        if (missingPrices.length > 0) {
+            const results = await Promise.allSettled(missingPrices.map(([symbol]) => this.getSpotOrderbook(symbol).then(ob => {
+                if (ob.bids.length > 0 && ob.asks.length > 0) {
+                    this._spotPrices.set(symbol, String((Number(ob.bids[0][0]) + Number(ob.asks[0][0])) / 2));
+                }
+            })));
+            void results; // consume
+        }
+        return entries.map(([symbol]) => {
             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",
+                markPrice: this._spotPrices.get(symbol) ?? "0", volume24h: "0",
                 sizeDecimals: dec.size, priceDecimals: dec.price,
             };
         });
@@ -128,32 +138,36 @@ export class LighterSpotAdapter {
     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,
+            // Reuse cached account data (shared with LighterAdapter.fetchAccount() — saves 1 API call)
+            const { withCache, TTL_ACCOUNT } = await import("../cache.js");
+            const acct = await withCache(`acct:lt:account:${address}`, TTL_ACCOUNT, async () => {
+                const res = await this._restGet("/account", {
+                    by: "l1_address",
+                    value: address,
+                });
+                const found = res.accounts?.find(a => a.account_index === this._lt.accountIndex)
+                    ?? res.accounts?.[0];
+                return found ?? null;
             });
-            const acct = res.accounts?.find(a => a.account_index === this._lt.accountIndex)
-                ?? res.accounts?.[0];
             if (!acct)
                 return [];
+            const balances = [];
             // Spot token balances from the assets array only.
             // Perp USDC (collateral) is already reported by getBalance() — don't duplicate here.
-            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 (bal > 0) {
-                        balances.push({
-                            token: asset.symbol === "USDC" ? "USDC_SPOT" : asset.symbol,
-                            total: asset.balance,
-                            available: String(bal - locked),
-                            held: asset.locked_balance,
-                        });
-                    }
+            const assets = (acct.assets ?? []);
+            for (const asset of assets) {
+                const bal = parseFloat(asset.balance || "0");
+                const locked = parseFloat(asset.locked_balance || "0");
+                if (bal > 0) {
+                    balances.push({
+                        token: asset.symbol === "USDC" ? "USDC_SPOT" : asset.symbol,
+                        total: asset.balance,
+                        available: String(bal - locked),
+                        held: asset.locked_balance,
+                    });
                 }
             }
             return balances;
@@ -244,18 +258,42 @@ export class LighterSpotAdapter {
         if (marketId === undefined) {
             throw new Error(`Unknown Lighter spot market: ${symbol}`);
         }
-        // Access signer through the adapter
+        // Lighter order IDs can exceed Number.MAX_SAFE_INTEGER (2^53-1).
+        // The WASM signer only accepts JS number, so large IDs lose precision
+        // and the cancel silently targets the wrong order.
+        // Fall back to cancelAll for the market when the ID is unsafe.
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            return this.spotCancelAllOrders(symbol);
+        }
         const signer = this._lt.signer;
         const nonce = await this._getNextNonce();
         const signed = await signer.signCancelOrder({
             marketIndex: marketId,
-            orderIndex: parseInt(orderId),
+            orderIndex: idNum,
             nonce,
             apiKeyIndex: this._lt._apiKeyIndex,
             accountIndex: this._lt.accountIndex,
         });
         return this._sendTx(signed);
     }
+    /** Cancel all orders across all markets (spot + perp) */
+    async spotCancelAllOrders(_symbol) {
+        if (this._lt.isReadOnly)
+            throw new Error("Cancel requires API key");
+        const signer = this._lt.signer;
+        const nonce = await this._getNextNonce();
+        const apiKeyIndex = this._lt._apiKeyIndex;
+        // time must be in milliseconds, in the future
+        const signed = await signer.signCancelAllOrders({
+            timeInForce: 1,
+            time: Date.now() + 3600_000,
+            nonce,
+            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)
@@ -333,9 +371,13 @@ export class LighterSpotAdapter {
         const nonce = await this._getNextNonce();
         const signer = this._lt.signer;
         const apiKeyIndex = this._lt._apiKeyIndex;
+        // Use a unique clientOrderIndex (uint48, max 2^48-1 ≈ 281 trillion).
+        // This value is used for cancel operations instead of the exchange-assigned
+        // order_id which can exceed Number.MAX_SAFE_INTEGER.
+        const clientOrderIndex = this._nextClientOrderIndex();
         const signed = await signer.signCreateOrder({
             marketIndex: opts.marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex,
             baseAmount: opts.baseAmount,
             price: opts.price,
             isAsk: opts.isAsk,
@@ -353,6 +395,13 @@ export class LighterSpotAdapter {
         }
         return this._sendTx(signed);
     }
+    /** Generate a unique client order index (uint48). Uses timestamp + counter. */
+    _nextClientOrderIndex() {
+        // Timestamp in seconds gives ~10 digits. Add counter for uniqueness within same second.
+        // uint48 max = 281_474_976_710_655. Date.now()/1000 ≈ 1.7 trillion (fits).
+        const base = Math.floor(Date.now() / 1000) % 281_474_976_710_000;
+        return base + (this._clientOrderCounter++ % 655);
+    }
     async _getNextNonce() {
         const apiKeyIndex = this._lt._apiKeyIndex;
         const res = await this._restGet("/nextNonce", {

package/dist/exchanges/lighter.d.ts

@@ -9,6 +9,7 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private _address;
     private _marketMap;
     private _marketDecimals;
+    private _clientOrderCounter;
     private _evmKey;
     private _apiKey;
     private _accountIndexInit;
@@ -149,6 +150,8 @@ export declare class LighterAdapter implements ExchangeAdapter {
     private signOrder;
     private sendTx;
     private restGet;
+    /** Generate a unique client order index (uint48). */
+    private nextClientOrderIndex;
     private ensureSigner;
     private static _wasmClient;
     private static getWasmClient;

package/dist/exchanges/lighter.js

@@ -7,6 +7,7 @@ export class LighterAdapter {
     _address;
     _marketMap = new Map(); // symbol → marketIndex
     _marketDecimals = new Map(); // symbol → decimals
+    _clientOrderCounter = 0;
     _evmKey;
     _apiKey;
     _accountIndexInit;
@@ -73,26 +74,30 @@ export class LighterAdapter {
             await this._refreshMarketMap();
             return;
         }
-        // Retry account lookup on 429 (rate limit) — critical for _accountIndex
-        for (let attempt = 0; attempt < 3; attempt++) {
-            try {
-                const res = await fetch(`${this._baseUrl}/api/v1/account?by=l1_address&value=${this._address}`);
-                if (res.status === 429 && attempt < 2) {
-                    await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
-                    continue;
-                }
-                const json = await res.json();
-                if (json.accounts && json.accounts.length > 0) {
-                    this._accountIndex = this._accountIndexInit >= 0
-                        ? this._accountIndexInit
-                        : json.accounts[0].account_index;
+        // If accountIndex is already known (from env/opts), skip API lookup entirely
+        if (this._accountIndexInit >= 0) {
+            this._accountIndex = this._accountIndexInit;
+        }
+        else {
+            // Retry account lookup on 429 (rate limit) — critical for _accountIndex
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const res = await fetch(`${this._baseUrl}/api/v1/account?by=l1_address&value=${this._address}`);
+                    if (res.status === 429 && attempt < 2) {
+                        await new Promise(r => setTimeout(r, 2000 * (attempt + 1)));
+                        continue;
+                    }
+                    const json = await res.json();
+                    if (json.accounts && json.accounts.length > 0) {
+                        this._accountIndex = json.accounts[0].account_index;
+                    }
+                    break;
                 }
-                break;
-            }
-            catch {
-                if (attempt < 2) {
-                    await new Promise(r => setTimeout(r, 1000));
-                    continue;
+                catch {
+                    if (attempt < 2) {
+                        await new Promise(r => setTimeout(r, 2000));
+                        continue;
+                    }
                 }
             }
         }
@@ -434,7 +439,7 @@ export class LighterAdapter {
         const { priceTicks: slippageTicks } = this.toTicks(symbol, 0, slippagePrice);
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: Math.max(slippageTicks, 1),
             isAsk: side === "sell" ? 1 : 0,
@@ -457,7 +462,7 @@ export class LighterAdapter {
         const isIoc = opts?.tif?.toUpperCase() === "IOC";
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: priceTicks,
             isAsk: side === "sell" ? 1 : 0,
@@ -473,10 +478,17 @@ export class LighterAdapter {
     async cancelOrder(symbol, orderId) {
         this.ensureSigner();
         await this.ensureMarketMap();
+        // Lighter order IDs can exceed Number.MAX_SAFE_INTEGER (2^53-1).
+        // The WASM signer only accepts JS number, so large IDs lose precision.
+        // Fall back to cancelAllOrders when the ID is unsafe.
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            return this.cancelAllOrders(symbol);
+        }
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const signed = await this._signer.signCancelOrder({
-            marketIndex, orderIndex: parseInt(orderId), nonce,
+            marketIndex, orderIndex: idNum, nonce,
             apiKeyIndex: this._apiKeyIndex, accountIndex: this._accountIndex,
         });
         return this.sendTx(signed);
@@ -495,7 +507,7 @@ export class LighterAdapter {
         }
         const nonce = await this.getNextNonce();
         const signed = await this._signer.signCancelAllOrders({
-            timeInForce: 0, time: Math.floor(Date.now() / 1000) + 86400, nonce,
+            timeInForce: 1, time: Date.now() + 3600_000, nonce,
             apiKeyIndex: this._apiKeyIndex, accountIndex: this._accountIndex,
         });
         return this.sendTx(signed);
@@ -506,9 +518,13 @@ export class LighterAdapter {
         const nonce = await this.getNextNonce();
         const marketIndex = this.getMarketIndex(symbol);
         const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
+        const idNum = Number(orderId);
+        if (!Number.isSafeInteger(idNum)) {
+            throw new Error(`Order ID ${orderId} exceeds MAX_SAFE_INTEGER — cancel and re-place instead`);
+        }
         const signed = await this._signer.signModifyOrder({
             marketIndex,
-            index: parseInt(orderId),
+            index: idNum,
             baseAmount,
             price: priceTicks,
             triggerPrice: 0,
@@ -541,7 +557,7 @@ export class LighterAdapter {
         }
         const signed = await this.signOrder({
             marketIndex,
-            clientOrderIndex: 0,
+            clientOrderIndex: this.nextClientOrderIndex(),
             baseAmount,
             price: Math.max(priceTicks, 1),
             isAsk: side === "sell" ? 1 : 0,
@@ -598,7 +614,7 @@ export class LighterAdapter {
             // /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 ?? ""),
+            size: String(t.size ?? t.base_amount ?? t.amount ?? ""),
             fee: String(t.fee ?? "0"),
         }));
     }
@@ -946,6 +962,11 @@ export class LighterAdapter {
             throw new Error(`GET ${path} failed (${res.status}): ${await res.text()}`);
         return res.json();
     }
+    /** Generate a unique client order index (uint48). */
+    nextClientOrderIndex() {
+        const base = Math.floor(Date.now() / 1000) % 281_474_976_710_000;
+        return base + (this._clientOrderCounter++ % 655);
+    }
     ensureSigner() {
         if (this._readOnly || this._accountIndex < 0 || !this._signer) {
             throw new Error("This command requires a Lighter API key. Run `perp -e lighter manage setup-api-key` first, " +

package/dist/exchanges/pacifica.js

@@ -79,13 +79,26 @@ export class PacificaAdapter {
     async getBalance() {
         if (!this._hasRealKey)
             throw new Error("No private key configured — account data unavailable. Run: perp init");
-        const [info, positions] = await Promise.all([
+        const [info, positions, prices] = await Promise.all([
             this.client.getAccount(this.account),
             this._getPositions(),
+            this._getPrices(),
         ]);
         const raw = info;
-        // Use API-provided unrealized PnL from positions
-        const totalPnl = positions.reduce((sum, p) => sum + Number(p.unrealized_pnl ?? 0), 0);
+        const priceMap = new Map(prices.map((p) => [p.symbol, p]));
+        // API often returns unrealized_pnl=0 — compute from price delta when needed
+        let totalPnl = 0;
+        for (const p of positions) {
+            let upnl = Number(p.unrealized_pnl ?? 0);
+            if (upnl === 0 && Number(p.amount) > 0) {
+                const mark = Number(priceMap.get(p.symbol)?.mark ?? p.mark_price ?? 0);
+                const entry = Number(p.entry_price);
+                const dir = p.side === "bid" ? 1 : -1;
+                if (mark > 0 && entry > 0)
+                    upnl = (mark - entry) * Number(p.amount) * dir;
+            }
+            totalPnl += upnl;
+        }
         return {
             equity: info.account_equity,
             available: info.available_to_spend,
@@ -114,6 +127,15 @@ export class PacificaAdapter {
         return positions.map((p) => {
             const mark = priceMap.get(p.symbol)?.mark ?? p.mark_price ?? "0";
             const side = p.side === "bid" ? "long" : "short";
+            const size = Number(p.amount);
+            const entry = Number(p.entry_price);
+            const markNum = Number(mark);
+            // API often returns unrealized_pnl=0 — compute from price delta when needed
+            let upnl = Number(p.unrealized_pnl ?? 0);
+            if (upnl === 0 && size > 0 && entry > 0 && markNum > 0) {
+                const dir = side === "long" ? 1 : -1;
+                upnl = (markNum - entry) * size * dir;
+            }
             return {
                 symbol: p.symbol,
                 side: side,
@@ -121,7 +143,7 @@ export class PacificaAdapter {
                 entryPrice: String(p.entry_price),
                 markPrice: mark,
                 liquidationPrice: String(p.liquidation_price ?? "N/A"),
-                unrealizedPnl: String(p.unrealized_pnl ?? "0"),
+                unrealizedPnl: upnl.toFixed(4),
                 leverage: p.leverage ?? levMap.get(String(p.symbol)) ?? 1,
             };
         });