perp-cli 0.12.17 → 0.14.1

package/dist/exchanges/venues/qfex.d.ts

@@ -0,0 +1,39 @@
+/**
+ * QFEX venue definition (design §14.1 as amended by §14.12).
+ *
+ * TradFi perpetuals (equities, indices, commodities; no spot) on a custodial, off-chain
+ * matching engine. All markets are cross-margin, margin asset USDC. Orders go over the Trade
+ * WebSocket only; account reads, leverage and transfers over REST; deposits / withdrawals over
+ * the separate "banker" host. Hot-path key = HMAC API key created on the QFEX website (2FA),
+ * stored in ~/.perp/qfex-agents/<publicKey>.json (SSOT Rule #3). There is no wallet signature.
+ * Not registered here; the registry module owns registerVenue().
+ */
+import type { VenueDefinition } from "../venue.js";
+import type { Network } from "../venue-types.js";
+/**
+ * Hosts per network. VenueNetworkConfig carries only two (rest + ws), so the MDS and banker
+ * hosts live here. Testnet = QFEX "UAT": "identical API and behaviour, separate exchange
+ * instance with no real funds" (official CLI README "Environments").
+ */
+export declare const QFEX_ENDPOINTS: Readonly<Record<Network, {
+    rest: string;
+    tradeWs: string;
+    mdsWs: string;
+    banker: string;
+}>>;
+/** Chain QFEX USDC deposits / withdrawals use in perp-cli (banker network ARBITRUM_ONE). */
+export declare const QFEX_WITHDRAW_NETWORK = "arbitrum";
+/**
+ * API withdrawals are switched off (owner decision 2026-10-13): `funds withdraw qfex` and
+ * QfexAdapter.withdraw refuse with CAPABILITY_UNSUPPORTED. The implementation (banker POST
+ * /withdraw behind settings.withdraw.qfex) is kept; flip this to re-enable it.
+ */
+export declare const QFEX_WITHDRAW_ENABLED: boolean;
+/** The uniform refusal while QFEX_WITHDRAW_ENABLED is false. */
+export declare const QFEX_WITHDRAW_DISABLED: {
+    readonly reason: "QFEX withdrawals are disabled in perp-cli for now";
+    readonly remediation: "Withdraw from the QFEX web app";
+};
+/** Banker `network` value for QFEX_WITHDRAW_NETWORK. */
+export declare const QFEX_BANKER_NETWORK = "ARBITRUM_ONE";
+export declare const qfexVenue: VenueDefinition;

package/dist/exchanges/venues/qfex.js

