perp-cli 0.15.0 → 0.16.0

package/dist/commands/pacifica-earn.js

@@ -19,7 +19,7 @@ import { isDryRun, networkOf, supportsDryRun } from "../cli-flags.js";
 import { PerpError } from "../errors.js";
 import { PacificaAdapter } from "../exchanges/pacifica.js";
 import { resolveVenueId } from "../exchanges/venue.js";
-import { PacificaClient } from "../pacifica/client.js";
+import { PacificaClient, requireSolanaAddress } from "../pacifica/client.js";
 import { logExecution } from "../execution-log.js";
 import { jsonOk, makeTable, printJson } from "../utils.js";
 import { mulDecimal } from "../exchanges/precision.js";
@@ -27,7 +27,7 @@ import { cmpDecimal, isPlainDecimal, trimDecimal } from "../exchanges/pacifica-d
 import { fundsFailStatus } from "./funds.js";
 import { requireIdempotencyKey, restampPresigned, sendPresigned, signPresigned } from "../exchanges/pacifica-presigned.js";
 import { buildPrintDepositRequest, buildPrintEndRequest, daysUntil, fetchPrintEvents, fetchPrintGames, fetchPrintHistory, fetchPrintMarket, fetchPrintPositions, findPrintGame, quotePrintOrder, requireEndable, } from "../exchanges/pacifica-print.js";
-import { buildVaultDepositRequest, buildVaultWithdrawRequest, DEPOSIT_WHITELIST_API_STATUS, fetchDepositWhitelist, fetchVaults, findVault, heldShares, planVaultDeposit, planVaultWithdraw, withdrawWindowAt, } from "../exchanges/pacifica-vaults.js";
+import { buildVaultDepositRequest, buildVaultWithdrawRequest, DEPOSIT_WHITELIST_API_STATUS, readDepositWhitelist, fetchVaults, findVault, heldShares, planVaultDeposit, planVaultWithdraw, withdrawWindowAt, } from "../exchanges/pacifica-vaults.js";
 const ts = (ms) => (ms === null ? "—" : new Date(ms).toISOString().replace("T", " ").slice(0, 16) + " UTC");
 export function registerPacificaEarnCommands(program, getAdapterForExchange, isJson) {
     /** Pacifica-only: an explicit -e naming another venue is refused (never silently ignored). */
@@ -288,11 +288,11 @@ export function registerPacificaEarnCommands(program, getAdapterForExchange, isJ
         assertPacifica();
         const c = publicClient();
         const v = findVault(await fetchVaults(c, null), ref);
-        const [acct, positions, whitelist] = await Promise.all([c.getAccount(v.address), c.getPositions(v.address), whitelistOrNull(c, v.address)]);
+        const [acct, positions, whitelist] = await Promise.all([c.getAccount(v.address), c.getPositions(v.address), readDepositWhitelist(c, v.address)]);
         const out = {
             ...v,
             live: { accountEquity: acct.account_equity ?? null, availableToWithdraw: acct.available_to_withdraw ?? null, positions: positions.map((p) => ({ symbol: p.symbol, side: p.side, amount: p.amount, entryPrice: p.entry_price })) },
-            depositWhitelist: { apiStatus: DEPOSIT_WHITELIST_API_STATUS, addresses: whitelist },
+            depositWhitelist: { apiStatus: DEPOSIT_WHITELIST_API_STATUS, addresses: whitelist.addresses, error: whitelist.error },
             withdrawWindow: withdrawWindowAt(v.config, Date.now()),
         };
         if (isJson())
@@ -304,7 +304,7 @@ export function registerPacificaEarnCommands(program, getAdapterForExchange, isJ
             "vault free balance": out.live.availableToWithdraw ?? "—", "performance fee": v.config.managerProfitShare ?? "none", "deposit cap": v.config.depositCap ?? "none",
             "lock-up after deposit": v.config.depositMinDurationMs === null ? "none" : `${(v.config.depositMinDurationMs / 3_600_000).toFixed(2)} h (reset by every deposit)`,
             "withdrawal window": `${windowLabel(v)}${out.withdrawWindow.restricted ? ` — now ${out.withdrawWindow.open ? "OPEN until" : "closed, opens"} ${ts(out.withdrawWindow.nextChangeAt)}` : ""}`,
-            "deposit whitelist": `${whitelist === null ? "unknown" : whitelist.length === 0 ? "none (anyone)" : `${whitelist.length} address(es)`} (unofficial endpoint; the venue decides)`, APY: "not published",
+            "deposit whitelist": `${whitelist.addresses === null ? `unknown (${whitelist.error})` : whitelist.addresses.length === 0 ? "none (anyone)" : `${whitelist.addresses.length} address(es)`} (unofficial endpoint; the venue decides)`, APY: "not published",
         }))
             console.log(`  ${k.padEnd(22)} ${val}`);
         if (out.live.positions.length > 0)
