perp-cli 0.14.3 → 0.16.0

package/dist/strategies/funding-arb.js

@@ -1,13 +1,15 @@
 import { assertCanClosePositions } from "../exchanges/trading-v2.js";
 import { MAX_PRICE_DEVIATION_PCT } from "../exchanges/index.js";
-import { symbolMatch, logSettledRejections } from "../utils.js";
+import { symbolMatch } from "../utils.js";
 import { logExecution } from "../execution-log.js";
 import { updateJobState } from "../jobs.js";
 import { invalidateCache } from "../cache.js";
 import { fetchBalancesWithFailures, computeRebalancePlan, hasEnoughBalance, marketLeverageOf, requiredArbMargin } from "../rebalance.js";
 import { checkArbLiquidity } from "../liquidity.js";
-import { computeAnnualSpread } from "../funding.js";
-import { fetchPacificaPrices, fetchHyperliquidMeta, fetchLighterOrderBookDetails, fetchLighterFundingRates, } from "../shared-api.js";
+import { computeAnnualSpread, getFundingHours } from "../funding.js";
+import { fetchVenuesRates } from "../funding/rates.js";
+import { getVenue } from "../exchanges/venue.js";
+import { sharedApiNetwork } from "../api/public/urls.js";
 import { computeMatchedSize } from "../arb-sizing.js";
 import { closePerpPairVerified, openPerpPairVerified } from "../commands/arb-auto.js";
 import { closePerpVerified, isOutcomeUnknown } from "../bot/perp-order.js";