@@ -0,0 +1,140 @@
+/**
+ * QFEX venue definition (design §14.1 as amended by §14.12).
+ *
+ * TradFi perpetuals (equities, indices, commodities; no spot) on a custodial, off-chain
+ * matching engine. All markets are cross-margin, margin asset USDC. Orders go over the Trade
+ * WebSocket only; account reads, leverage and transfers over REST; deposits / withdrawals over
+ * the separate "banker" host. Hot-path key = HMAC API key created on the QFEX website (2FA),
+ * stored in ~/.perp/qfex-agents/<publicKey>.json (SSOT Rule #3). There is no wallet signature.
+ * Not registered here; the registry module owns registerVenue().
+ */
+import { BUILDER_FEE_CAPABILITIES } from "../builder-fee.js";
+import { QFEX_MODIFY_KEEPS_CLIENT_ID, QFEX_RESTING_REDUCE_ONLY_VERIFIED } from "../qfex/signing.js";
+/**
+ * Hosts per network. VenueNetworkConfig carries only two (rest + ws), so the MDS and banker
+ * hosts live here. Testnet = QFEX "UAT": "identical API and behaviour, separate exchange
+ * instance with no real funds" (official CLI README "Environments").
+ */
+export const QFEX_ENDPOINTS = {
+    mainnet: { rest: "https://api.qfex.com", tradeWs: "wss://trade.qfex.com", mdsWs: "wss://mds.qfex.com", banker: "https://banker.qfex.com" },
+    testnet: { rest: "https://api.qfex.io", tradeWs: "wss://trade.qfex.io", mdsWs: "wss://mds.qfex.io", banker: "https://banker.qfex.io" },
+};
+/** Chain QFEX USDC deposits / withdrawals use in perp-cli (banker network ARBITRUM_ONE). */
+export const QFEX_WITHDRAW_NETWORK = "arbitrum";
+/**
+ * API withdrawals are switched off (owner decision 2026-10-13): `funds withdraw qfex` and
+ * QfexAdapter.withdraw refuse with CAPABILITY_UNSUPPORTED. The implementation (banker POST
+ * /withdraw behind settings.withdraw.qfex) is kept; flip this to re-enable it.
+ */
+export const QFEX_WITHDRAW_ENABLED = false;
+/** The uniform refusal while QFEX_WITHDRAW_ENABLED is false. */
+export const QFEX_WITHDRAW_DISABLED = { reason: "QFEX withdrawals are disabled in perp-cli for now", remediation: "Withdraw from the QFEX web app" };
+/** Banker `network` value for QFEX_WITHDRAW_NETWORK. */
+export const QFEX_BANKER_NETWORK = "ARBITRUM_ONE";
+/** Lazy: public.ts (and `ws`) is only loaded when market data is actually requested. */
+const publicData = {
+    async fetchFundingRates(net) {
+        return (await import("../qfex/public.js")).qfexPublicData.fetchFundingRates(net);
+    },
+    async fetchMarkets(net) {
+        return (await import("../qfex/public.js")).qfexPublicData.fetchMarkets(net);
+    },
+};
+function network(net) {
+    return {
+        restUrl: QFEX_ENDPOINTS[net].rest,
+        wsUrl: QFEX_ENDPOINTS[net].tradeWs,
+        explorerUrl: null,
+        signingChainId: null,
+        settlementChain: "offchain",
+        collateral: ["USDC"],
+        collateralAssetIndex: null,
+        rpcUrl: null,
+        depositPins: null,
+    };
+}
+export const qfexVenue = {
+    id: "qfex",
+    aliases: ["qf"],
+    displayName: "QFEX",
+    family: "qfex",
+    // Custodial: there is no owner-wallet signing path at all.
+    masterKeyKind: "none",
+    agentKeyKind: "hmac",
+    secretStorage: { kind: "perp-keystore", dir: "qfex-agents" },
+    networks: { mainnet: network("mainnet"), testnet: network("testnet") },
+    // Docs /qfex/funding: settled every 60 minutes.
+    fundingRateBasis: { kind: "perHours", hours: 1 },
+    settlementIntervalHours: 1,
+    // Q4: the unit of `funding_rate` (and funding_rate vs next_funding_rate) is not verified
+    // against settled payments, and equity funding accrues only ~120 of 168 hours a week, so
+    // hourly × 8760 overstates it. Until both are settled QFEX is not a funding-arb venue.
+    fundingVerified: false,
+    roles: ["marketData", "account", "trading"],
+    capabilities: {
+        // The venue offers a native MARKET order (bounded only by the price band — docs /qfex/risk-limits
+        // "Dynamic price bands": 1.65%–10% by product preset and session; "integrations should use
+        // that live value rather than hardcoding a percentage"); the
+        // adapter sends every market order as an IOC LIMIT at the tick-aligned protection price
+        // (mark ± resolved slippage, design §13.2) — the same declaration as Ondo.
+        marketOrder: "native",
+        // ALO = order_type "ALO" + GTC.
+        timeInForce: ["GTC", "IOC", "FOK", "ALO"],
+        // Reduce-only (Q2, production 2026-10-05: `reduce_only` is a JSON boolean; rejected with no
+        // position, but an order larger than the position is accepted and RESTS at full size). The
+        // adapter enforces side and size against the live position before each send, which covers
+        // an immediate order only — a resting one is refused until match-time capping is proven
+        // (QFEX_RESTING_REDUCE_ONLY_VERIFIED, qfex/signing.ts).
+        reduceOnlyTif: QFEX_RESTING_REDUCE_ONLY_VERIFIED === true ? null : ["IOC"],
+        clientOrderId: true,
+        // The ACK arrives first; fills / rejections follow as separate events. Client order ids
+        // are GENERATED only (venue ids are not unique) — a user --client-id is refused.
+        orderAck: "async",
+        // Attached take_profit / stop_loss exists on add_order, but the stop quantity on a partial
+        // or zero-fill entry and the id of the resulting stop are unverified (Q7) → separate
+        // reduce-only TAKE_PROFIT / STOP_LOSS stop orders sized to the verified fill (Q21 passed on
+        // production 2026-10-12: the stop ACK echoes the client id — qfex/signing.ts QFEX_STOP_CLIENT_ID_ECHO).
+        tpsl: "separateOrders",
+        // modify_order returns a NEW order id; the MODIFIED frame keeps the client id (Q5, production
+        // 2026-10-12 — QFEX_MODIFY_KEEPS_CLIENT_ID) → native amend correlated by client id.
+        amend: QFEX_MODIFY_KEEPS_CLIENT_ID === true ? "native" : null,
+        batchPlaceMax: null,
+        marginModes: ["cross"],
+        // TRON USDT and USD bank rails are out of scope. API withdrawals are off (QFEX_WITHDRAW_ENABLED).
+        withdrawAssets: QFEX_WITHDRAW_ENABLED ? ["USDC"] : null,
+    },
+    // Venue budget: 12,000 weight / 60 s per USER across all connections and keys (general and
+    // cancel buckets separate). This process takes 25% (50/s, burst 100); the rest is left to the
+    // user's other processes, the QFEX web app and the official CLI. Weights: docs /websocket/rate.
+    rateLimit: {
+        capacity: 100,
+        refillPerSec: 50,
+        weights: {
+            add_order: 1, cancel_order: 1, modify_order: 1, get_order: 2, get_user_orders: 5, cancel_all_orders: 2,
+            get_user_trades: 0.5, subscribe: 0.1, unsubscribe: 0.1, set_user_leverage: 0.1, cancel_stop_order: 1,
+            modify_stop_order: 1,
+        },
+    },
+    // Docs /qfex/faq + prohibited-jurisdictions ("including but not limited to"). Warn-only.
+    restrictedRegions: ["US", "GB", "ES", "UA", "SY", "IR", "RU", "KP", "MM", "BY", "VE", "SD"],
+    symbolIdentity: "explicit",
+    publicData,
+    spot: null,
+    // Widest documented price band (equities at the open: 10%). The order's own band is checked before sending.
+    maxSlippageBps: 1000,
+    builderFee: BUILDER_FEE_CAPABILITIES["qfex"],
+    create: async (ctx) => {
+        const { QfexAdapter } = await import("../qfex/adapter.js");
+        const adapter = new QfexAdapter(qfexVenue, ctx);
+        // Builder code: only settings builder.qfex (off by default); no approval step. It rides on
+        // the connection's auth, so --no-builder / testnet use a session without it.
+        const { loadSettings } = await import("../../settings.js");
+        const { resolveBuilderGate } = await import("../builder-fee.js");
+        const settings = loadSettings();
+        adapter.builderFee = resolveBuilderGate("qfex", ctx, settings.builder, null, () => "");
+        // Withdraw gate (settings.withdraw.qfex): absent = withdraw() refuses.
+        const gate = settings.withdraw.qfex;
+        adapter.withdrawGate = gate === undefined ? null : gate;
+        return adapter;
+    },
+};