@@ -339,8 +339,8 @@ export function registerPacificaEarnCommands(program, getAdapterForExchange, isJ
         const c = publicClient();
         const s = await masterSigning(o.account, dryRun);
         const v = findVault(await fetchVaults(c, s.identity.account), ref);
-        const [info, whitelist] = await Promise.all([c.getAccount(s.identity.account), whitelistOrNull(c, v.address)]);
-        const plan = planVaultDeposit(v, s.identity.account, amount, { availableToWithdraw: availableOf(info, s.identity.account), whitelist });
+        const [info, whitelist] = await Promise.all([c.getAccount(s.identity.account), readDepositWhitelist(c, v.address)]);
+        const plan = planVaultDeposit(v, s.identity.account, amount, { availableToWithdraw: availableOf(info, s.identity.account), whitelist: whitelist.addresses });
         const sharesBefore = heldShares(v, s.identity.account).shares ?? "0";
         const req = buildVaultDepositRequest(v.address, plan.amount, s.identity, { timestamp: Date.now(), idempotencyKey });
         if (!isJson())
@@ -393,21 +393,8 @@ export function registerPacificaEarnCommands(program, getAdapterForExchange, isJ
     });
 }
 // ── helpers ──────────────────────────────────────────────────────────────
-/** Unofficial whitelist read: null when unreadable (advisory only — the venue's refusal is final). */
-async function whitelistOrNull(c, vault) {
-    try {
-        return await fetchDepositWhitelist(c, vault);
-    }
-    catch {
-        return null;
-    }
-}
 function requireAddress(s) {
-    const a = s.trim();
-    if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(a)) {
-        throw new PerpError("INVALID_PARAMS", `Not a Solana (base58) address: "${s}"`, { remediation: "Pass a base58 Solana address" });
-    }
-    return a;
+    return requireSolanaAddress(s);
 }
 function parseDirection(s) {
     const d = s.trim().toLowerCase();

package/dist/commands/portfolio.d.ts

@@ -16,10 +16,26 @@
  */
 import type { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
+import type { DashboardExchange } from "../dashboard/index.js";
 import "../exchanges/venues/index.js";
+/**
+ * HIP-3 dex names, read live from info `perpDexs` on the selected network (index 0 = the native
+ * dex, null). Throws on a failed or malformed read — never substitutes a fixed list (Rule #2):
+ * a stale list hides positions on any dex Hyperliquid adds later.
+ */
+export declare function fetchHip3DexNames(): Promise<string[]>;
 /**
  * Open-position count on a HIP-3 dex; null = the read failed (unknown — NOT "no positions").
  * The failure is warned on stderr; callers must treat null as "may hold positions".
  */
 export declare function checkDexPositions(address: string, dex: string): Promise<number | null>;
+/**
+ * HIP-3 dexes holding positions (or whose read failed) for `address`, scanning every dex of the
+ * live `perpDexs` list. `error` is set when the dex list itself could not be read: no dex is
+ * scanned and the caller must surface it (positions on HIP-3 dexes are unknown, not absent).
+ */
+export declare function autoDetectHip3Dexes(address: string, getHLAdapterForDex: (dex: string) => Promise<ExchangeAdapter>, verbose: boolean): Promise<{
+    exchanges: DashboardExchange[];
+    error: string | null;
+}>;
 export declare function registerPortfolioCommand(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean, version: string, getHLAdapterForDex?: (dex: string) => Promise<ExchangeAdapter>): void;

package/dist/commands/portfolio.js

@@ -304,7 +304,7 @@ async function runHealth(exchangeList, network) {
 }
 // ── Arb top-5 ──────────────────────────────────────────────────────────────
 async function fetchArbTop() {
-    const { fetchAllFundingRates, TOP_SYMBOLS } = await import("../funding-rates.js");
+    const { fetchAllFundingRates, isRankedComparison, TOP_SYMBOLS } = await import("../funding-rates.js");
     const { saveFundingSnapshot, getHistoricalAverages } = await import("../funding-history.js");
     let snapshot;
     try {
@@ -323,6 +323,7 @@ async function fetchArbTop() {
     }
     catch { /* ignore */ }
     const top = snapshot.symbols
+        .filter(isRankedComparison)
         .filter(s => s.maxSpreadAnnual >= 5)
         .sort((a, b) => b.maxSpreadAnnual - a.maxSpreadAnnual)
         .slice(0, 5);
@@ -527,7 +528,31 @@ async function runWatch(resolved, version, getAdapterForExchange, isJsonMode) {
     }
 }
 // ── Serve mode (delegates to dashboard infra) ──────────────────────────────
-const KNOWN_HIP3_DEXES = ["xyz", "flx", "hyna", "km", "cash", "vntl"];
+/**
+ * HIP-3 dex names, read live from info `perpDexs` on the selected network (index 0 = the native
+ * dex, null). Throws on a failed or malformed read — never substitutes a fixed list (Rule #2):
+ * a stale list hides positions on any dex Hyperliquid adds later.
+ */
+export async function fetchHip3DexNames() {
+    const res = await fetch(HYPERLIQUID_API_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "perpDexs" }),
+    });
+    if (!res.ok)
+        throw new Error(`info perpDexs HTTP ${res.status}`);
+    const list = await res.json();
+    if (!Array.isArray(list))
+        throw new Error("info perpDexs: expected an array");
+    return list.flatMap((d, i) => {
+        if (d === null)
+            return [];
+        const name = d?.name;
+        if (typeof name !== "string" || name === "")
+            throw new Error(`info perpDexs: entry ${i} has no dex name`);
+        return [name];
+    });
+}
 /**
  * Open-position count on a HIP-3 dex; null = the read failed (unknown — NOT "no positions").
  * The failure is warned on stderr; callers must treat null as "may hold positions".
@@ -558,8 +583,22 @@ export async function checkDexPositions(address, dex) {
         return null;
     }
 }
-async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
-    const checks = await Promise.all(KNOWN_HIP3_DEXES.map(async (dex) => ({
+/**
+ * HIP-3 dexes holding positions (or whose read failed) for `address`, scanning every dex of the
+ * live `perpDexs` list. `error` is set when the dex list itself could not be read: no dex is
+ * scanned and the caller must surface it (positions on HIP-3 dexes are unknown, not absent).
+ */
+export async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
+    let dexes;
+    try {
+        dexes = await fetchHip3DexNames();
+    }
+    catch (e) {
+        const error = `HIP-3 dex list unavailable — HIP-3 positions unknown, pass --dexes to monitor specific dexes: ${e instanceof Error ? e.message : String(e)}`;
+        process.stderr.write(`[warn] hl:hip3 ${error}\n`);
+        return { exchanges: [], error };
+    }
+    const checks = await Promise.all(dexes.map(async (dex) => ({
         dex,
         count: await checkDexPositions(address, dex),
     })));