@@ -21,58 +23,21 @@ async function sizeDecimalsOf(adapter, symbol) {
     return m === undefined ? null : m.sizeDecimals;
 }
 async function fetchAllRates() {
-    // SSOT rule #2: each DEX is independent. allSettled keeps the comparison
-    // alive when one DEX errors out, while rejection reasons get logged to
-    // stderr (explicit failure, never silent).
-    const [pacRates, hlRates, ltRates] = await Promise.allSettled([
-        fetchPacificaPrices().then(assets => assets.map(p => ({
-            exchange: "pacifica", symbol: p.symbol, fundingRate: p.funding, markPrice: p.mark,
-        }))),
-        fetchHyperliquidMeta().then(assets => assets.map(a => ({
-            exchange: "hyperliquid", symbol: a.symbol, fundingRate: a.funding, markPrice: a.markPx,
-        }))),
-        (async () => {
-            const [details, funding] = await Promise.all([
-                fetchLighterOrderBookDetails(),
-                fetchLighterFundingRates(),
-            ]);
-            const priceMap = new Map(details.map(d => [d.marketId, d.lastTradePrice]));
-            const symMap = new Map(details.map(d => [d.marketId, d.symbol]));
-            const out = [];
-            for (const fr of funding) {
-                const symbol = fr.symbol || symMap.get(fr.marketId) || "";
-                if (!symbol)
-                    continue;
-                // Prefer fr.markPrice; fall back to orderBook last-trade as documented
-                // price source preference (NOT an error fallback).
-                const directMark = fr.markPrice;
-                const fallbackMark = priceMap.get(fr.marketId);
-                let markPrice;
-                if (directMark !== null && Number.isFinite(directMark) && directMark > 0) {
-                    markPrice = directMark;
-                }
-                else if (fallbackMark !== undefined && Number.isFinite(fallbackMark) && fallbackMark > 0) {
-                    markPrice = fallbackMark;
-                }
-                // SSOT rule #2: skip rows whose mark price cannot be resolved at all
-                // — never publish a 0 mark price downstream.
-                if (markPrice === undefined)
-                    continue;
-                out.push({ exchange: "lighter", symbol, fundingRate: fr.rate, markPrice });
-            }
-            return out;
-        })(),
-    ]);
-    logSettledRejections([pacRates, hlRates, ltRates], ["pacifica", "hyperliquid", "lighter"], "funding-arb");
-    return [
-        ...(pacRates.status === "fulfilled" ? pacRates.value : []),
-        ...(hlRates.status === "fulfilled" ? hlRates.value : []),
-        ...(ltRates.status === "fulfilled" ? ltRates.value : []),
-    ];
+    // The SAME rate rows as `arb scan --rates` (fetchVenuesRates): one per venue and canonical
+    // symbol (unclassified / ambiguous tickers have no canonical and never pair). Each venue is
+    // independent; a failed one is reported on stderr (explicit, never silent).
+    const venues = ["pacifica", "hyperliquid", "lighter"].map(id => getVenue(id));
+    const { rates: fetched, exchangeErrors } = await fetchVenuesRates(venues, sharedApiNetwork(), false);
+    // Never a leg on an unverified rate (row label; the venue filter already drops them).
+    const rates = fetched.filter(r => r.fundingVerified);
+    for (const [ex, msg] of Object.entries(exchangeErrors))
+        process.stderr.write(`[funding-arb] ${ex}: funding rates unavailable — ${msg}\n`);
+    // computeAnnualSpread / toHourlyRate normalize with the venue's basis: keep each rate in it.
+    return rates.map(r => ({ exchange: r.exchange, symbol: r.canonical, venueSymbol: r.symbol, fundingRate: r.hourlyRate * getFundingHours(r.exchange), markPrice: r.markPrice }));
 }
 // annualize: use computeAnnualSpread from funding.ts for cross-exchange comparison
 /**
- * `perp strategy funding-arb` loop. With autoExecute (design §12.3):
+ * `perp strategy funding-arb` loop. With autoExecute:
  *  - entry = openPerpPairVerified (long, then the short sized to the long's VERIFIED fill;
  *    definite short failure → reduce-only rollback; unknown outcome → quarantine). A lot-size
  *    rejection is never resubmitted blindly: the long is re-sized only when it was definitely
@@ -111,8 +76,12 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                 const rates = await fetchAllRates();
                 // Group by symbol
                 const rateMap = new Map();
+                // --symbols selects an asset by its canonical key or any venue's own symbol (kPEPE selects
+                // the whole 1000PEPE group, Lighter's leg included).
+                const want = new Set((params.symbols ?? []).map(s => s.toUpperCase()));
+                const wanted = new Set(rates.filter(r => want.has(r.symbol.toUpperCase()) || want.has(r.venueSymbol.toUpperCase())).map(r => r.symbol));
                 for (const r of rates) {
-                    if (params.symbols?.length && !params.symbols.includes(r.symbol))
+                    if (want.size > 0 && !wanted.has(r.symbol))
                         continue;
                     if (!rateMap.has(r.symbol))
                         rateMap.set(r.symbol, []);
@@ -233,6 +202,8 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                         if (annualSpread >= params.minSpread) {
                             const longEx = lowest.exchange;
                             const shortEx = highest.exchange;
+                            const longSym = lowest.venueSymbol;
+                            const shortSym = highest.venueSymbol;
                             log(`[ARB] ENTRY signal: ${symbol} spread ${annualSpread.toFixed(1)}% — long ${longEx} (${(lowest.fundingRate * 100).toFixed(4)}%) / short ${shortEx} (${(highest.fundingRate * 100).toFixed(4)}%)`);
                             if (params.autoExecute) {
                                 const longAdapter = adapters.get(longEx);
@@ -243,7 +214,7 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                 }
                                 // Check orderbook liquidity & adjust size
                                 const requestedUsd = params.sizeUsd ?? Number(params.size) * highest.markPrice;
-                                const liq = await checkArbLiquidity(longAdapter, shortAdapter, symbol, requestedUsd, 0.5, log);
+                                const liq = await checkArbLiquidity(longAdapter, shortAdapter, longSym, requestedUsd, 0.5, log, shortSym);
                                 if (!liq.viable)
                                     continue;
                                 // Compute matched size (same for both legs) at each venue's published size precision —
@@ -251,7 +222,7 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                 let longDec;
                                 let shortDec;
                                 try {
-                                    [longDec, shortDec] = await Promise.all([sizeDecimalsOf(longAdapter, symbol), sizeDecimalsOf(shortAdapter, symbol)]);
+                                    [longDec, shortDec] = await Promise.all([sizeDecimalsOf(longAdapter, longSym), sizeDecimalsOf(shortAdapter, shortSym)]);
                                 }
                                 catch (e) {
                                     log(`[ARB] Skip ${symbol}: could not read the market size precision (${e instanceof Error ? e.message : String(e)})`);
@@ -272,7 +243,7 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                     let longLev;
                                     let shortLev;
                                     try {
-                                        [longLev, shortLev] = await Promise.all([marketLeverageOf(longAdapter, symbol), marketLeverageOf(shortAdapter, symbol)]);
+                                        [longLev, shortLev] = await Promise.all([marketLeverageOf(longAdapter, longSym), marketLeverageOf(shortAdapter, shortSym)]);
                                     }
                                     catch (e) {
                                         log(`[ARB] Skip ${symbol}: could not read the market leverage (${e instanceof Error ? e.message : String(e)})`);
@@ -288,8 +259,8 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                 log(`[ARB] Opening: ${matched.size} ${symbol} — long ${longEx} then short ${shortEx}, each verified ($${matched.notional.toFixed(0)}/leg, slippage ~${liq.longSlippage.toFixed(2)}%/${liq.shortSlippage.toFixed(2)}%)...`);
                                 const openPair = (size) => openPerpPairVerified({
                                     source: SOURCE, sym: symbol,
-                                    longAdapter, longExch: longEx, longSym: symbol,
-                                    shortAdapter, shortExch: shortEx, shortSym: symbol,
+                                    longAdapter, longExch: longEx, longSym,
+                                    shortAdapter, shortExch: shortEx, shortSym,
                                     size, smart: false, log, shortLotRetry: true,
                                 });
                                 let res = await openPair(matched.size);
@@ -323,6 +294,8 @@ export async function runFundingArb(adapters, params, jobId, log = console.log)
                                     entrySpread: annualSpread,
                                     openedAt: Date.now(),
                                     entryPrices: { long: lowest.markPrice, short: highest.markPrice },
+                                    longSymbol: longSym,
+                                    shortSymbol: shortSym,
                                 });
                                 // Entry record: `arb status` / `arb close` confirm this pair from it (arbPairProvenance).
                                 logExecution({
@@ -403,8 +376,8 @@ async function closeArbPosition(pos, adapters, log) {
     let shortSize;
     try {
         [longSize, shortSize] = await Promise.all([
-            venueLegSize(longAdapter, pos.symbol, "long").then(cap),
-            venueLegSize(shortAdapter, pos.symbol, "short").then(cap),
+            venueLegSize(longAdapter, pos.longSymbol, "long").then(cap),
+            venueLegSize(shortAdapter, pos.shortSymbol, "short").then(cap),
         ]);
     }
     catch (err) {
@@ -418,8 +391,8 @@ async function closeArbPosition(pos, adapters, log) {
     if (longSize !== null && shortSize !== null) {
         const res = await closePerpPairVerified({
             source: SOURCE, sym: pos.symbol,
-            longAdapter, longExch: pos.longExchange, longSym: pos.symbol, longSize,
-            shortAdapter, shortExch: pos.shortExchange, shortSym: pos.symbol, shortSize,
+            longAdapter, longExch: pos.longExchange, longSym: pos.longSymbol, longSize,
+            shortAdapter, shortExch: pos.shortExchange, shortSym: pos.shortSymbol, shortSize,
             smart: false, log,
         });
         if (res.status === "closed") {
@@ -448,7 +421,7 @@ async function closeArbPosition(pos, adapters, log) {
         return false;
     };
     try {
-        const c = await closePerpVerified(adapter, venue, pos.symbol, side, size);
+        const c = await closePerpVerified(adapter, venue, leg === "long" ? pos.longSymbol : pos.shortSymbol, side, size);
         if (c.residual > 0)
             return q(`orphaned ${leg} close on ${venue} closed ${c.closed} of ${size}, ${c.residual} still open${c.note !== null ? ` (${c.note})` : ""}`);
     }

package/dist/trade-validator.js

@@ -12,7 +12,7 @@ export async function validateTrade(adapter, params) {
     const checks = [];
     const warnings = [];
     const sym = params.symbol.toUpperCase();
-    // Liquidity threshold = the bound a market order on this venue would carry (design §13.10 #14).
+    // Liquidity threshold = the bound a market order on this venue would carry.
     const maxSlippage = resolveAdapterSlippage(adapter, null).bps / 10_000;
     // Fetch market list, balance, and positions in parallel.
     // Defer the orderbook call until symbol membership is confirmed so invalid
@@ -264,7 +264,7 @@ export async function enforceOrderRisk(adapter, p) {
         const markets = await adapter.getMarkets();
         const m = markets.find((mk) => symbolMatch(mk.symbol, p.symbol));
         if (!m) {
-            throw new PerpError("SYMBOL_NOT_FOUND", `${p.symbol} not found on ${adapter.name}`, { exchange: adapter.name });
+            throw new PerpError("SYMBOL_NOT_FOUND", `${p.symbol} not found on ${adapter.name}`, { exchange: adapter.name, remediation: `List markets: perp -e ${adapter.name} market list` });
         }
         price = Number(m.markPrice);
     }

package/dist/utils.d.ts

@@ -1,6 +1,11 @@
 import type { OrderResult } from "./exchanges/venue-types.js";
 export declare function symbolMatch(candidate: string, target: string): boolean;
 export declare function formatUsd(value: string | number): string;
+/**
+ * Symbol argument as typed, normalized for display and lookup: upper case, except a HIP-3 dex
+ * prefix, which is lower case on the venue ("xyz:xyz100" / "XYZ:XYZ100" → "xyz:XYZ100").
+ */
+export declare function normalizeSymbolArg(symbol: string): string;
 export declare function formatPnl(value: string | number): string;
 export declare function formatPercent(value: string | number): string;
 export declare function makeTable(head: string[], rows: string[][]): string;
