perp-cli 0.14.0 → 0.14.1

package/dist/commands/wallet.js

@@ -1,4 +1,5 @@
 import { Option } from "commander";
+import { evmOnchainBalances, solanaOnchainBalances, stableTotal } from "../onchain-balances.js";
 import { PerpError } from "../errors.js";
 import chalk from "chalk";
 import bs58 from "bs58";
@@ -98,80 +99,60 @@ export function getWalletKeyByName(name) {
     const store = loadStore();
     return store.wallets[name]?.privateKey ?? null;
 }
+/** SOL + USDC / USDT on Solana (devnet: USDP). */
 async function getSolanaBalances(address, isTestnet) {
-    const { Connection, PublicKey } = await import("@solana/web3.js");
-    const rpcUrl = isTestnet
-        ? "https://api.devnet.solana.com"
-        : "https://api.mainnet-beta.solana.com";
-    const connection = new Connection(rpcUrl);
-    const pubkey = new PublicKey(address);
-    const balances = [];
-    const solLamports = await connection.getBalance(pubkey);
-    const solBalance = solLamports / 1e9;
-    balances.push({ token: "SOL", balance: solBalance.toFixed(6), usdValue: "" });
-    const usdcMint = isTestnet
-        ? "USDPqRbLidFGufty2s3oizmDEKdqx7ePTqzDMbf5ZKM"
-        : "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-    try {
-        const tokenAccounts = await connection.getParsedTokenAccountsByOwner(pubkey, {
-            mint: new PublicKey(usdcMint),
-        });
-        let usdcBalance = 0;
-        for (const { account } of tokenAccounts.value) {
-            const parsed = account.data.parsed?.info;
-            if (parsed)
-                usdcBalance += Number(parsed.tokenAmount?.uiAmount ?? 0);
+    return solanaOnchainBalances(address, isTestnet);
+}
+/** Gas token + USDC / USDT (USDG on Robinhood Chain) on every EVM chain perp-cli uses; `only` limits the chains. */
+async function getEvmBalances(address, isTestnet, only) {
+    return evmOnchainBalances(address, isTestnet, only);
+}
+/** Human table: non-zero balances and failed reads (JSON keeps every row), then the stablecoin total. */
+function balanceTable(balances) {
+    const shown = balances.filter(b => b.error !== null || Number(b.balance) !== 0);
+    const rows = shown.map((b) => [
+        b.chain,
+        chalk.white.bold(b.token),
+        b.balance === null ? chalk.red("read failed") : b.balance,
+        b.usdValue === null ? chalk.gray("-") : `$${formatUsd(b.usdValue)}`,
+    ]);
+    const total = stableTotal(balances);
+    rows.push([chalk.gray("total"), chalk.white.bold("stablecoins"), "", `$${formatUsd(total.usd)}${total.errors.length > 0 ? chalk.red(" (some reads failed)") : ""}`]);
+    return makeTable(["Chain", "Token", "Balance", "USD Value"], rows);
+}
+async function balanceEntry(label, vm, address, testnet) {
+    const balances = vm === "solana" ? await getSolanaBalances(address, testnet) : await getEvmBalances(address, testnet);
+    const total = stableTotal(balances);
+    return { ...label, chain: vm, address, balances, stableUsd: total.usd, errors: total.errors };
+}
+/** Reads each distinct address once (several venues often share one key), in order. */
+async function balanceEntries(items, testnet) {
+    const seen = new Map();
+    const out = [];
+    for (const it of items) {
+        const key = `${it.vm}:${it.address.toLowerCase()}`;
+        const prev = seen.get(key);
+        if (prev !== undefined) {
+            if (it.label.exchange !== undefined)
+                prev.exchange = prev.exchange === undefined ? it.label.exchange : `${prev.exchange},${it.label.exchange}`;
+            continue;
         }
-        balances.push({
-            token: isTestnet ? "USDP" : "USDC",
-            balance: usdcBalance.toFixed(2),
-            usdValue: `$${formatUsd(usdcBalance)}`,
-        });
-    }
-    catch {
-        balances.push({ token: isTestnet ? "USDP" : "USDC", balance: "0.00", usdValue: "$0.00" });
-    }
-    try {
-        const res = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd");
-        const json = (await res.json());
-        balances[0].usdValue = `$${formatUsd(solBalance * (json.solana?.usd ?? 0))}`;
+        const entry = await balanceEntry(it.label, it.vm, it.address, testnet);
+        seen.set(key, entry);
+        out.push(entry);
     }
-    catch {
-        balances[0].usdValue = "-";
-    }
-    return balances;
+    return out;
 }
-async function getEvmBalances(address, isTestnet) {
-    const { ethers } = await import("ethers");
-    const rpcUrl = isTestnet
-        ? "https://sepolia-rollup.arbitrum.io/rpc"
-        : "https://arb1.arbitrum.io/rpc";
-    const provider = new ethers.JsonRpcProvider(rpcUrl);
-    const balances = [];
-    const ethBal = await provider.getBalance(address);
-    const ethBalance = Number(ethers.formatEther(ethBal));
-    balances.push({ token: "ETH", balance: ethBalance.toFixed(6), usdValue: "" });
-    const usdcAddr = isTestnet
-        ? "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d"
-        : "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
-    try {
-        const usdc = new ethers.Contract(usdcAddr, ["function balanceOf(address) view returns (uint256)"], provider);
-        const rawBal = await usdc.balanceOf(address);
-        const usdcBalance = Number(ethers.formatUnits(rawBal, 6));
-        balances.push({ token: "USDC", balance: usdcBalance.toFixed(2), usdValue: `$${formatUsd(usdcBalance)}` });
-    }
-    catch {
-        balances.push({ token: "USDC", balance: "0.00", usdValue: "$0.00" });
-    }
-    try {
-        const res = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd");
-        const json = (await res.json());
-        balances[0].usdValue = `$${formatUsd(ethBalance * (json.ethereum?.usd ?? 0))}`;
-    }
-    catch {
-        balances[0].usdValue = "-";
+/** Exactly one JSON document (an array of entries), or one table per entry. */
+function printBalanceEntries(entries, json) {
+    if (json)
+        return printJson(jsonOk(entries));
+    for (const e of entries) {
+        const who = [e.wallet, e.exchange].filter(x => x !== undefined).join(" / ");
+        console.log(chalk.cyan.bold(`\n  ${who} (${e.chain} ${e.address.slice(0, 8)}...)`));
+        console.log(balanceTable(e.balances));
     }
-    return balances;
+    console.log();
 }
 // ── Derive address from private key ──────────────────────────
 async function deriveSolanaAddress(key) {
@@ -816,7 +797,7 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
     // ── balance (by wallet name) ──
     wallet
         .command("balance [name]")
-        .description("Check on-chain balance for a saved wallet (or active wallet)")
+        .description("On-chain balances for a saved wallet (or the active one): gas token + USDC / USDT on Arbitrum, Ethereum, Base, BNB Chain, Robinhood Chain (USDG) and Solana")
         .option("--testnet", "Use testnet", false)
         .action(async (name, opts) => {
         const store = loadStore();
@@ -867,44 +848,25 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
             if (activeEntries.length === 0) {
                 const settings = loadSettings();
                 if (settings.owsActiveWallet) {
+                    // Only loading the OWS vault may fall through to the env path; balance reads report
+                    // their own per-token errors and any other failure propagates.
+                    let owsAccounts = null;
                     try {
                         const { loadOws } = await import("../signer/ows-loader.js");
-                        const ows = loadOws();
-                        const owsWallet = ows.getWallet(settings.owsActiveWallet);
-                        const owsResults = [];
-                        for (const acct of owsWallet.accounts) {
-                            const isEvm = acct.chainId.startsWith("eip155:");
-                            const isSol = acct.chainId.startsWith("solana:");
-                            if (!isEvm && !isSol)
-                                continue;
-                            const address = acct.address;
-                            const balances = isSol
-                                ? await getSolanaBalances(address, opts.testnet)
-                                : await getEvmBalances(address, opts.testnet);
-                            if (isJson()) {
-                                owsResults.push({
-                                    wallet: settings.owsActiveWallet,
-                                    chain: isSol ? "solana" : "evm",
-                                    address,
-                                    balances,
-                                });
-                            }
-                            else {
-                                console.log(chalk.cyan.bold(`\n  ${settings.owsActiveWallet} (${isSol ? "solana" : "evm"} ${address.slice(0, 8)}...)`));
-                                const rows = balances.map((b) => [
-                                    chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-"),
-                                ]);
-                                console.log(makeTable(["Token", "Balance", "USD Value"], rows));
-                            }
-                        }
-                        if (isJson())
-                            printJson(jsonOk(owsResults));
-                        else
-                            console.log();
-                        return;
+                        owsAccounts = loadOws().getWallet(settings.owsActiveWallet).accounts;
                     }
                     catch {
-                        // OWS module unavailable or vault missing — fall through to env path
+                        owsAccounts = null; // OWS module unavailable or vault missing — use the env path below
+                    }
+                    if (owsAccounts !== null) {
+                        const results = [];
+                        for (const acct of owsAccounts) {
+                            const vm = acct.chainId.startsWith("solana:") ? "solana" : acct.chainId.startsWith("eip155:") ? "evm" : null;
+                            if (vm === null)
+                                continue;
+                            results.push(await balanceEntry({ wallet: settings.owsActiveWallet }, vm, acct.address, opts.testnet));
+                        }
+                        return printBalanceEntries(results, isJson());
                     }
                 }
                 const stored = loadEnvFile();
@@ -928,54 +890,13 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
                     }
                     process.exit(1);
                 }
-                for (const we of envEntries) {
-                    if (!isJson())
-                        console.log(chalk.cyan.bold(`\n  ${we.exchange} (${we.address.slice(0, 8)}...)`));
-                    const balances = we.chain === "solana"
-                        ? await getSolanaBalances(we.address, opts.testnet)
-                        : await getEvmBalances(we.address, opts.testnet);
-                    if (isJson()) {
-                        printJson(jsonOk({ exchange: we.exchange, address: we.address, balances }));
-                        continue;
-                    }
-                    const rows = balances.map((b) => [
-                        chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-"),
-                    ]);
-                    console.log(makeTable(["Token", "Balance", "USD Value"], rows));
-                }
-                console.log();
-                return;
-            }
-            for (const ae of activeEntries) {
-                if (!isJson())
-                    console.log(chalk.cyan.bold(`\n  ${ae.name} (${ae.exchange})`));
-                const balances = ae.type === "solana"
-                    ? await getSolanaBalances(ae.address, opts.testnet)
-                    : await getEvmBalances(ae.address, opts.testnet);
-                if (isJson()) {
-                    printJson(jsonOk({ wallet: ae.name, exchange: ae.exchange, balances }));
-                    continue;
-                }
-                const rows = balances.map((b) => [
-                    chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-"),
-                ]);
-                console.log(makeTable(["Token", "Balance", "USD Value"], rows));
+                return printBalanceEntries(await balanceEntries(envEntries.map(we => ({ label: { exchange: we.exchange }, vm: we.chain, address: we.address })), opts.testnet), isJson());
             }
-            console.log();
-            return;
+            return printBalanceEntries(await balanceEntries(activeEntries.map(ae => ({
+                label: { wallet: ae.name, exchange: ae.exchange }, vm: ae.type === "solana" ? "solana" : "evm", address: ae.address,
+            })), opts.testnet), isJson());
         }
-        if (!isJson())
-            console.log(chalk.cyan(`\n  Fetching balance for "${entry.name}" (${entry.address.slice(0, 8)}...)\n`));
-        const balances = entry.type === "solana"
-            ? await getSolanaBalances(entry.address, opts.testnet)
-            : await getEvmBalances(entry.address, opts.testnet);
-        if (isJson())
-            return printJson(jsonOk({ wallet: entry.name, balances }));
-        const rows = balances.map((b) => [
-            chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-"),
-        ]);
-        console.log(makeTable(["Token", "Balance", "USD Value"], rows));
-        console.log();
+        return printBalanceEntries([await balanceEntry({ wallet: entry.name }, entry.type === "solana" ? "solana" : "evm", entry.address, opts.testnet)], isJson());
     });
     // ── direct address balance (kept for convenience) ──
     wallet
@@ -988,8 +909,7 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
         const balances = await getSolanaBalances(address, opts.testnet);
         if (isJson())
             return printJson(jsonOk(balances));
-        const rows = balances.map((b) => [chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-")]);
-        console.log(makeTable(["Token", "Balance", "USD Value"], rows));
+        console.log(balanceTable(balances));
         console.log(chalk.gray(`\n  Network: ${opts.testnet ? "Devnet" : "Mainnet"}\n`));
     });
     wallet
@@ -999,11 +919,10 @@ export function registerWalletCommands(program, isJson, getAdapter, getPacificaA
         .action(async (address, opts) => {
         if (!isJson())
             console.log(chalk.cyan(`\n  Fetching Arbitrum balances for ${address.slice(0, 8)}...${address.slice(-4)}\n`));
-        const balances = await getEvmBalances(address, opts.testnet);
+        const balances = await getEvmBalances(address, opts.testnet, [opts.testnet ? "arbitrum-sepolia" : "arbitrum"]);
         if (isJson())
             return printJson(jsonOk(balances));
-        const rows = balances.map((b) => [chalk.white.bold(b.token), b.balance, b.usdValue || chalk.gray("-")]);
-        console.log(makeTable(["Token", "Balance", "USD Value"], rows));
+        console.log(balanceTable(balances));
         console.log(chalk.gray(`\n  Network: Arbitrum ${opts.testnet ? "Sepolia" : "One"}\n`));
     });
     // ── migrate (legacy → OWS) ──

package/dist/exchanges/aster.d.ts

@@ -61,6 +61,8 @@ type ResolvedSigner = {
     /** EVM address of the owner/master — used as `user` field in Aster requests */
     userAddress: string;
 };
+/** Max 1000-row pages of 7-day commission income read for symbol discovery (20 000 fills). */
+export declare const ASTER_INCOME_MAX_PAGES = 20;
 export declare class AsterAdapter implements ExchangeAdapter {
     readonly name = "aster";
     readonly chain = "bnb";
@@ -207,7 +209,26 @@ export declare class AsterAdapter implements ExchangeAdapter {
      */
     invalidateOpenOrdersCache(): void;
     getOpenOrders(): Promise<ExchangeOrder[]>;
+    /**
+     * Symbols with account activity: open positions, open orders, and every symbol with a
+     * COMMISSION income row in the last 7 days (the venue's default window). Aster's userTrades /
+     * allOrders both require `symbol`, so this is the per-symbol fan-out set. Income is read in
+     * pages of 1000 (the endpoint max; startTime / endTime are inclusive) walking back from now;
+     * more than ASTER_INCOME_MAX_PAGES pages → EXCHANGE_ERROR, never a partial set. Orders on a
+     * symbol that never filled, is not open and has no position cannot be found (allOrders needs it).
+     */
+    private _tradedApiSymbols;
+    /**
+     * Recent orders across the symbols with account activity (see _tradedApiSymbols), newest first.
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /**
+     * Recent fills. `GET /fapi/v3/userTrades` requires a symbol (asterdex/api-docs V3), so the
+     * symbols come from the open positions plus every symbol with a COMMISSION income row in the
+     * venue's default window (`GET /fapi/v3/income`: "the recent 7-day data" when no time is sent).
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
     /**

package/dist/exchanges/aster.js

@@ -152,6 +152,8 @@ export function requireAsterClientOrderId(id) {
     return id;
 }
 // ── AsterAdapter ──────────────────────────────────────────────────────────────
+/** Max 1000-row pages of 7-day commission income read for symbol discovery (20 000 fills). */
+export const ASTER_INCOME_MAX_PAGES = 20;
 export class AsterAdapter {
     name = "aster";
     chain = "bnb";
@@ -715,65 +717,137 @@ export class AsterAdapter {
         this._ordersCache = { data: result, time: Date.now(), epoch: accountCacheEpoch() };
         return result;
     }
-    async getOrderHistory(limit = 30) {
+    /**
+     * Symbols with account activity: open positions, open orders, and every symbol with a
+     * COMMISSION income row in the last 7 days (the venue's default window). Aster's userTrades /
+     * allOrders both require `symbol`, so this is the per-symbol fan-out set. Income is read in
+     * pages of 1000 (the endpoint max; startTime / endTime are inclusive) walking back from now;
+     * more than ASTER_INCOME_MAX_PAGES pages → EXCHANGE_ERROR, never a partial set. Orders on a
+     * symbol that never filled, is not open and has no position cannot be found (allOrders needs it).
+     */
+    async _tradedApiSymbols(r) {
         const positions = await this.getPositions();
         const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
-        if (apiSymbols.size === 0) {
-            for (const s of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT"]) {
-                apiSymbols.add(s);
+        const open = await this._signedGetEip712("/fapi/v3/openOrders", {}, r);
+        if (!Array.isArray(open)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster open orders is not a list (${JSON.stringify(open).slice(0, 120)})`, { exchange: "aster" });
+        }
+        for (const o of open) {
+            if (typeof o.symbol === "string" && o.symbol !== "")
+                apiSymbols.add(o.symbol);
+        }
+        const startTime = Date.now() - 7 * 86_400_000;
+        let endTime = Date.now();
+        for (let page = 0;; page++) {
+            if (page >= ASTER_INCOME_MAX_PAGES) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster commission history exceeds ${ASTER_INCOME_MAX_PAGES * 1000} rows in 7 days — the symbol list would be incomplete`, {
+                    exchange: "aster", remediation: "Check fills per symbol in the Aster web app",
+                });
+            }
+            const income = await this._signedGetEip712("/fapi/v3/income", {
+                incomeType: "COMMISSION", startTime: String(startTime), endTime: String(endTime), limit: "1000",
+            }, r);
+            if (!Array.isArray(income)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster income history is not a list (${JSON.stringify(income).slice(0, 120)})`, { exchange: "aster" });
+            }
+            let oldest = Infinity;
+            for (const row of income) {
+                if (typeof row.symbol === "string" && row.symbol !== "")
+                    apiSymbols.add(row.symbol);
+                const t = Number(row.time);
+                if (!Number.isFinite(t)) {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster income row without a numeric time: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "aster" });
+                }
+                oldest = Math.min(oldest, t);
             }
+            if (income.length < 1000 || oldest <= startTime)
+                break;
+            endTime = oldest - 1;
         }
+        return apiSymbols;
+    }
+    /**
+     * Recent orders across the symbols with account activity (see _tradedApiSymbols), newest first.
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
+    async getOrderHistory(limit = 30) {
         const r = this._resolveSigner();
-        const allOrders = [];
+        const apiSymbols = await this._tradedApiSymbols(r);
+        const field = (o, k) => {
+            const v = o[k];
+            if ((typeof v === "string" && v !== "") || typeof v === "number")
+                return String(v);
+            throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row without a readable ${k}: ${JSON.stringify(o).slice(0, 160)}`, { exchange: "aster" });
+        };
+        const rows = [];
         for (const sym of apiSymbols) {
-            try {
-                const orders = await this._signedGetEip712("/fapi/v3/allOrders", {
-                    symbol: sym,
-                    limit: String(limit),
-                }, r);
-                for (const o of orders ?? []) {
-                    allOrders.push({
-                        orderId: String(o.orderId ?? ""),
-                        symbol: this._fromApi(String(o.symbol ?? "")),
-                        side: String(o.side).toLowerCase(),
-                        price: String(o.price ?? "0"),
-                        size: String(o.origQty ?? "0"),
-                        filled: String(o.executedQty ?? "0"),
-                        status: String(o.status ?? ""),
-                        type: String(o.type ?? ""),
-                        triggerPrice: Number(o.stopPrice) > 0 ? String(o.stopPrice) : null,
-                    });
+            const orders = await this._signedGetEip712("/fapi/v3/allOrders", { symbol: sym, limit: String(limit) }, r);
+            if (!Array.isArray(orders)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster allOrders for ${sym} is not a list (${JSON.stringify(orders).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const o of orders) {
+                const side = field(o, "side").toLowerCase();
+                if (side !== "buy" && side !== "sell") {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row with unknown side "${side}"`, { exchange: "aster" });
                 }
+                const time = Number(field(o, "time"));
+                if (!Number.isFinite(time))
+                    throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row with a non-numeric time`, { exchange: "aster" });
+                rows.push({
+                    time,
+                    order: {
+                        orderId: field(o, "orderId"),
+                        symbol: this._fromApi(field(o, "symbol")),
+                        side,
+                        price: field(o, "price"),
+                        size: field(o, "origQty"),
+                        filled: field(o, "executedQty"),
+                        status: field(o, "status"),
+                        type: field(o, "type"),
+                        triggerPrice: Number(o.stopPrice) > 0 ? String(o.stopPrice) : null,
+                    },
+                });
             }
-            catch { /* skip */ }
         }
-        return allOrders.slice(0, limit);
+        return rows.sort((x, y) => y.time - x.time).slice(0, limit).map(x => x.order);
     }
+    /**
+     * Recent fills. `GET /fapi/v3/userTrades` requires a symbol (asterdex/api-docs V3), so the
+     * symbols come from the open positions plus every symbol with a COMMISSION income row in the
+     * venue's default window (`GET /fapi/v3/income`: "the recent 7-day data" when no time is sent).
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     async getTradeHistory(limit = 30) {
-        const positions = await this.getPositions();
-        const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
-        if (apiSymbols.size === 0)
-            apiSymbols.add("BTCUSDT");
         const r = this._resolveSigner();
+        const apiSymbols = await this._tradedApiSymbols(r);
+        const field = (t, k) => {
+            const v = t[k];
+            if ((typeof v === "string" && v !== "") || typeof v === "number")
+                return String(v);
+            throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row without a readable ${k}: ${JSON.stringify(t).slice(0, 160)}`, { exchange: "aster" });
+        };
         const allTrades = [];
         for (const sym of apiSymbols) {
-            try {
-                const trades = await this._signedGetEip712("/fapi/v3/userTrades", {
-                    symbol: sym,
-                    limit: String(limit),
-                }, r);
-                for (const t of trades ?? []) {
-                    allTrades.push({
-                        time: Number(t.time ?? 0),
-                        symbol: this._fromApi(String(t.symbol ?? "")),
-                        side: t.buyer ? "buy" : "sell",
-                        price: String(t.price ?? "0"),
-                        size: String(t.qty ?? "0"),
-                        fee: String(t.commission ?? "0"),
-                    });
+            const trades = await this._signedGetEip712("/fapi/v3/userTrades", { symbol: sym, limit: String(limit) }, r);
+            if (!Array.isArray(trades)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster userTrades for ${sym} is not a list (${JSON.stringify(trades).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const t of trades) {
+                if (typeof t.buyer !== "boolean") {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row without a boolean buyer: ${JSON.stringify(t).slice(0, 160)}`, { exchange: "aster" });
                 }
+                const time = Number(field(t, "time"));
+                if (!Number.isFinite(time))
+                    throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row with a non-numeric time`, { exchange: "aster" });
+                allTrades.push({
+                    time,
+                    symbol: this._fromApi(field(t, "symbol")),
+                    side: t.buyer ? "buy" : "sell",
+                    price: field(t, "price"),
+                    size: field(t, "qty"),
+                    fee: field(t, "commission"),
+                });
             }
-            catch { /* skip */ }
         }
         return allTrades.sort((a, b) => b.time - a.time).slice(0, limit);
     }

package/dist/exchanges/ondo/adapter.d.ts

@@ -42,12 +42,6 @@ import type { VenueCreateContext, VenueDefinition } from "../venue.js";
 import type { AmendRequest, CancelResult, LeverageResult, Network, OrderRef, OrderRequest, OrderResult, VenueMarket } from "../venue-types.js";
 import { type BuilderFeeGate } from "../builder-fee.js";
 import { OndoClient } from "./client.js";
-interface OndoWithdrawal {
-    withdrawal_status: string;
-    withdrawal_id: string;
-    customer_withdrawal_id: string;
-    hash?: string;
-}
 export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     readonly name: "ondo";
     readonly aliases: readonly ["ondo-perps"];
@@ -72,8 +66,6 @@ export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
     get restClient(): OndoClient;
     /** Account id from GET /v1/account — the `from.id`/`to.id` of withdrawals and spot↔perp transfers. */
     accountId(): Promise<string>;
-    /** Withdrawal address book (GET /v1/wallet/address_book) — withdrawals go only to these addresses. */
-    addressBook(): Promise<string[]>;
     private pairOf;
     /**
      * An order the venue returned as "pending" (not yet open / filled) is read back by id
@@ -152,15 +144,9 @@ export declare class OndoAdapter implements ExchangeAdapter, TradingV2 {
         triggerType?: "mark" | "last" | "mid";
     }): Promise<OrderResult>;
     /**
-     * Withdraw USDC from the perps (margin) wallet to an Ethereum address.
-     * Requires an API key with the `transfer` scope. The destination may need to
-     * be on the account's address book (venue error bad_withdrawal_address).
+     * Withdrawals are not available over the API (account owner, 2026-10-13): Ondo pays only
+     * address-book destinations and refuses API-key auth for adding one
+     * (`key_not_allowed_for_action`). Refused before any request — withdraw in the web app.
      */
-    withdraw(amount: string, destination: string, opts?: {
-        assetId?: number;
-        routeType?: number;
-    }): Promise<OndoWithdrawal & {
-        withdrawalFeeUSD: string;
-    }>;
+    withdraw(_amount: string, _destination: string): Promise<never>;
 }
-export {};

package/dist/exchanges/ondo/adapter.js

@@ -41,7 +41,6 @@ import { alignProtectionPrice, floorSize, formatComputedPrice, requireOnTick, sl
 import { unsupported, validateLegacyTif, validateOrderRequest } from "../trading-v2.js";
 import { networkConfig, requireCapabilities } from "../venue.js";
 import { parseOrderRef, toLegacyMarketInfo } from "../venue-types.js";
-import { ONDO_WITHDRAW_NETWORK } from "../venues/ondo.js";
 import { builderGateOf, builderRejectionOf, NO_BUILDER, requireFeeBps } from "../builder-fee.js";
 import { loadOndoCredentials, ONDO_APPROVE_REMEDIATION } from "./agent.js";
 import { OndoClient } from "./client.js";
@@ -217,10 +216,6 @@ export class OndoAdapter {
         const account = await this.client.get("/v1/account", null);
         return account.accountID;
     }
-    /** Withdrawal address book (GET /v1/wallet/address_book) — withdrawals go only to these addresses. */
-    async addressBook() {
-        return (await import("./funds.js")).ondoAddressBook(this.client);
-    }
     // ── Helpers ──
     async pairOf(symbol) {
         const market = ondoVenueSymbol(symbol);
@@ -806,30 +801,11 @@ export class OndoAdapter {
     }
     // ── Withdraw (capabilities.WithdrawCapable) ──
     /**
-     * Withdraw USDC from the perps (margin) wallet to an Ethereum address.
-     * Requires an API key with the `transfer` scope. The destination may need to
-     * be on the account's address book (venue error bad_withdrawal_address).
+     * Withdrawals are not available over the API (account owner, 2026-10-13): Ondo pays only
+     * address-book destinations and refuses API-key auth for adding one
+     * (`key_not_allowed_for_action`). Refused before any request — withdraw in the web app.
      */
-    async withdraw(amount, destination, opts) {
-        if (opts?.assetId !== undefined || opts?.routeType !== undefined) {
-            throw new PerpError("INVALID_PARAMS", "Ondo Perps withdraw takes no assetId/routeType (USDC on Ethereum only)");
-        }
-        if (!/^0x[0-9a-fA-F]{40}$/.test(destination)) {
-            throw new PerpError("INVALID_PARAMS", `Ondo Perps withdraw destination must be an Ethereum address (got "${destination}")`);
-        }
-        if (!/^\d+(\.\d+)?$/.test(amount) || !isPositive(amount)) {
-            throw new PerpError("INVALID_PARAMS", `Withdraw amount must be a positive decimal (got "${amount}")`);
-        }
-        // AccountInfo.withdrawalFeeUSD (required in the OpenAPI spec) is reported with the result.
-        const account = await this.client.get("/v1/account", null);
-        const res = await this.client.post("/v1/withdraw", {
-            customer_withdrawal_id: randomUUID(),
-            symbol: "USDC",
-            network: ONDO_WITHDRAW_NETWORK,
-            amount,
-            address: destination,
-            from: { id: account.accountID, wallet: "margin" },
-        });
-        return { ...res, withdrawalFeeUSD: account.withdrawalFeeUSD };
+    async withdraw(_amount, _destination) {
+        throw unsupported("Ondo Perps", "withdraw", "the Ondo Perps API does not allow withdrawals", "Withdraw from the Ondo Perps web app");
     }
 }