@@ -580,7 +619,7 @@ async function autoDetectHip3Dexes(address, getHLAdapterForDex, verbose) {
             process.stderr.write(`[warn] hl:${dex} left out of the dashboard (adapter unavailable${count === null ? ", positions unknown" : `, ${count} position(s)`}): ${e instanceof Error ? e.message : String(e)}\n`);
         }
     }
-    return results;
+    return { exchanges: results, error: null };
 }
 async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapterForDex) {
     const { startDashboard } = await import("../dashboard/index.js");
@@ -616,7 +655,9 @@ async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapte
                 const hlAddr = hlEx ? hlEx.adapter.address ?? "" : "";
                 if (hlAddr) {
                     const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, false);
-                    exchanges.push(...detected);
+                    exchanges.push(...detected.exchanges);
+                    if (detected.error !== null)
+                        errors["hl:hip3"] = detected.error;
                 }
             }
         }
@@ -675,8 +716,10 @@ async function runServe(resolved, getAdapterForExchange, isJsonMode, getHLAdapte
             if (hlAddr) {
                 console.log(chalk.gray("  Scanning HIP-3 dexes for active positions..."));
                 const detected = await autoDetectHip3Dexes(hlAddr, getHLAdapterForDex, true);
-                exchanges.push(...detected);
-                if (!detected.length)
+                exchanges.push(...detected.exchanges);
+                if (detected.error !== null)
+                    console.log(chalk.yellow(`  ✗ hl:hip3: ${detected.error.slice(0, 120)}`));
+                else if (!detected.exchanges.length)
                     console.log(chalk.gray("  No active HIP-3 dex positions found"));
             }
         }

package/dist/commands/trade.js