@@ -26,6 +31,20 @@ export interface ApiResponse<T = unknown> {
         exchange?: string;
         timestamp: string;
         duration_ms?: number;
+        skippedRows?: {
+            count: number;
+            reason: string;
+        }; /** Why a value is null / degraded (e.g. a venue's funding rate unavailable). */
+        warnings?: string[]; /** `arb scan --rates`: the --min threshold (annualized %) and how many pairs it hid. */
+        minSpread?: number;
+        belowMinSpread?: number; /** Public-address reads (`account positions --address`): the address read, "public", the sub-reads that failed and notes on an empty answer. */
+        address?: string;
+        source?: "public";
+        errors?: Record<string, {
+            code: string;
+            message: string;
+        }>;
+        notes?: string[];
     };
 }
 /** Wrap successful result in standard envelope */
@@ -50,18 +69,18 @@ export declare function withJsonErrors<T>(isJson: boolean, fn: () => Promise<T>,
 /**
  * Central CLI error printer. JSON: the structured envelope incl. details and
  * remediation. Human: the uniform "not supported" line for CAPABILITY_UNSUPPORTED
- * (design §13.6) — `✗ <Venue>: <feature> not supported — <reason>. Alternative: <remediation>` —
+ * — `✗ <Venue>: <feature> not supported — <reason>. Alternative: <remediation>` —
  * otherwise `Error: <message>` plus the remediation.
  */
 export declare function printCliError(err: unknown, isJson: boolean, exchange?: string): void;
 /**
- * JSON payload of an order result (design §13.7): the uniform OrderResult (+ execution)
+ * JSON payload of an order result: the uniform OrderResult (+ execution)
  * with the venue's raw response duplicated under `legacy` for one release.
  */
 export declare function orderResultJson(r: OrderResult & {
     remediation?: string | null;
 }, extra?: Record<string, unknown>): Record<string, unknown>;
-/** Human lines for an order result — one format for every venue (design §13.7). */
+/** Human lines for an order result — one format for every venue. */
 export declare function formatOrderResult(r: OrderResult & {
     remediation?: string | null;
 }): string[];

package/dist/utils.js

@@ -30,6 +30,14 @@ export function formatUsd(value) {
         maximumFractionDigits: maxDecimals,
     });
 }
