perp-cli 0.3.3

package/dist/exchanges/lighter.js

@@ -0,0 +1,793 @@
+import { createRequire } from "node:module";
+// Use createRequire to load the CJS build of lighter-sdk
+// (the ESM build has a broken require polyfill that fails on Node built-ins)
+const require = createRequire(import.meta.url);
+export class LighterAdapter {
+    name = "lighter";
+    _signer;
+    _accountIndex = -1;
+    _address;
+    _marketMap = new Map(); // symbol → marketIndex
+    _marketDecimals = new Map(); // symbol → decimals
+    _evmKey;
+    _apiKey;
+    _accountIndexInit;
+    _baseUrl;
+    _chainId;
+    _testnet;
+    _readOnly;
+    // 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
+     * @param testnet   Use testnet (chain ID 300) instead of mainnet (chain ID 304)
+     * @param opts      Optional: apiKey (40-byte Lighter signing key), accountIndex
+     */
+    constructor(evmKey, testnet = false, opts) {
+        this._evmKey = evmKey;
+        this._apiKey = opts?.apiKey || process.env.LIGHTER_API_KEY || "";
+        this._accountIndexInit = opts?.accountIndex ?? parseInt(process.env.LIGHTER_ACCOUNT_INDEX || "-1");
+        this._address = "";
+        this._testnet = testnet;
+        this._readOnly = !this._apiKey;
+        this._baseUrl = testnet
+            ? (process.env.LIGHTER_TESTNET_URL || "https://testnet.zklighter.elliot.ai")
+            : "https://mainnet.zklighter.elliot.ai";
+        this._chainId = testnet ? 300 : 304;
+    }
+    get signer() {
+        return this._signer;
+    }
+    get accountIndex() {
+        return this._accountIndex;
+    }
+    get address() {
+        return this._address;
+    }
+    get evmKey() {
+        return this._evmKey;
+    }
+    get isReadOnly() {
+        return this._readOnly;
+    }
+    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
+        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) {
+            this._accountIndex = this._accountIndexInit >= 0
+                ? this._accountIndexInit
+                : json.accounts[0].account_index;
+        }
+        // Initialize signer for trading if we have an API key
+        if (this._apiKey) {
+            const { LighterSignerClient } = require("lighter-sdk");
+            this._signer = new LighterSignerClient({
+                url: this._baseUrl,
+                privateKey: this._apiKey,
+                chainId: this._chainId,
+                accountIndex: this._accountIndex,
+                apiKeyIndex: parseInt(process.env.LIGHTER_API_KEY_INDEX || "3"),
+                loaderType: "wasm",
+            });
+            // Only initialize (load WASM + create client), skip checkClient which does HTTP from WASM
+            await this._signer.initialize();
+            this._readOnly = false;
+        }
+        // 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,
+                });
+            }
+        }
+        catch {
+            // Market map will be empty, use fallback
+        }
+    }
+    getMarketIndex(symbol) {
+        const idx = this._marketMap.get(symbol.toUpperCase());
+        if (idx === undefined)
+            throw new Error(`Unknown Lighter market: ${symbol}`);
+        return idx;
+    }
+    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;
+        }
+        catch {
+            return 0;
+        }
+    }
+    toTicks(symbol, size, price) {
+        const dec = this._marketDecimals.get(symbol.toUpperCase()) ?? { size: 0, price: 0 };
+        return {
+            baseAmount: Math.round(size * Math.pow(10, dec.size)),
+            priceTicks: Math.round(price * Math.pow(10, dec.price)),
+        };
+    }
+    async getMarkets() {
+        const markets = [];
+        try {
+            const res = await this.restGet("/orderBookDetails", {});
+            for (const d of res.order_book_details ?? []) {
+                if (d.market_type !== "perp")
+                    continue;
+                // max_leverage from min_initial_margin_fraction (e.g. 400 = 4% margin = 25x)
+                const imf = d.min_initial_margin_fraction ?? d.default_initial_margin_fraction ?? 500;
+                const maxLev = imf > 0 ? Math.floor(10000 / imf) : 50;
+                markets.push({
+                    symbol: d.symbol,
+                    markPrice: String(d.last_trade_price ?? 0),
+                    indexPrice: String(d.last_trade_price ?? 0),
+                    fundingRate: "0", // funding rates require auth
+                    volume24h: String(d.daily_quote_token_volume ?? 0),
+                    openInterest: String(d.open_interest ?? 0),
+                    maxLeverage: maxLev,
+                });
+            }
+        }
+        catch { /* non-critical */ }
+        return markets;
+    }
+    async fetchAccount() {
+        if (!this._address)
+            return null;
+        const { fetchAndCache, TTL_ACCOUNT } = await import("../cache.js");
+        return fetchAndCache(`acct:lt:account:${this._address}`, TTL_ACCOUNT, async () => {
+            const res = await this.restGet("/account", {
+                by: "l1_address",
+                value: this._address,
+            });
+            const acct = this._accountIndex >= 0
+                ? res.accounts?.find(a => a.account_index === this._accountIndex || a.index === this._accountIndex)
+                : res.accounts?.[0];
+            return acct ?? res.accounts?.[0] ?? null;
+        });
+    }
+    async getOrderbook(symbol) {
+        try {
+            const marketId = this.getMarketIndex(symbol);
+            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 getBalance() {
+        const acct = await this.fetchAccount();
+        if (!acct)
+            return { equity: "0", available: "0", marginUsed: "0", unrealizedPnl: "0" };
+        const totalAsset = Number(acct.total_asset_value || 0);
+        const available = Number(acct.available_balance || 0);
+        const collateral = Number(acct.collateral || 0);
+        const unrealizedPnl = acct.positions?.reduce((sum, p) => sum + Number(p.unrealized_pnl || 0), 0) ?? 0;
+        return {
+            equity: String(totalAsset),
+            available: String(available),
+            marginUsed: String(Math.max(0, collateral - available)),
+            unrealizedPnl: String(unrealizedPnl),
+        };
+    }
+    async getPositions() {
+        const acct = await this.fetchAccount();
+        if (!acct)
+            return [];
+        return (acct.positions ?? [])
+            .filter((p) => Number(p.position || 0) !== 0)
+            .map((p) => {
+            const posSize = Number(p.position || 0);
+            return {
+                symbol: String(p.symbol || `Market-${p.market_id}`),
+                side: (Number(p.sign) > 0 ? "long" : "short"),
+                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)
+                    : "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))
+                    : 1,
+            };
+        });
+    }
+    async getAuthToken() {
+        if (this._readOnly)
+            throw new Error("Auth requires API key");
+        const deadline = Math.floor(Date.now() / 1000) + 3600;
+        const auth = await this._signer.createAuthToken(deadline);
+        return auth.authToken;
+    }
+    async restGetAuth(path, params) {
+        const auth = await this.getAuthToken();
+        params.auth = auth;
+        return this.restGet(path, params);
+    }
+    async getOpenOrders() {
+        if (this._accountIndex < 0 || this._readOnly)
+            return [];
+        try {
+            // Check if account has any orders first
+            const acct = await this.fetchAccount();
+            const totalOrders = Number(acct?.total_order_count ?? 0);
+            if (totalOrders === 0)
+                return [];
+            // Query each market in parallel (accountActiveOrders requires auth + market_id)
+            const allOrders = [];
+            const entries = Array.from(this._marketMap.entries());
+            const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/accountActiveOrders", {
+                account_index: String(this._accountIndex),
+                market_id: String(marketId),
+            }).then(res => ({ sym, orders: (res.orders ?? []) }))));
+            for (const r of results) {
+                if (r.status !== "fulfilled" || !r.value.orders.length)
+                    continue;
+                for (const o of r.value.orders) {
+                    allOrders.push({
+                        orderId: String(o.order_id ?? o.order_index ?? ""),
+                        symbol: String(o.symbol ?? r.value.sym),
+                        side: o.is_ask ? "sell" : "buy",
+                        price: String(o.price ?? "0"),
+                        size: String(o.initial_base_amount ?? o.remaining_base_amount ?? "0"),
+                        filled: String(o.filled_base_amount ?? "0"),
+                        status: String(o.status ?? "open"),
+                        type: String(o.type ?? "limit"),
+                    });
+                }
+            }
+            return allOrders;
+        }
+        catch {
+            return [];
+        }
+    }
+    async marketOrder(symbol, side, size) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        const { baseAmount } = this.toTicks(symbol, parseFloat(size), 0);
+        // Market orders need a max slippage price (buy=high, sell=low)
+        const markPrice = await this.getMarkPrice(symbol);
+        const slippagePrice = side === "buy" ? markPrice * 2 : markPrice * 0.5;
+        const { priceTicks: slippageTicks } = this.toTicks(symbol, 0, slippagePrice);
+        const signed = await this.signOrder({
+            marketIndex,
+            clientOrderIndex: 0,
+            baseAmount,
+            price: Math.max(slippageTicks, 1),
+            isAsk: side === "sell" ? 1 : 0,
+            type: 1, // ORDER_TYPE_MARKET
+            timeInForce: 0, // IOC (Immediate or Cancel)
+            reduceOnly: 0,
+            triggerPrice: 0,
+            orderExpiry: 0, // DEFAULT_IOC_EXPIRY
+            nonce,
+        });
+        return this.sendTx(signed);
+    }
+    async limitOrder(symbol, side, price, size, opts) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
+        const signed = await this.signOrder({
+            marketIndex,
+            clientOrderIndex: 0,
+            baseAmount,
+            price: priceTicks,
+            isAsk: side === "sell" ? 1 : 0,
+            type: 0, // ORDER_TYPE_LIMIT
+            timeInForce: 1, // GTT (Good Till Time) — rests on orderbook
+            reduceOnly: opts?.reduceOnly ? 1 : 0,
+            triggerPrice: 0,
+            orderExpiry: -1, // DEFAULT_28_DAY_ORDER_EXPIRY (WASM auto-computes 28 days)
+            nonce,
+        });
+        return this.sendTx(signed);
+    }
+    async cancelOrder(symbol, orderId) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        const signed = await this._signer.signCancelOrder(marketIndex, parseInt(orderId), nonce);
+        return this.sendTx(signed);
+    }
+    async cancelAllOrders(_symbol) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const signed = await this._signer.signCancelAllOrders(0, Math.floor(Date.now() / 1000) + 86400, nonce);
+        return this.sendTx(signed);
+    }
+    async modifyOrder(symbol, orderId, price, size) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        const { baseAmount, priceTicks } = this.toTicks(symbol, parseFloat(size), parseFloat(price));
+        const signed = await this._signer.signModifyOrder({
+            marketIndex,
+            index: parseInt(orderId),
+            baseAmount,
+            price: priceTicks,
+            triggerPrice: 0,
+            nonce,
+        });
+        if (signed.error) {
+            throw new Error(`Signer: ${signed.error}`);
+        }
+        return this.sendTx(signed);
+    }
+    async stopOrder(symbol, side, size, triggerPrice, opts) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        const { baseAmount } = this.toTicks(symbol, parseFloat(size), 0);
+        const { priceTicks: triggerTicks } = this.toTicks(symbol, 0, parseFloat(triggerPrice));
+        // If limitPrice given → stop-limit (type 0, GTT), else stop-market (type 1, IOC)
+        const isMarket = !opts?.limitPrice;
+        let priceTicks;
+        if (isMarket) {
+            const markPrice = await this.getMarkPrice(symbol);
+            const slippagePrice = side === "buy" ? markPrice * 2 : markPrice * 0.5;
+            priceTicks = this.toTicks(symbol, 0, slippagePrice).priceTicks;
+        }
+        else {
+            priceTicks = this.toTicks(symbol, 0, parseFloat(opts.limitPrice)).priceTicks;
+        }
+        const signed = await this.signOrder({
+            marketIndex,
+            clientOrderIndex: 0,
+            baseAmount,
+            price: Math.max(priceTicks, 1),
+            isAsk: side === "sell" ? 1 : 0,
+            type: isMarket ? 1 : 0,
+            timeInForce: isMarket ? 0 : 1, // IOC for market, GTT for limit
+            reduceOnly: opts?.reduceOnly ? 1 : 0,
+            triggerPrice: triggerTicks,
+            orderExpiry: isMarket ? 0 : -1,
+            nonce,
+        });
+        return this.sendTx(signed);
+    }
+    async updateLeverage(symbol, leverage, marginMode = "cross") {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const marketIndex = this.getMarketIndex(symbol);
+        // fraction = initial margin fraction in basis points: 10000/leverage
+        const fraction = Math.round(10000 / leverage);
+        const mode = marginMode === "isolated" ? 1 : 0;
+        const signed = await this._signer.signUpdateLeverage(marketIndex, fraction, mode, nonce);
+        if (signed.error) {
+            throw new Error(`Signer: ${signed.error}`);
+        }
+        return this.sendTx(signed);
+    }
+    async withdraw(amount, assetId = 2, routeType = 0) {
+        this.ensureSigner();
+        const nonce = await this.getNextNonce();
+        const signed = await this._signer.signWithdraw(amount, assetId, routeType, nonce);
+        return this.sendTx(signed);
+    }
+    // ── Interface aliases ──
+    async editOrder(symbol, orderId, price, size) {
+        return this.modifyOrder(symbol, orderId, price, size);
+    }
+    async setLeverage(symbol, leverage, marginMode = "cross") {
+        return this.updateLeverage(symbol, leverage, marginMode);
+    }
+    async getRecentTrades(symbol, limit = 20) {
+        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",
+            price: String(t.price ?? "0"),
+            size: String(t.base_amount ?? t.amount ?? ""),
+            fee: String(t.fee ?? "0"),
+        }));
+    }
+    async getFundingHistory(symbol, limit = 10) {
+        const rates = await this.getFundingRates();
+        const r = rates.get(symbol.toUpperCase());
+        if (!r)
+            return [];
+        // Lighter funding-rates is current only, not historical
+        return [{ time: Date.now(), rate: r.rate, price: r.markPrice }];
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const res = await this.getCandles(symbol, interval, startTime, endTime);
+        const candles = (res.candles ?? []);
+        return candles.map((c) => ({
+            time: Number(c.start_timestamp ?? c.t ?? 0),
+            open: String(c.open ?? c.o ?? "0"),
+            high: String(c.high ?? c.h ?? "0"),
+            low: String(c.low ?? c.l ?? "0"),
+            close: String(c.close ?? c.c ?? "0"),
+            volume: String(c.base_token_volume ?? c.v ?? ""),
+            trades: Number(c.trades_count ?? c.n ?? 0),
+        }));
+    }
+    async getOrderHistory(limit = 30) {
+        const raw = await this._getOrderHistoryRaw();
+        const orders = (raw.orders ?? []);
+        return orders.slice(0, limit).map((o) => ({
+            orderId: String(o.order_index ?? o.order_id ?? ""),
+            symbol: String(o.symbol ?? ""),
+            side: o.is_ask ? "sell" : "buy",
+            price: String(o.price ?? "0"),
+            size: String(o.initial_base_amount ?? o.base_amount ?? ""),
+            filled: String(o.filled_base_amount ?? "0"),
+            status: String(o.status ?? "done"),
+            type: String(o.type ?? "limit"),
+        }));
+    }
+    async getTradeHistory(limit = 30) {
+        const raw = await this._getTradeHistoryRaw(limit);
+        const trades = (raw.trades ?? []);
+        return trades.slice(0, limit).map((t) => ({
+            time: Number(t.timestamp ?? 0) * 1000,
+            symbol: String(t.symbol ?? ""),
+            side: t.is_ask ? "sell" : "buy",
+            price: String(t.price ?? "0"),
+            size: String(t.base_amount ?? t.amount ?? ""),
+            fee: String(t.fee ?? "0"),
+        }));
+    }
+    async getFundingPayments(limit = 30) {
+        const raw = await this._getPositionFundingRaw();
+        const items = (raw.funding ?? []);
+        return items.slice(0, limit).map((f) => ({
+            time: Number(f.timestamp ?? 0) * 1000,
+            symbol: String(f.symbol ?? ""),
+            payment: String(f.amount ?? f.payment ?? "0"),
+        }));
+    }
+    /**
+     * Get funding rates for all markets.
+     * API: GET /api/v1/funding-rates
+     */
+    async getFundingRates() {
+        const map = new Map();
+        try {
+            const res = await this.restGet("/funding-rates", {});
+            const reverseMap = new Map();
+            for (const [sym, idx] of this._marketMap) {
+                reverseMap.set(idx, sym);
+            }
+            for (const fr of res.funding_rates ?? []) {
+                const symbol = fr.symbol || reverseMap.get(fr.market_id);
+                if (symbol) {
+                    map.set(symbol, {
+                        rate: String(fr.rate ?? fr.funding_rate ?? "0"),
+                        markPrice: fr.mark_price ?? "0",
+                    });
+                }
+            }
+        }
+        catch { /* non-critical */ }
+        return map;
+    }
+    /**
+     * Get candle data for a market.
+     */
+    async getCandles(symbol, resolution, startTime, endTime, countBack = 100) {
+        const marketId = this.getMarketIndex(symbol);
+        return this.restGet("/candles", {
+            market_id: String(marketId),
+            resolution,
+            start_timestamp: String(startTime),
+            end_timestamp: String(endTime),
+            count_back: String(countBack),
+        });
+    }
+    /**
+     * Get order history (inactive orders) — raw response.
+     */
+    async _getOrderHistoryRaw() {
+        if (this._accountIndex < 0 || this._readOnly)
+            return { orders: [] };
+        const allOrders = [];
+        const entries = Array.from(this._marketMap.entries());
+        const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/accountInactiveOrders", {
+            account_index: String(this._accountIndex),
+            market_id: String(marketId),
+        }).then((res) => {
+            const orders = (res.orders ?? []);
+            return orders.map((o) => ({ ...o, symbol: o.symbol ?? sym }));
+        })));
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                allOrders.push(...r.value);
+        }
+        return { orders: allOrders };
+    }
+    /**
+     * Get trade history — raw response.
+     */
+    async _getTradeHistoryRaw(limit = 100) {
+        if (this._accountIndex < 0)
+            return { trades: [] };
+        const allTrades = [];
+        const entries = Array.from(this._marketMap.entries());
+        const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/trades", {
+            account_index: String(this._accountIndex),
+            market_id: String(marketId),
+            limit: String(Math.min(limit, 20)),
+        }).then((res) => {
+            const trades = (res.trades ?? []);
+            return trades.map((t) => ({ ...t, symbol: t.symbol ?? sym }));
+        })));
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                allTrades.push(...r.value);
+        }
+        // Sort by timestamp descending
+        allTrades.sort((a, b) => Number(b.timestamp ?? 0) - Number(a.timestamp ?? 0));
+        return { trades: allTrades.slice(0, limit) };
+    }
+    /**
+     * Get position funding history — raw response.
+     */
+    async _getPositionFundingRaw() {
+        if (this._accountIndex < 0)
+            return { funding: [] };
+        const allFunding = [];
+        const entries = Array.from(this._marketMap.entries());
+        const results = await Promise.allSettled(entries.map(([sym, marketId]) => this.restGetAuth("/positionFunding", {
+            account_index: String(this._accountIndex),
+            market_id: String(marketId),
+        }).then((res) => {
+            const items = (res.funding ?? res.data ?? []);
+            return items.map((f) => ({ ...f, symbol: f.symbol ?? sym }));
+        })));
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                allFunding.push(...r.value);
+        }
+        allFunding.sort((a, b) => Number(b.timestamp ?? 0) - Number(a.timestamp ?? 0));
+        return { funding: allFunding };
+    }
+    /**
+     * Get PnL chart data.
+     */
+    async getPnl(period = "1d") {
+        return this.restGet("/pnl", {
+            account_index: String(this._accountIndex),
+            period,
+        });
+    }
+    /**
+     * Get deposit history.
+     */
+    async getDepositHistory() {
+        return this.restGet("/deposit_history", {
+            l1_address: this._address,
+        });
+    }
+    /**
+     * Get withdrawal history.
+     */
+    async getWithdrawHistory() {
+        return this.restGet("/withdraw_history", {
+            account_index: String(this._accountIndex),
+        });
+    }
+    /**
+     * Get transfer history.
+     */
+    async getTransferHistory() {
+        return this.restGet("/transfer_history", {
+            account_index: String(this._accountIndex),
+        });
+    }
+    /**
+     * Get asset details.
+     */
+    async getAssetDetails(assetId) {
+        const params = {};
+        if (assetId !== undefined)
+            params.asset_id = String(assetId);
+        return this.restGet("/assetDetails", params);
+    }
+    /**
+     * Get exchange metrics.
+     */
+    async getExchangeMetrics(symbol) {
+        const params = {};
+        if (symbol)
+            params.symbol = symbol;
+        return this.restGet("/exchangeMetrics", params);
+    }
+    /**
+     * Get account limits.
+     */
+    async getAccountLimits() {
+        return this.restGet("/accountLimits", {
+            account_index: String(this._accountIndex),
+        });
+    }
+    /**
+     * Create CCTP intent address for cross-chain deposit.
+     */
+    async createIntentAddress(chainId) {
+        const res = await fetch(`${this._baseUrl}/api/v1/createIntentAddress`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                chain_id: String(chainId),
+                from_addr: this._address,
+                amount: "0",
+                is_external_deposit: "true",
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`createIntentAddress failed: ${await res.text()}`);
+        return res.json();
+    }
+    /**
+     * Use a referral code.
+     */
+    async useReferralCode(code) {
+        // Referral endpoint requires POST with l1_address, referral_code, and auth (form-urlencoded)
+        const auth = await this.getAuthToken();
+        const res = await fetch(`${this._baseUrl}/api/v1/referral/use`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ l1_address: this._address, referral_code: code, auth }),
+        });
+        const json = await res.json();
+        if (json.code && json.code !== 200)
+            throw new Error(`Referral failed: ${json.message ?? JSON.stringify(json)}`);
+        return json;
+    }
+    /**
+     * Direct REST GET helper.
+     */
+    async getNextNonce() {
+        const apiKeyIndex = parseInt(process.env.LIGHTER_API_KEY_INDEX || "3");
+        const res = await this.restGet("/nextNonce", {
+            account_index: String(this._accountIndex),
+            api_key_index: String(apiKeyIndex),
+        });
+        return res.nonce ?? res.next_nonce ?? 0;
+    }
+    async signOrder(params) {
+        try {
+            const result = await this._signer.signCreateOrder(params);
+            if (result.error) {
+                throw new Error(`Signer: ${result.error}`);
+            }
+            return result;
+        }
+        catch (e) {
+            if (e instanceof Error)
+                throw e;
+            if (typeof e === "object" && e !== null && "error" in e) {
+                throw new Error(`Signer: ${e.error}`);
+            }
+            throw new Error(`Signer: ${JSON.stringify(e)}`);
+        }
+    }
+    async sendTx(signed) {
+        if (signed.error)
+            throw new Error(`Signer error: ${signed.error}`);
+        if (!signed.txInfo)
+            throw new Error("Signer returned empty txInfo");
+        const res = await fetch(`${this._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 url = new URL(`${this._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();
+    }
+    ensureSigner() {
+        if (this._readOnly) {
+            throw new Error("This command requires a Lighter API key. Run `perp -e lighter manage setup-api-key` first, " +
+                "then set LIGHTER_API_KEY in your .env");
+        }
+    }
+    static async getWasmOps() {
+        const { WasmLoader } = require("lighter-sdk");
+        const loader = WasmLoader.getInstance();
+        await loader.load({});
+        return loader.getOperations();
+    }
+    /**
+     * Generate a new Lighter API key pair using the WASM signer.
+     * Returns { privateKey, publicKey } (both 0x-prefixed, 40 bytes).
+     */
+    static async generateApiKey(seed) {
+        const ops = await LighterAdapter.getWasmOps();
+        const result = ops
+            .GenerateAPIKey(seed ?? `pacifica-cli-${Date.now()}-${Math.random()}`);
+        if (result.err)
+            throw new Error(`GenerateAPIKey failed: ${result.err}`);
+        return { privateKey: result.privateKey, publicKey: result.publicKey };
+    }
+    /**
+     * Generate an API key and register it on-chain via ChangePubKey.
+     * Uses WASM signer to sign + ETH key for L1 signature.
+     * Returns the generated key pair.
+     */
+    async setupApiKey(apiKeyIndex = 2) {
+        const { ethers } = await import("ethers");
+        // 1. Generate key pair
+        const { privateKey, publicKey } = await LighterAdapter.generateApiKey();
+        // 2. Get nonce from API
+        const nonceRes = await this.restGet("/nextNonce", {
+            account_index: String(this._accountIndex),
+            api_key_index: String(apiKeyIndex),
+        });
+        const nonce = nonceRes.next_nonce ?? 0;
+        // 3. Create signer client with new key and sign ChangePubKey
+        const ops = await LighterAdapter.getWasmOps();
+        const opsAny = ops;
+        // CreateClient with the new API key
+        opsAny.CreateClient(this._baseUrl, privateKey, this._chainId, apiKeyIndex, this._accountIndex);
+        // Sign ChangePubKey
+        const signed = await opsAny.SignChangePubKey(publicKey, nonce, apiKeyIndex, this._accountIndex);
+        if (signed.error)
+            throw new Error(`SignChangePubKey failed: ${signed.error}`);
+        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);
+        // 5. Add L1Sig to txInfo
+        const txInfo = JSON.parse(signed.txInfo);
+        txInfo.L1Sig = l1Sig;
+        // 6. Submit to Lighter API
+        const sendRes = await fetch(`${this._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: JSON.stringify(txInfo),
+            }),
+        });
+        if (!sendRes.ok) {
+            const errText = await sendRes.text();
+            throw new Error(`ChangePubKey sendTx failed (${sendRes.status}): ${errText}`);
+        }
+        const result = await sendRes.json();
+        if (result.code !== 200) {
+            throw new Error(`ChangePubKey failed: ${result.message ?? JSON.stringify(result)}`);
+        }
+        return { privateKey, publicKey };
+    }
+}