@@ -303,7 +303,7 @@ function checkTpSlDirection(positionSide, ref, refLabel, p) {
 }
 /** The venue's current mark price for `symbol` (PRICE_STALE when it is not published / not positive). */
 async function markPriceOf(adapter, symbol) {
-    const m = (await adapter.getMarkets()).find(x => symbolMatch(x.symbol, symbol));
+    const m = (await adapter.getMarkets({ funding: false })).find(x => symbolMatch(x.symbol, symbol));
     const px = m === undefined ? NaN : Number(m.markPrice);
     if (!(px > 0) || !Number.isFinite(px)) {
         throw new PerpError("PRICE_STALE", `${adapter.name} ${symbol}: no mark price to check the TP/SL direction against`, { exchange: adapter.name });
@@ -489,7 +489,7 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
     }
     /** Mark price of `sym` (split sizing / risk); no usable mark → PRICE_STALE, nothing sent. */
     async function splitMarkPrice(adapter, sym) {
-        const market = (await adapter.getMarkets()).find(m => symbolMatch(m.symbol, sym));
+        const market = (await adapter.getMarkets({ funding: false })).find(m => symbolMatch(m.symbol, sym));
         const markPrice = market !== undefined ? Number(market.markPrice) : NaN;
         if (!(markPrice > 0)) {
             throw new PerpError("PRICE_STALE", `${adapter.name}: no usable mark price for ${sym} — cannot size the split; nothing was sent`, { exchange: adapter.name });
@@ -1489,8 +1489,8 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
     });
     // === Pacifica-only commands ===
     supportsDryRun(trade.command("edit <symbol> <orderId> <price> <size>"))
-        .description("Edit an existing order: new price and new open (unfilled) size; the order keeps its TIF / post-only (pacifica: re-created as ALO) — orderId, or c:<clientOrderId> on ondo/arcus/qfex (qfex: plain LIMIT / ALO only; the venue assigns a new order id, the client id is kept)")
-        .option("--tif <tif>", "Time-in-force of the replacement (cancel+replace venues only, e.g. ondo; ALO keeps post-only)")
+        .description("Edit an existing order: new price and new open (unfilled) size; the order keeps its TIF / post-only (pacifica: TIF read from the order's client id — ALO via native edit, GTC / TOB via cancel+replace; a new order id either way) — use the orderId the edit returns; orderId, or c:<clientOrderId> on ondo/arcus/qfex (qfex: plain LIMIT / ALO only; the venue assigns a new order id, the client id is kept)")
+        .option("--tif <tif>", "Time-in-force of the replacement (ondo / pacifica only; ALO keeps post-only)")
         .option("--force-tif", "Allow --tif to flip the order's post-only flag (ondo / pacifica); otherwise such a conflict is refused")
         .action(async (symbol, orderId, price, size, opts) => {
         const adapter = await getAdapter();

package/dist/cross-chain-margin.d.ts

@@ -70,4 +70,6 @@ export declare function marginEntryBlocks(check: ChainMarginCheck, minMarginPct?
  * @param maxSlippagePct - Max acceptable slippage (default: 0.3%)
  * @returns USD size per leg, or 0 if not viable
  */
-export declare function computeAutoSize(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, maxSlippagePct?: number): Promise<number>;
+export declare function computeAutoSize(longAdapter: ExchangeAdapter, shortAdapter: ExchangeAdapter, symbol: string, maxSlippagePct?: number, 
+/** The short venue's own symbol when it differs (kPEPE ↔ 1000PEPE); default `symbol`. */
+shortSymbol?: string): Promise<number>;

package/dist/cross-chain-margin.js

@@ -94,11 +94,13 @@ export function marginEntryBlocks(check, minMarginPct = 30) {
  * @param maxSlippagePct - Max acceptable slippage (default: 0.3%)
  * @returns USD size per leg, or 0 if not viable
  */
-export async function computeAutoSize(longAdapter, shortAdapter, symbol, maxSlippagePct = 0.3) {
+export async function computeAutoSize(longAdapter, shortAdapter, symbol, maxSlippagePct = 0.3, 
+/** The short venue's own symbol when it differs (kPEPE ↔ 1000PEPE); default `symbol`. */
+shortSymbol = symbol) {
     // Step 1: Get orderbooks from both sides
     const [longOB, shortOB, longBal, shortBal] = await Promise.all([
         longAdapter.getOrderbook(symbol),
-        shortAdapter.getOrderbook(symbol),
+        shortAdapter.getOrderbook(shortSymbol),
         longAdapter.getBalance(),
         shortAdapter.getBalance(),
     ]);

package/dist/dashboard/server.js

@@ -44,11 +44,11 @@ async function pollArbData() {
     let exchangeStatus = {};
     let exchangeErrors = {};
     try {
-        const { fetchAllFundingRates } = await import("../funding/rates.js");
+        const { fetchAllFundingRates, isRankedComparison } = await import("../funding/rates.js");
         const snapshot = await fetchAllFundingRates({ minSpread: 5 });
         exchangeStatus = snapshot.exchangeStatus;
         exchangeErrors = snapshot.exchangeErrors;
-        for (const sym of snapshot.symbols.slice(0, 20)) {
+        for (const sym of snapshot.symbols.filter(isRankedComparison).slice(0, 20)) {
             opportunities.push({
                 symbol: sym.symbol,
                 longExchange: sym.longExchange,

package/dist/dashboard/ui.js

@@ -235,6 +235,8 @@ function connect() {
 // ── Helpers ──
 function fmt(v, d=2) { const n=Number(v)||0; return n.toLocaleString('en-US',{minimumFractionDigits:d,maximumFractionDigits:d}); }
 function usdOrDash(v, d=2) { return v==null ? '-' : '$'+fmt(v,d); }
+// Market row cells: prices in the row's quote currency (QFEX SAMSUNG-KRW: "220,150.00 KRW", never $); OI is BASE units (never $); funding null = "-" (not 0%).
+function marketCells(m) { const q=(typeof m.quoteAsset==='string'&&m.quoteAsset!=='USD')?escHtml(m.quoteAsset):null; const px=(v,d=2)=>v==null?'-':(q===null?'$'+fmt(v,d):fmt(v,d)+' '+q); const vol=m.volume24h==null&&typeof m.volume24hQuote==='string'?px(m.volume24hQuote,0):usdOrDash(m.volume24h,0); const base=escHtml(String(m.symbol).split(':').pop().replace(/-PERP$/i,'')); return { mark: px(m.markPrice), index: px(m.indexPrice), funding: m.fundingRate==null?'-':(Number(m.fundingRate)*100).toFixed(4)+'%', volume: vol, oi: m.openInterest==null?'-':Number(m.openInterest).toLocaleString('en-US',{maximumFractionDigits:4})+' '+base }; }
 function pnlClass(v) { return Number(v)>=0?'pnl-pos':'pnl-neg'; }
 function pnlSign(v) { const n=Number(v)||0; return n>=0?'+$'+fmt(Math.abs(n)):'-$'+fmt(Math.abs(n)); }
 function rateClass(v) { const n=Number(v)||0; return n>0?'rate-positive':n<0?'rate-negative':'rate-neutral'; }
@@ -243,7 +245,8 @@ function spreadClass(v) { return v>=50?'spread-high':v>=20?'spread-mid':'spread-
 const NA = '<span style="color:var(--yellow,#e5c07b)">unavailable</span>';
 function usdOrNA(v, d=2) { return v==null ? NA : '$'+fmt(v,d); }
 function pnlOrNA(v) { return v==null ? NA : pnlSign(v); }
-function escHtml(v) { return String(v).replace(/[&<>"]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'})[c]); }
+// Every venue-supplied string (symbol, quoteAsset, dex, exchange, order fields) goes through this before innerHTML.
+function escHtml(v) { return String(v).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[c]); }
 
 // ── Portfolio Rendering ──
 function renderTotals(t) {
@@ -325,16 +328,16 @@ function renderPanels(exchanges) {
         const notional = p.markPrice == null ? null : Math.abs(Number(p.size)) * Number(p.markPrice);
         const margin = notional == null ? null : p.leverage > 0 ? notional / p.leverage : notional;
         const roe = margin != null && margin > 0 && p.unrealizedPnl != null ? (Number(p.unrealizedPnl) / margin * 100) : null;
-        return \`<tr>\${isHL?\`<td style="color:var(--purple);font-size:11px">\${dex}</td>\`:''}<td>\${sym}</td><td class="side-\${p.side}">\${p.side.toUpperCase()}</td><td>\${p.size}</td><td>\${usdOrNA(p.entryPrice)}</td><td>\${usdOrNA(p.markPrice)}</td><td>\${(p.liquidationPrice==null||p.liquidationPrice==='N/A')?'-':'$'+fmt(p.liquidationPrice)}</td><td style="color:var(--muted)">\${usdOrNA(notional)}</td><td class="\${pnlClass(p.unrealizedPnl)}">\${pnlOrNA(p.unrealizedPnl)}</td><td class="\${pnlClass(p.unrealizedPnl)}">\${roe==null?NA:(roe>=0?'+':'')+fmt(roe,1)+'%'}</td><td>\${p.leverage}x</td></tr>\`;
+        return \`<tr>\${isHL?\`<td style="color:var(--purple);font-size:11px">\${escHtml(dex)}</td>\`:''}<td>\${escHtml(sym)}</td><td class="side-\${escHtml(p.side)}">\${escHtml(String(p.side).toUpperCase())}</td><td>\${escHtml(p.size)}</td><td>\${usdOrNA(p.entryPrice)}</td><td>\${usdOrNA(p.markPrice)}</td><td>\${(p.liquidationPrice==null||p.liquidationPrice==='N/A')?'-':'$'+fmt(p.liquidationPrice)}</td><td style="color:var(--muted)">\${usdOrNA(notional)}</td><td class="\${pnlClass(p.unrealizedPnl)}">\${pnlOrNA(p.unrealizedPnl)}</td><td class="\${pnlClass(p.unrealizedPnl)}">\${roe==null?NA:(roe>=0?'+':'')+fmt(roe,1)+'%'}</td><td>\${p.leverage}x</td></tr>\`;
       }).join('')}</tbody></table>\`:(posKnown?'<div class="empty-msg">No open positions</div>':'<div class="empty-msg">Positions '+NA+'</div>')}
       <div class="section-title">Open Orders (\${ordKnown ? filteredOrders.length : '?'})</div>
       \${filteredOrders.length?\`<table><thead><tr>\${isHL?'<th>DEX</th>':''}<th>Symbol</th><th>Side</th><th>Type</th><th>Price</th><th>Size</th><th>Filled</th><th>Status</th></tr></thead><tbody>\${filteredOrders.map(o=>{
         const dex = getDex(o.symbol);
         const sym = o.symbol.includes(':') ? o.symbol.split(':').slice(1).join(':') : o.symbol;
-        return \`<tr>\${isHL?\`<td style="color:var(--purple);font-size:11px">\${dex}</td>\`:''}<td>\${sym}</td><td class="side-\${o.side}">\${o.side.toUpperCase()}</td><td>\${o.type}</td><td>$\${fmt(o.price)}</td><td>\${o.size}</td><td>\${o.filled}</td><td>\${o.status}</td></tr>\`;
+        return \`<tr>\${isHL?\`<td style="color:var(--purple);font-size:11px">\${escHtml(dex)}</td>\`:''}<td>\${escHtml(sym)}</td><td class="side-\${escHtml(o.side)}">\${escHtml(String(o.side).toUpperCase())}</td><td>\${escHtml(o.type)}</td><td>$\${fmt(o.price)}</td><td>\${escHtml(o.size)}</td><td>\${escHtml(o.filled)}</td><td>\${escHtml(o.status)}</td></tr>\`;
       }).join('')}</tbody></table>\`:(ordKnown?'<div class="empty-msg">No open orders</div>':'<div class="empty-msg">Open orders '+NA+'</div>')}
       <div class="section-title">Markets (Top 10)</div>
-      \${ex.topMarkets.length?\`<table><thead><tr><th>Symbol</th><th>Mark</th><th>Index</th><th>Funding</th><th>24h Vol</th><th>OI</th><th>Max Lev</th></tr></thead><tbody>\${ex.topMarkets.map(m=>{const fr=Number(m.fundingRate);return\`<tr><td>\${m.symbol}</td><td>$\${fmt(m.markPrice)}</td><td>\${usdOrDash(m.indexPrice)}</td><td class="\${rateClass(fr)}">\${(fr*100).toFixed(4)}%</td><td>\${usdOrDash(m.volume24h,0)}</td><td>\${usdOrDash(m.openInterest,0)}</td><td>\${m.maxLeverage==null?'-':m.maxLeverage+'x'}</td></tr>\`;}).join('')}</tbody></table>\`:'<div class="empty-msg">No market data</div>'}
+      \${ex.topMarkets.length?\`<table><thead><tr><th>Symbol</th><th>Mark</th><th>Index</th><th>Funding</th><th>24h Vol</th><th>OI</th><th>Max Lev</th></tr></thead><tbody>\${ex.topMarkets.map(m=>{const fr=Number(m.fundingRate);const c=marketCells(m);return\`<tr><td>\${escHtml(m.symbol)}</td><td>\${c.mark}</td><td>\${c.index}</td><td class="\${rateClass(fr)}">\${c.funding}</td><td>\${c.volume}</td><td>\${c.oi}</td><td>\${m.maxLeverage==null?'-':m.maxLeverage+'x'}</td></tr>\`;}).join('')}</tbody></table>\`:'<div class="empty-msg">No market data</div>'}
     </div>\`;
   }).join('');
 
@@ -419,7 +422,7 @@ function renderArb() {
       const barColor = o.spreadAnnual>=50?'var(--green)':o.spreadAnnual>=20?'var(--yellow)':'var(--muted)';
       const bestMark = o.rates.reduce((best,r) => r.markPrice>0?r.markPrice:best, 0);
       return \`<tr>
-        <td style="font-weight:600">\${o.symbol}</td>
+        <td style="font-weight:600">\${escHtml(o.symbol)}</td>
         <td>
           <div class="\${spreadClass(o.spreadAnnual)}">\${fmt(o.spreadAnnual,1)}%</div>
           <div class="spread-bar"><div class="spread-bar-fill" style="width:\${barW}%;background:\${barColor}"></div></div>
@@ -514,7 +517,7 @@ function renderEvents() {
   if (!events.length) { el.innerHTML='<div class="empty-msg">Waiting for events...</div>'; return; }
   el.innerHTML = events.map(e => {
     const cls = e.isCrit?'crit':e.isWarn?'warn':'';
-    return \`<div class="event"><span class="event-time">\${e.time}</span> <span class="event-type \${cls}">[\${e.type}]</span> <span>\${e.exchange}</span> <span style="color:var(--muted)">\${JSON.stringify(e.data).slice(0,120)}</span></div>\`;
+    return \`<div class="event"><span class="event-time">\${e.time}</span> <span class="event-type \${cls}">[\${e.type}]</span> <span>\${escHtml(e.exchange)}</span> <span style="color:var(--muted)">\${escHtml(JSON.stringify(e.data).slice(0,120))}</span></div>\`;
   }).join('');
 }
 

package/dist/errors.d.ts

@@ -320,3 +320,8 @@ export declare function unknownActionRemediation(venue: string, action: string):
  * and "1e3" are refused). Returns the trimmed string.
  */
 export declare function parsePositiveDecimal(raw: string, what: string): string;
+/**
+ * A keyless account read (positions, balance, orders, history): the one typed refusal every venue
+ * returns — NO_SIGNER_AVAILABLE with the setup remediation (never an UNKNOWN 500).
+ */
+export declare function noAccountKeyError(venue: string): PerpError;

package/dist/errors.js

@@ -388,3 +388,13 @@ export function parsePositiveDecimal(raw, what) {
     }
     return s;
 }
+/**
+ * A keyless account read (positions, balance, orders, history): the one typed refusal every venue
+ * returns — NO_SIGNER_AVAILABLE with the setup remediation (never an UNKNOWN 500).
+ */
+export function noAccountKeyError(venue) {
+    return new PerpError("NO_SIGNER_AVAILABLE", `${venue}: no account key configured — account data unavailable`, {
+        exchange: venue,
+        remediation: `Set up an account for ${venue}: perp setup (or perp -e ${venue} wallet show to check)`,
+    });
+}

package/dist/exchanges/address.d.ts

@@ -0,0 +1,8 @@
+export type AddressKind = "evm" | "solana";
+export declare function isEvmAddress(value: string): boolean;
+/** A base58 string that decodes to a 32-byte public key. */
+export declare function isSolanaAddress(value: string): boolean;
+/** Pacifica account / Print order / vault address: base58 32 bytes, else INVALID_PARAMS. */
+export declare function requireSolanaAddress(value: string, field?: string): string;
+/** `address` in the form `kind` expects (trimmed), else INVALID_PARAMS naming the expected form. */
+export declare function requireAddressOfKind(venue: string, kind: AddressKind, address: string): string;

package/dist/exchanges/address.js

@@ -0,0 +1,47 @@
+/**
+ * Public account address formats (keyless reads by address): EVM `0x` + 40 hex (Hyperliquid,
+ * Lighter) and base58 Solana public keys (Pacifica). A wrong format is refused with
+ * INVALID_PARAMS before any request — the venues answer a foreign address with an empty success
+ * (Pacifica `success: true, []`), which would read as "no positions".
+ */
+import bs58 from "bs58";
+import { PerpError } from "../errors.js";
+const EVM_RE = /^0x[0-9a-fA-F]{40}$/;
+export function isEvmAddress(value) {
+    return EVM_RE.test(value.trim());
+}
+/** A base58 string that decodes to a 32-byte public key. */
+export function isSolanaAddress(value) {
+    try {
+        return bs58.decode(value.trim()).length === 32;
+    }
+    catch {
+        return false;
+    }
+}
+/** Pacifica account / Print order / vault address: base58 32 bytes, else INVALID_PARAMS. */
+export function requireSolanaAddress(value, field = "address") {
+    const a = value.trim();
+    if (!isSolanaAddress(a)) {
+        throw new PerpError("INVALID_PARAMS", `Not a Solana (base58) ${field}: "${value}"${isEvmAddress(a) ? " — that is an EVM address; Pacifica accounts are Solana addresses" : ""}`, {
+            exchange: "pacifica", remediation: "Pass the base58 Solana address you use on Pacifica",
+        });
+    }
+    return a;
+}
+/** `address` in the form `kind` expects (trimmed), else INVALID_PARAMS naming the expected form. */
+export function requireAddressOfKind(venue, kind, address) {
+    const a = address.trim();
+    if (kind === "evm") {
+        if (isEvmAddress(a))
+            return a;
+        throw new PerpError("INVALID_PARAMS", `${venue} expects an EVM 0x address (0x + 40 hex)${isSolanaAddress(a) ? " — that is a Solana address" : ""}: "${address}"`, {
+            exchange: venue, remediation: `Pass the 0x address of the ${venue} account`,
+        });
+    }
+    if (isSolanaAddress(a))
+        return a;
+    throw new PerpError("INVALID_PARAMS", `${venue} expects a base58 Solana address${isEvmAddress(a) ? " — that is an EVM address" : ""}: "${address}"`, {
+        exchange: venue, remediation: `Pass the base58 Solana address of the ${venue} account`,
+    });
+}

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

@@ -22,7 +22,7 @@
  *   an `entryTpsl` bundle.
  */
 import type { EvmSigner } from "../../signer/interface.js";
-import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade, ExchangePublicTrade } from "../interface.js";
+import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade, ExchangePublicTrade, FundingHistoryRow } from "../interface.js";
 import type { ResolvedSlippage } from "../slippage.js";
 import { type TradingV2 } from "../trading-v2.js";
 import type { VenueCreateContext, VenueDefinition } from "../venue.js";
@@ -37,6 +37,8 @@ export declare const ARCUS_GOOD_TIL_HORIZON_MS: number;
 export declare const ARCUS_MAX_PROTECTION_DEVIATION = 0.1;
 /** clientId max (36) minus the "-tp"/"-sl" suffix of entryTpsl child legs. */
 export declare const ARCUS_TPSL_CLIENT_ID_MAX = 33;
+/** /v1/trades and /v1/fundingRates take `limit` ≤ 1000 (docs; the venue answered 1000 rows for more). */
+export declare const ARCUS_HISTORY_CAP = 1000;
 export declare class ArcusAdapter implements ExchangeAdapter, TradingV2 {
     readonly name: "arcus";
     readonly venue: VenueDefinition;
@@ -57,6 +59,12 @@ export declare class ArcusAdapter implements ExchangeAdapter, TradingV2 {
     private accountQuery;
     private loadMarkets;
     private market;
+    /**
+     * A market-data read (book / trades / funding / candles) of a listed market that is not ONLINE
+     * is refused like `market info` / `market list` treat it (not listed): SYMBOL_NOT_FOUND naming
+     * the venue status — the venue answered `[]` or HTTP 404 ORDER_NOT_FOUND for it before.
+     */
+    private onlineMarket;
     private symbolOf;
     /** Protection price: slippage from `ref`, aligned toward crossing on the tier tick, ≤ 10 % from `ref`. */
     private protectionPrice;
@@ -144,11 +152,7 @@ export declare class ArcusAdapter implements ExchangeAdapter, TradingV2 {
         asks: [string, string][];
     }>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangePublicTrade[]>;
-    getFundingHistory(symbol: string, limit?: number): Promise<{
-        time: number;
-        rate: string;
-        price: string | null;
-    }[]>;
+    getFundingHistory(symbol: string, limit?: number): Promise<FundingHistoryRow[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     private rawPositions;
     getBalance(): Promise<ExchangeBalance>;

package/dist/exchanges/arcus/adapter.js

@@ -22,6 +22,7 @@
  *   an `entryTpsl` bundle.
  */
 import { PerpError } from "../../errors.js";
+import { isArcusOnlineMarket } from "../../ws/arcus-market.js";
 import { OwsEvmSigner } from "../../signer/ows-evm.js";
 import { OwsSolanaSigner } from "../../signer/ows-solana.js";
 import { alignProtectionPrice, floorSize, mulDecimal, requirePositive, slippagePrice, subDecimal, toUnitsExact, unitsToString } from "../precision.js";
@@ -90,6 +91,15 @@ function finalityOf(s) {
     return s === "filled" || s === "rejected" || s === "cancelled" ? "final" : "pending";
 }
 const usToMs = (us) => Math.floor(us / 1000);
+/** /v1/trades and /v1/fundingRates take `limit` ≤ 1000 (docs; the venue answered 1000 rows for more). */
+export const ARCUS_HISTORY_CAP = 1000;
+function arcusLimit(what, limit) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > ARCUS_HISTORY_CAP) {
+        throw new PerpError("INVALID_PARAMS", `Arcus: ${what} limit must be 1..${ARCUS_HISTORY_CAP} (got ${limit})`, {
+            remediation: `Arcus serves at most ${ARCUS_HISTORY_CAP} rows per request`,
+        });
+    }
+}
 function sideLower(s) { return s === "BUY" ? "buy" : "sell"; }
 function tifFromRead(t) {
     // Reads report resting (GTT) orders as the legacy "GTC".
@@ -281,6 +291,21 @@ export class ArcusAdapter {
         }
         return m;
     }
+    /**
+     * A market-data read (book / trades / funding / candles) of a listed market that is not ONLINE
+     * is refused like `market info` / `market list` treat it (not listed): SYMBOL_NOT_FOUND naming
+     * the venue status — the venue answered `[]` or HTTP 404 ORDER_NOT_FOUND for it before.
+     */
+    async onlineMarket(symbol) {
+        const m = await this.market(symbol);
+        if (!isArcusOnlineMarket(m)) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Arcus: market ${m.marketDisplayName} is ${m.status} (not tradable; no live market data)`, {
+                exchange: "arcus", status: m.status, tradable: false,
+                remediation: "List live markets with: perp market list -e arcus",
+            });
+        }
+        return m;
+    }
     async symbolOf(marketId) {
         let m = (await this.loadMarkets(false)).byId.get(marketId);
         if (!m)
@@ -878,20 +903,22 @@ export class ArcusAdapter {
         return (await this.getVenueMarkets()).map(toLegacyMarketInfo);
     }
     async getOrderbook(symbol) {
-        const m = await this.market(symbol);
+        const m = await this.onlineMarket(symbol);
         const ob = await this.client.get(`/v1/l2OrderBook/${encodeURIComponent(m.marketDisplayName)}`, "l2OrderBook", { nLevels: ORDERBOOK_LEVELS });
         return { bids: ob.bids, asks: ob.asks };
     }
     async getRecentTrades(symbol, limit = 50) {
-        const m = await this.market(symbol);
+        arcusLimit("trades", limit);
+        const m = await this.onlineMarket(symbol);
         const res = await this.client.get("/v1/trades", "trades", { market: m.marketDisplayName, limit });
-        // Public tape carries no fee; "0" follows the legacy ExchangeTrade convention for public trades.
+        // Public tape: no fee applies to the viewer → null, never "0".
         return res.trades.map(t => ({ time: usToMs(t.timestamp), symbol: m.baseAsset, side: sideLower(t.side), price: t.price, size: t.size, fee: null }));
     }
     async getFundingHistory(symbol, limit = 100) {
-        const m = await this.market(symbol);
+        arcusLimit("funding history", limit);
+        const m = await this.onlineMarket(symbol);
         const res = await this.client.get("/v1/fundingRates", "fundingRates", { market: m.marketDisplayName, limit });
-        return res.fundingRates.map(f => ({ time: usToMs(f.time), rate: f.fundingRate, price: null }));
+        return res.fundingRates.map(f => ({ time: usToMs(f.time), rate: f.fundingRate, price: null, intervalHours: 1, rateKind: "lastSettled" }));
     }
     async getKlines(symbol, interval, startTime, endTime) {
         if (!CANDLE_TIMEFRAMES.has(interval)) {
@@ -899,7 +926,7 @@ export class ArcusAdapter {
                 remediation: `Use one of: ${[...CANDLE_TIMEFRAMES].join(", ")}`,
             });
         }
-        const m = await this.market(symbol);
+        const m = await this.onlineMarket(symbol);
         const span = CANDLE_WINDOW_BARS * CANDLE_MS[interval];
         const windows = Math.max(1, Math.ceil((endTime - startTime) / span));
         if (windows > CANDLE_MAX_WINDOWS) {

package/dist/exchanges/arcus/public.js

@@ -24,6 +24,7 @@
  * - tradable: status === "ONLINE".
  */
 import { PerpError } from "../../errors.js";
+import { isArcusOnlineMarket } from "../../ws/arcus-market.js";
 import { canonicalFor } from "../canonical-symbols.js";
 import { arcusVenue } from "../venues/arcus.js";
 import { ArcusClient } from "./client.js";
@@ -101,7 +102,7 @@ export function toArcusVenueMarket(m) {
         maxLeverage: maxLeverageOf(m),
         marginTiers: null,
         session: sessionOf(m),
-        tradable: m.status === "ONLINE",
+        tradable: isArcusOnlineMarket(m),
     };
 }
 /**
@@ -110,7 +111,7 @@ export function toArcusVenueMarket(m) {
  * market / funding lists rather than listed at a $0 price and 0 % funding.
  */
 export function onlineArcusMarkets(raw) {
-    return raw.filter(m => m.status === "ONLINE");
+    return raw.filter(isArcusOnlineMarket);
 }
 async function fetchMarkets(net) {
     const raw = await fetchArcusRawMarkets(new ArcusClient(net, null));