+/**
+ * Symbol argument as typed, normalized for display and lookup: upper case, except a HIP-3 dex
+ * prefix, which is lower case on the venue ("xyz:xyz100" / "XYZ:XYZ100" → "xyz:XYZ100").
+ */
+export function normalizeSymbolArg(symbol) {
+    const i = symbol.indexOf(":");
+    return i === -1 ? symbol.toUpperCase() : `${symbol.slice(0, i).toLowerCase()}:${symbol.slice(i + 1).toUpperCase()}`;
+}
 export function formatPnl(value) {
     const num = Number(value);
     if (isNaN(num))
@@ -235,7 +243,7 @@ export async function withJsonErrors(isJson, fn, exchange) {
 /**
  * Central CLI error printer. JSON: the structured envelope incl. details and
  * remediation. Human: the uniform "not supported" line for CAPABILITY_UNSUPPORTED
- * (design §13.6) — `✗ <Venue>: <feature> not supported — <reason>. Alternative: <remediation>` —
+ * — `✗ <Venue>: <feature> not supported — <reason>. Alternative: <remediation>` —
  * otherwise `Error: <message>` plus the remediation.
  */
 export function printCliError(err, isJson, exchange) {
@@ -262,13 +270,13 @@ export function printCliError(err, isJson, exchange) {
     }
 }
 /**
- * JSON payload of an order result (design §13.7): the uniform OrderResult (+ execution)
+ * JSON payload of an order result: the uniform OrderResult (+ execution)
  * with the venue's raw response duplicated under `legacy` for one release.
  */
 export function orderResultJson(r, extra) {
     return { ...r, ...extra, legacy: r.venueRaw };
 }
-/** Human lines for an order result — one format for every venue (design §13.7). */
+/** Human lines for an order result — one format for every venue. */
 export function formatOrderResult(r) {
     const lines = [];
     const statusColor = r.status === "filled" ? chalk.green

package/dist/venue-health.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Venue connectivity probe — the one implementation behind `perp health`,
+ * `perp portfolio --health` and the MCP `health_check` tool.
+ *
+ * Pacifica / Hyperliquid / Lighter / Aster / QFEX / GRVT: a REST ping (status = HTTP status, 0 = no
+ * response). Every other venue — including read-only (market-data-only) venues such as TxFlow —
+ * is probed with its public market-data read (status null). A venue with no environment on the
+ * selected network (TxFlow has no testnet) is not probed and is listed in `skipped`.
+ *
+ * The ping helpers (shared-api) read the shared API URLs, which follow the network the caller
+ * selected (setSharedApiNetwork); Aster / QFEX / market-data probes take `network` directly.
+ */
+import type { Network, VenueId } from "./exchanges/venue-types.js";
+import "./exchanges/venues/index.js";
+export interface VenueProbe {
+    venue: VenueId;
+    ok: boolean;
+    latencyMs: number;
+    /** HTTP status of a REST ping (0 = no response); null for a market-data probe. */
+    status: number | null;
+    /** null when ok. */
+    error: string | null;
+    probe: "ping" | "markets";
+    /** "unofficial" = the venue is read through an undocumented API (VenueDefinition.apiStatus). */
+    apiStatus: "official" | "unofficial";
+}
+export interface VenueHealth {
+    probes: VenueProbe[];
+    /** Venues requested but not probed: no environment on `network`. */
+    skipped: Array<{
+        venue: VenueId;
+        reason: string;
+    }>;
+    allHealthy: boolean;
+}
+/**
+ * Probe `venueIds` (default: every registered venue) on `network`, in parallel. Never throws for a
+ * venue failure — each failure is a probe with ok:false and its message.
+ */
+export declare function probeVenueHealth(network: Network, venueIds?: readonly string[]): Promise<VenueHealth>;

package/dist/venue-health.js

@@ -0,0 +1,75 @@
+/**
+ * Venue connectivity probe — the one implementation behind `perp health`,
+ * `perp portfolio --health` and the MCP `health_check` tool.
+ *
+ * Pacifica / Hyperliquid / Lighter / Aster / QFEX / GRVT: a REST ping (status = HTTP status, 0 = no
+ * response). Every other venue — including read-only (market-data-only) venues such as TxFlow —
+ * is probed with its public market-data read (status null). A venue with no environment on the
+ * selected network (TxFlow has no testnet) is not probed and is listed in `skipped`.
+ *
+ * The ping helpers (shared-api) read the shared API URLs, which follow the network the caller
+ * selected (setSharedApiNetwork); Aster / QFEX / market-data probes take `network` directly.
+ */
+import { extractErrorMessage } from "./errors.js";
+import { getVenue, listVenues, networkConfig } from "./exchanges/venue.js";
+import { pingHyperliquid, pingLighter, pingPacifica } from "./shared-api.js";
+import "./exchanges/venues/index.js";
+async function timed(probe, fn) {
+    const start = Date.now();
+    try {
+        const r = await fn();
+        return { ok: r.ok, latencyMs: Date.now() - start, status: r.status, error: r.ok ? null : `HTTP ${r.status}`, probe };
+    }
+    catch (e) {
+        return { ok: false, latencyMs: Date.now() - start, status: probe === "ping" ? 0 : null, error: extractErrorMessage(e), probe };
+    }
+}
+const restPing = (url) => timed("ping", async () => {
+    const res = await fetch(url);
+    return { ok: res.ok, status: res.status };
+});
+/** shared-api helpers report a transport failure as status 0 with no message. */
+const helperPing = (fn) => async () => {
+    const r = await fn();
+    return { ...r, error: r.ok ? null : r.status === 0 ? "no response" : `HTTP ${r.status}`, probe: "ping" };
+};
+function pingFor(id, network) {
+    switch (id) {
+        case "pacifica": return helperPing(pingPacifica);
+        case "hyperliquid": return helperPing(pingHyperliquid);
+        case "lighter": return helperPing(pingLighter);
+        case "aster": return () => restPing(`${networkConfig(getVenue("aster"), network).restUrl}/fapi/v1/time`);
+        // QFEX: public GET /refdata for one instrument.
+        case "qfex": return () => restPing(`${networkConfig(getVenue("qfex"), network).restUrl}/refdata?ticker=AAPL-USD`);
+        // GRVT: one public instrument read (the market-data probe would fan out over every ticker).
+        case "grvt": return () => timed("ping", async () => {
+            const res = await fetch(`${networkConfig(getVenue("grvt"), network).restUrl}/full/v1/instrument`, {
+                method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ instrument: "BTC_USDT_Perp" }),
+            });
+            return { ok: res.ok, status: res.status };
+        });
+        default: return null;
+    }
+}
+/**
+ * Probe `venueIds` (default: every registered venue) on `network`, in parallel. Never throws for a
+ * venue failure — each failure is a probe with ok:false and its message.
+ */
+export async function probeVenueHealth(network, venueIds) {
+    const defs = venueIds === undefined ? listVenues() : venueIds.map(id => getVenue(id));
+    const skipped = [];
+    const probed = defs.filter(v => {
+        if (v.networks[network] !== null)
+            return true;
+        skipped.push({ venue: v.id, reason: `${v.displayName} has no ${network} environment` });
+        return false;
+    });
+    const results = await Promise.all(probed.map(v => {
+        const ping = pingFor(v.id, network);
+        return ping !== null
+            ? ping()
+            : timed("markets", async () => { await v.publicData.fetchMarkets(network, { funding: false }); return { ok: true, status: null }; });
+    }));
+    const probes = probed.map((v, i) => ({ venue: v.id, ...results[i], apiStatus: v.apiStatus.kind }));
+    return { probes, skipped, allHealthy: probes.every(p => p.ok) };
+}

package/dist/withdraw-gate.d.ts

@@ -1,6 +1,6 @@
 /**
  * Withdraw gate for venues whose withdrawals are authorized by an API key alone — no owner
- * signature (settings.withdraw.<venue>; today: qfex). Design §14.12 #8.
+ * signature (settings.withdraw.<venue>; today: qfex)..
  *
  * Before such a withdrawal is sent it must pass, locally:
  *   1. a gate is configured at all (absent → refused);

package/dist/withdraw-gate.js

@@ -1,6 +1,6 @@
 /**
  * Withdraw gate for venues whose withdrawals are authorized by an API key alone — no owner
- * signature (settings.withdraw.<venue>; today: qfex). Design §14.12 #8.
+ * signature (settings.withdraw.<venue>; today: qfex)..
  *
  * Before such a withdrawal is sent it must pass, locally:
  *   1. a gate is configured at all (absent → refused);

package/dist/ws/arcus-market.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Arcus GET /v1/markets eligibility — the one rule for every Arcus surface (WS directory, CLI
+ * adapter market-data reads, public market data / funding / arb, MCP): a market is listed only
+ * while `status` is "ONLINE". OFFLINE markets (live 2026-10-19: F, BAC, CCL, VT, SGOV, RVI-USD —
+ * 6 of 70) publish placeholder zeros for mark / index / rate / OI / volume, never real values.
+ */
+export declare function isArcusOnlineMarket(row: {
+    status?: unknown;
+}): boolean;

package/dist/ws/arcus-market.js

@@ -0,0 +1,9 @@
+/**
+ * Arcus GET /v1/markets eligibility — the one rule for every Arcus surface (WS directory, CLI
+ * adapter market-data reads, public market data / funding / arb, MCP): a market is listed only
+ * while `status` is "ONLINE". OFFLINE markets (live 2026-10-19: F, BAC, CCL, VT, SGOV, RVI-USD —
+ * 6 of 70) publish placeholder zeros for mark / index / rate / OI / volume, never real values.
+ */
+export function isArcusOnlineMarket(row) {
+    return row.status === "ONLINE";
+}

package/dist/ws/aster-market.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Aster GET /fapi/v3/exchangeInfo market eligibility — the one rule for every Aster surface (WS
+ * directory, CLI adapter, public market data / funding / arb, MCP): a market is listed only while
+ * `contractType` is "PERPETUAL" and `status` is "TRADING". Live 2026-10-19: TRADING/PERPETUAL 605,
+ * SETTLING/PERPETUAL 23 (being delisted: TONUSDT, IRUSDT, …), PENDING_TRADING with contractType ""
+ * 6 (MBLUSDT, AFEEUSDT, …) — neither of the latter two streams or trades.
+ *
+ * The quote asset is NOT part of eligibility: USD1 / U quoted perps are live markets, listed by
+ * every surface (asterCliSymbol gives the CLI symbol, asterMatchable whether it gets a canonical).
+ */
+export declare function isAsterListedPerpetual(row: {
+    contractType?: unknown;
+    status?: unknown;
+}): boolean;
+/**
+ * CLI symbol of a listed Aster perpetual: the base for the USDT-quoted market (ETHUSDT → ETH, the
+ * venue's main listing), the venue symbol for any other quote (BTCUSD1, BTCU) — unique per market
+ * and passed to the venue as is.
+ */
+export declare function asterCliSymbol(row: {
+    symbol: string;
+    baseAsset: string;
+    quoteAsset?: unknown;
+}): string;
+/**
+ * Whether a listed Aster market may carry a cross-venue canonical (then `base`): only its USDT
+ * market. USD1 / U quoted ones (BTCUSD1, GPROUSD1, BTCU) are listed but never matched across
+ * venues — so `arb` (scan / auto / exec) never takes one as a leg: Aster arb sizing, margin checks
+ * and transfers are USDT-collateral, and a USD1 / U margined leg is not handled.
+ */
+export declare function asterMatchable(row: {
+    quoteAsset?: unknown;
+}): boolean;

package/dist/ws/aster-market.js

@@ -0,0 +1,30 @@
+/**
+ * Aster GET /fapi/v3/exchangeInfo market eligibility — the one rule for every Aster surface (WS
+ * directory, CLI adapter, public market data / funding / arb, MCP): a market is listed only while
+ * `contractType` is "PERPETUAL" and `status` is "TRADING". Live 2026-10-19: TRADING/PERPETUAL 605,
+ * SETTLING/PERPETUAL 23 (being delisted: TONUSDT, IRUSDT, …), PENDING_TRADING with contractType ""
+ * 6 (MBLUSDT, AFEEUSDT, …) — neither of the latter two streams or trades.
+ *
+ * The quote asset is NOT part of eligibility: USD1 / U quoted perps are live markets, listed by
+ * every surface (asterCliSymbol gives the CLI symbol, asterMatchable whether it gets a canonical).
+ */
+export function isAsterListedPerpetual(row) {
+    return row.contractType === "PERPETUAL" && row.status === "TRADING";
+}
+/**
+ * CLI symbol of a listed Aster perpetual: the base for the USDT-quoted market (ETHUSDT → ETH, the
+ * venue's main listing), the venue symbol for any other quote (BTCUSD1, BTCU) — unique per market
+ * and passed to the venue as is.
+ */
+export function asterCliSymbol(row) {
+    return row.quoteAsset === "USDT" ? row.baseAsset : row.symbol;
+}
+/**
+ * Whether a listed Aster market may carry a cross-venue canonical (then `base`): only its USDT
+ * market. USD1 / U quoted ones (BTCUSD1, GPROUSD1, BTCU) are listed but never matched across
+ * venues — so `arb` (scan / auto / exec) never takes one as a leg: Aster arb sizing, margin checks
+ * and transfers are USDT-collateral, and a USD1 / U margined leg is not handled.
+ */
+export function asterMatchable(row) {
+    return row.quoteAsset === "USDT";
+}