package/dist/execution-log.js

@@ -11,13 +11,21 @@ function genId() {
 }
 /** Append an execution record to the log */
 export function logExecution(record) {
-    ensureDir();
     const full = {
         id: genId(),
         timestamp: new Date().toISOString(),
         ...record,
     };
-    appendFileSync(LOG_FILE, JSON.stringify(full) + "\n", { mode: 0o600 });
+    // The log is a record OF an outcome, never part of it: a write failure (disk full, read-only
+    // home, permissions) must not turn a filled order into a thrown "failed" one. It is reported
+    // on stderr and the caller continues with the real result.
+    try {
+        ensureDir();
+        appendFileSync(LOG_FILE, JSON.stringify(full) + "\n", { mode: 0o600 });
+    }
+    catch (e) {
+        process.stderr.write(`[perp] Warning: could not write the execution log (${LOG_FILE}): ${e instanceof Error ? e.message : String(e)} — the ${record.type} on ${record.exchange} was recorded as "${record.status}" in memory only\n`);
+    }
     return full;
 }
 /** Read execution log with optional filters */

package/dist/funding/legacy-public.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Public market data for the legacy venues without a native `getVenueMarkets`
+ * (pacifica, hyperliquid core, aster) — design §10.6. Lighter uses
+ * exchanges/lighter-public.ts.
+ *
+ * Network-aware: the REST base comes from `legacyPublicBaseUrl(venue, net)`,
+ * never from the mutable `*_API_URL` globals. A network without a known public
+ * API throws NOT_IMPLEMENTED.
+ *
+ * FUNDING BASIS / SETTLEMENT
+ *   pacifica, hyperliquid: the venue definition (fundingBasisOf / settlementIntervalOf).
+ *   aster: per symbol from GET /fapi/v3/fundingInfo `fundingIntervalHours`
+ *     (live 2026-09-30: 1h/2h/4h/8h mixed). One quoted rate covers one interval,
+ *     so basis hours == settlement hours. A symbol missing from fundingInfo is
+ *     excluded with a warning (its period would be a guess).
+ *
+ * ASSET CLASS
+ *   hyperliquid core: crypto (HIP-3 dexes are not served here).
+ *   pacifica: crypto-centric; PACIFICA_NON_CRYPTO lists every non-crypto perp
+ *     listed on 2026-09-30.
+ *   aster: exchangeInfo `underlyingSubType` (STOCK / ETF / Commodities / pre-launch).
+ *   AMBIGUOUS tickers are excluded with a warning so they cannot produce a false
+ *   cross-venue match (SPX = the SPX6900 token, whose ticker equals the S&P 500
+ *   canonical key).
+ *
+ * Fields a venue does not publish on this path are null (HL has no fixed tick
+ * size; Aster leverage brackets need a signed call; Aster OI is per-symbol only).
+ */
+import type { VenuePublicData } from "../exchanges/venue.js";
+export type LegacyPublicVenue = "pacifica" | "hyperliquid" | "aster";
+export declare function legacyPublicData(venue: LegacyPublicVenue): VenuePublicData;

package/dist/funding/legacy-public.js

@@ -0,0 +1,369 @@
+/**
+ * Public market data for the legacy venues without a native `getVenueMarkets`
+ * (pacifica, hyperliquid core, aster) — design §10.6. Lighter uses
+ * exchanges/lighter-public.ts.
+ *
+ * Network-aware: the REST base comes from `legacyPublicBaseUrl(venue, net)`,
+ * never from the mutable `*_API_URL` globals. A network without a known public
+ * API throws NOT_IMPLEMENTED.
+ *
+ * FUNDING BASIS / SETTLEMENT
+ *   pacifica, hyperliquid: the venue definition (fundingBasisOf / settlementIntervalOf).
+ *   aster: per symbol from GET /fapi/v3/fundingInfo `fundingIntervalHours`
+ *     (live 2026-09-30: 1h/2h/4h/8h mixed). One quoted rate covers one interval,
+ *     so basis hours == settlement hours. A symbol missing from fundingInfo is
+ *     excluded with a warning (its period would be a guess).
+ *
+ * ASSET CLASS
+ *   hyperliquid core: crypto (HIP-3 dexes are not served here).
+ *   pacifica: crypto-centric; PACIFICA_NON_CRYPTO lists every non-crypto perp
+ *     listed on 2026-09-30.
+ *   aster: exchangeInfo `underlyingSubType` (STOCK / ETF / Commodities / pre-launch).
+ *   AMBIGUOUS tickers are excluded with a warning so they cannot produce a false
+ *   cross-venue match (SPX = the SPX6900 token, whose ticker equals the S&P 500
+ *   canonical key).
+ *
+ * Fields a venue does not publish on this path are null (HL has no fixed tick
+ * size; Aster leverage brackets need a signed call; Aster OI is per-symbol only).
+ */
+import { HL_MIN_ORDER_VALUE_USD } from "../constants.js";
+import { PerpError } from "../errors.js";
+import { venueRateString } from "../utils/numeric.js";
+import { assertOk } from "../api/public/_http.js";
+import { legacyPublicBaseUrl } from "../api/public/urls.js";
+import { canonicalFor } from "../exchanges/canonical-symbols.js";
+import { fundingBasisOf, settlementIntervalOf } from "../exchanges/venue.js";
+// ── Classification ──
+const AMBIGUOUS = new Set(["SPX"]);
+/** Pacifica non-crypto perps (live /info 2026-09-30). BP / CHIP: ticker collides with a listed equity/ETF. */
+const PACIFICA_NON_CRYPTO = {
+    NVDA: "equity", TSLA: "equity", GOOGL: "equity", PLTR: "equity", HOOD: "equity", CRCL: "equity",
+    SPCX: "equity", SKHYNIX: "equity", SAMSUNG: "equity", MSTR: "equity", MU: "equity", SNDK: "equity",
+    META: "equity",
+    DRAM: "etf", URNM: "etf",
+    XAU: "commodity", XAG: "commodity", CL: "commodity", COPPER: "commodity", NATGAS: "commodity",
+    PLATINUM: "commodity",
+    USDJPY: "fx", EURUSD: "fx",
+    SP500: "index",
+};
+const PACIFICA_AMBIGUOUS = new Set(["BP", "CHIP"]);
+function classifyPacifica(symbol) {
+    const up = symbol.toUpperCase();
+    if (AMBIGUOUS.has(up) || PACIFICA_AMBIGUOUS.has(up))
+        return null;
+    return PACIFICA_NON_CRYPTO[up] ?? "crypto"; // crypto-centric venue: non-crypto is listed explicitly
+}
+function classifyHyperliquid(symbol) {
+    return AMBIGUOUS.has(symbol.toUpperCase()) ? null : "crypto";
+}
+function classifyAster(symbol, subTypes) {
+    if (AMBIGUOUS.has(symbol.toUpperCase()))
+        return null;
+    if (subTypes.includes("pre-launch"))
+        return "preIpo";
+    if (subTypes.includes("ETF"))
+        return "etf";
+    if (subTypes.includes("STOCK"))
+        return "equity";
+    if (subTypes.includes("Commodities"))
+        return "commodity";
+    return "crypto";
+}
+function warnExcluded(venue, what, symbols) {
+    if (symbols.length > 0) {
+        console.warn(`[${venue}] excluded ${symbols.length} ${what}: ${symbols.join(", ")}`);
+    }
+}
+// ── HTTP ──
+async function getJson(venue, url, label, init) {
+    const res = await fetch(url, { ...init, signal: AbortSignal.timeout(15_000) });
+    await assertOk(res, `${venue} ${label}`);
+    const text = await res.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new PerpError("EXCHANGE_ERROR", `${venue} ${label}: invalid JSON`, { body: text.slice(0, 500) });
+    }
+}
+function arrayField(venue, label, v) {
+    if (!Array.isArray(v))
+        throw new PerpError("EXCHANGE_ERROR", `${venue} ${label}: expected an array`);
+    return v;
+}
+function numStr(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return String(v);
+    if (typeof v === "string" && v.length > 0 && Number.isFinite(Number(v)))
+        return v;
+    return null;
+}
+/** A funding rate field: a JSON number without float noise (venueRateString), a numeric string verbatim; else null. */
+function rateStr(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return venueRateString(v);
+    return numStr(v);
+}
+function positiveNumStr(v) {
+    const s = numStr(v);
+    return s !== null && Number(s) > 0 ? s : null;
+}
+function stepFromDecimals(d) {
+    return d === 0 ? "1" : `0.${"0".repeat(d - 1)}1`;
+}
+// ── Pacifica ──
+async function pacificaRows(net) {
+    const base = legacyPublicBaseUrl("pacifica", net);
+    const [infoJson, pricesJson] = await Promise.all([
+        getJson("pacifica", `${base}/info`, "info"),
+        getJson("pacifica", `${base}/info/prices`, "info/prices"),
+    ]);
+    const info = arrayField("pacifica", "info", infoJson.data);
+    const prices = arrayField("pacifica", "info/prices", pricesJson.data);
+    const priceBySymbol = new Map(prices.map(p => [String(p.symbol), p]));
+    const basis = fundingBasisOf("pacifica");
+    const settlement = settlementIntervalOf("pacifica");
+    const out = [];
+    const unclassified = [];
+    const unpriced = [];
+    for (const m of info) {
+        // /info lists spot markets too (e.g. SOL-USDC). A row without the field cannot be classified.
+        if (typeof m.instrument_type !== "string") {
+            throw new PerpError("EXCHANGE_ERROR", `Pacifica /info row ${String(m.symbol)} has no instrument_type`, { exchange: "pacifica" });
+        }
+        if (m.instrument_type === "spot")
+            continue;
+        const symbol = String(m.symbol ?? "");
+        const assetClass = classifyPacifica(symbol);
+        if (assetClass === null) {
+            unclassified.push(symbol);
+            continue;
+        }
+        const p = priceBySymbol.get(symbol);
+        const mark = p ? positiveNumStr(p.mark) : null;
+        if (!p || mark === null) {
+            unpriced.push(symbol);
+            continue;
+        }
+        const maxLeverage = Number(m.max_leverage);
+        out.push({
+            market: {
+                venue: "pacifica",
+                venueSymbol: symbol,
+                symbol,
+                canonical: canonicalFor("pacifica", symbol, assetClass),
+                assetClass,
+                settle: "USDC",
+                quoteAsset: null,
+                markPrice: mark,
+                indexPrice: positiveNumStr(p.oracle),
+                fundingRate: rateStr(p.next_funding),
+                fundingRateBasis: basis,
+                settlementIntervalHours: settlement,
+                openInterest: numStr(p.open_interest),
+                volume24h: numStr(p.volume_24h),
+                tickSize: positiveNumStr(m.tick_size),
+                stepSize: positiveNumStr(m.lot_size),
+                minSize: null,
+                minNotional: positiveNumStr(m.min_order_size),
+                maxLeverage: Number.isFinite(maxLeverage) && maxLeverage > 0 ? maxLeverage : null,
+                marginTiers: null,
+                session: null,
+                tradable: true,
+            },
+            nextFundingTime: null, // Pacifica publishes no next-funding timestamp
+        });
+    }
+    warnExcluded("pacifica", "unclassified/ambiguous market(s)", unclassified);
+    warnExcluded("pacifica", "market(s) without a mark price", unpriced);
+    return out;
+}
+// ── Hyperliquid core ──
+async function hyperliquidRows(net) {
+    const base = legacyPublicBaseUrl("hyperliquid", net);
+    const json = await getJson("hyperliquid", `${base}/info`, "info metaAndAssetCtxs", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ type: "metaAndAssetCtxs" }),
+    });
+    if (!Array.isArray(json) || json.length < 2) {
+        throw new PerpError("EXCHANGE_ERROR", "hyperliquid metaAndAssetCtxs: expected [meta, assetCtxs]");
+    }
+    const universe = arrayField("hyperliquid", "meta.universe", json[0].universe);
+    const ctxs = arrayField("hyperliquid", "assetCtxs", json[1]);
+    if (ctxs.length !== universe.length) {
+        throw new PerpError("EXCHANGE_ERROR", `hyperliquid metaAndAssetCtxs: ${universe.length} assets vs ${ctxs.length} contexts`);
+    }
+    const basis = fundingBasisOf("hyperliquid");
+    const settlement = settlementIntervalOf("hyperliquid");
+    const out = [];
+    const unclassified = [];
+    const unpriced = [];
+    universe.forEach((a, i) => {
+        const ctx = ctxs[i];
+        const symbol = String(a.name ?? "");
+        const assetClass = classifyHyperliquid(symbol);
+        if (assetClass === null) {
+            unclassified.push(symbol);
+            return;
+        }
+        const mark = positiveNumStr(ctx.markPx);
+        if (mark === null) {
+            unpriced.push(symbol);
+            return;
+        }
+        const szDecimals = Number(a.szDecimals);
+        const maxLeverage = Number(a.maxLeverage);
+        out.push({
+            market: {
+                venue: "hyperliquid",
+                venueSymbol: symbol,
+                symbol,
+                canonical: canonicalFor("hyperliquid", symbol, assetClass),
+                assetClass,
+                settle: "USDC",
+                quoteAsset: null,
+                markPrice: mark,
+                indexPrice: positiveNumStr(ctx.oraclePx),
+                fundingRate: rateStr(ctx.funding),
+                fundingRateBasis: basis,
+                settlementIntervalHours: settlement,
+                openInterest: numStr(ctx.openInterest),
+                volume24h: numStr(ctx.dayNtlVlm),
+                tickSize: null, // HL prices use a significant-figure rule, not a fixed tick
+                stepSize: Number.isInteger(szDecimals) && szDecimals >= 0 ? stepFromDecimals(szDecimals) : null,
+                minSize: null,
+                minNotional: HL_MIN_ORDER_VALUE_USD,
+                maxLeverage: Number.isFinite(maxLeverage) && maxLeverage > 0 ? maxLeverage : null,
+                marginTiers: null,
+                session: null,
+                tradable: a.isDelisted !== true,
+            },
+            nextFundingTime: null, // not published in metaAndAssetCtxs
+        });
+    });
+    warnExcluded("hyperliquid", "unclassified/ambiguous market(s)", unclassified);
+    warnExcluded("hyperliquid", "market(s) without a mark price", unpriced);
+    return out;
+}
+// ── Aster ──
+function asterFilter(filters, type, field) {
+    if (!Array.isArray(filters))
+        return null;
+    const f = filters.find(x => x.filterType === type);
+    return f ? positiveNumStr(f[field]) : null;
+}
+async function asterRows(net) {
+    const base = legacyPublicBaseUrl("aster", net);
+    const [infoJson, premiumJson, tickerJson, fundingInfoJson] = await Promise.all([
+        getJson("aster", `${base}/fapi/v1/exchangeInfo`, "exchangeInfo"),
+        getJson("aster", `${base}/fapi/v1/premiumIndex`, "premiumIndex"),
+        getJson("aster", `${base}/fapi/v1/ticker/24hr`, "ticker/24hr"),
+        getJson("aster", `${base}/fapi/v3/fundingInfo`, "fundingInfo"),
+    ]);
+    const symbols = arrayField("aster", "exchangeInfo.symbols", infoJson.symbols);
+    const premiumBySymbol = new Map(arrayField("aster", "premiumIndex", premiumJson).map(p => [String(p.symbol), p]));
+    const tickerBySymbol = new Map(arrayField("aster", "ticker/24hr", tickerJson).map(t => [String(t.symbol), t]));
+    const intervalBySymbol = new Map();
+    for (const f of arrayField("aster", "fundingInfo", fundingInfoJson)) {
+        const h = Number(f.fundingIntervalHours);
+        if (Number.isFinite(h) && h > 0)
+            intervalBySymbol.set(String(f.symbol), h);
+    }
+    const out = [];
+    const unclassified = [];
+    const unpriced = [];
+    const noInterval = [];
+    for (const s of symbols) {
+        if (s.contractType !== "PERPETUAL" || s.quoteAsset !== "USDT")
+            continue;
+        const venueSymbol = String(s.symbol);
+        const symbol = String(s.baseAsset);
+        const subTypes = Array.isArray(s.underlyingSubType) ? s.underlyingSubType.map(String) : [];
+        const assetClass = classifyAster(symbol, subTypes);
+        if (assetClass === null) {
+            unclassified.push(venueSymbol);
+            continue;
+        }
+        const p = premiumBySymbol.get(venueSymbol);
+        const mark = p ? positiveNumStr(p.markPrice) : null;
+        if (!p || mark === null) {
+            unpriced.push(venueSymbol);
+            continue;
+        }
+        const hours = intervalBySymbol.get(venueSymbol);
+        if (hours === undefined) {
+            noInterval.push(venueSymbol);
+            continue;
+        }
+        if (typeof s.marginAsset !== "string" || s.marginAsset.length === 0) {
+            throw new PerpError("EXCHANGE_ERROR", `aster exchangeInfo: ${venueSymbol} has no marginAsset`);
+        }
+        const next = Number(p.nextFundingTime);
+        const t = tickerBySymbol.get(venueSymbol);
+        out.push({
+            market: {
+                venue: "aster",
+                venueSymbol,
+                symbol,
+                canonical: canonicalFor("aster", symbol, assetClass),
+                assetClass,
+                settle: s.marginAsset,
+                quoteAsset: s.quoteAsset,
+                markPrice: mark,
+                indexPrice: positiveNumStr(p.indexPrice),
+                fundingRate: rateStr(p.lastFundingRate),
+                fundingRateBasis: { kind: "perHours", hours },
+                settlementIntervalHours: hours,
+                openInterest: null, // per-symbol endpoint only
+                volume24h: t ? numStr(t.quoteVolume) : null,
+                tickSize: asterFilter(s.filters, "PRICE_FILTER", "tickSize"),
+                stepSize: asterFilter(s.filters, "LOT_SIZE", "stepSize"),
+                minSize: asterFilter(s.filters, "LOT_SIZE", "minQty"),
+                minNotional: asterFilter(s.filters, "MIN_NOTIONAL", "notional"),
+                maxLeverage: null, // leverage brackets require a signed call
+                marginTiers: null,
+                session: null,
+                tradable: s.status === "TRADING",
+            },
+            nextFundingTime: Number.isFinite(next) && next > 0 ? next : null,
+        });
+    }
+    warnExcluded("aster", "unclassified/ambiguous market(s)", unclassified);
+    warnExcluded("aster", "market(s) without a mark price", unpriced);
+    warnExcluded("aster", "market(s) missing from fundingInfo", noInterval);
+    return out;
+}
+// ── VenuePublicData ──
+function rowsFor(venue, net) {
+    switch (venue) {
+        case "pacifica": return pacificaRows(net);
+        case "hyperliquid": return hyperliquidRows(net);
+        case "aster": return asterRows(net);
+    }
+}
+export function legacyPublicData(venue) {
+    return {
+        async fetchMarkets(net) {
+            return (await rowsFor(venue, net)).map(r => r.market);
+        },
+        async fetchFundingRates(net) {
+            const out = [];
+            for (const { market: m, nextFundingTime } of await rowsFor(venue, net)) {
+                if (!m.tradable || m.fundingRate === null)
+                    continue;
+                out.push({
+                    venue: m.venue,
+                    venueSymbol: m.venueSymbol,
+                    symbol: m.symbol,
+                    canonical: m.canonical,
+                    rate: m.fundingRate,
+                    basis: m.fundingRateBasis,
+                    markPrice: m.markPrice,
+                    nextFundingTime,
+                });
+            }
+            return out;
+        },
+    };
+}