perp-cli 0.14.3 → 0.16.0

package/dist/exchanges/qfex/adapter.js

@@ -1,6 +1,5 @@
 /**
  * QFEX adapter — native TradingV2 + legacy ExchangeAdapter shim
- * (design §14.3–§14.6 as amended by §14.12; §10.7, §10.10, §13).
  *
  * Signer: imported HMAC API key only (QfexAgentMeta → ~/.perp/qfex-agents/<publicKey>.json).
  * Orders go over the Trade WebSocket (ws-transport.ts); account reads, leverage and transfers
@@ -51,7 +50,7 @@ import { QFEX_BANKER_NETWORK, QFEX_ENDPOINTS, QFEX_WITHDRAW_DISABLED, QFEX_WITHD
 import { loadQfexCredentials, QFEX_IMPORT_REMEDIATION } from "./agent.js";
 import { QfexClient } from "./client.js";
 import { qfexStatusClass } from "./errors.js";
-import { fetchQfexInstruments, qfexPlainSymbol, qfexPublicData, qfexTradable, qfexVenueSymbol, } from "./public.js";
+import { buildQfexFundingRates, buildQfexMarkets, fetchQfexInstruments, fetchQfexMarketsWithInstruments, qfexFundingWindowClosed, qfexIndexPrices, qfexListedStatus, qfexPlainSymbol, qfexPublicData, qfexTradable, qfexVenueSymbol, } from "./public.js";
 import { QFEX_AUTOMATION_VERIFIED, QFEX_MODIFY_KEEPS_CLIENT_ID, QFEX_REDUCE_ONLY_WIRE, QFEX_STOP_CLIENT_ID_ECHO, decimalsEqual, fromWireNumber, isZeroDecimal, qfexAutomationGate, qfexReduceOnlyGate, reduceOnlyWireValue, subDecimals, sumDecimals, toWireNumber, weightedAveragePrice, } from "./signing.js";
 import { QFEX_IDLE_CLOSE_MS, QFEX_MDS_TIMEOUT_MS, QFEX_TIMEOUTS, fetchQfexMarketStats, qfexPendingRemediation, qfexTradeSession, } from "./ws-transport.js";
 /** A mark price entry older than this (its own venue `time`) is not used as an order reference. */
@@ -78,6 +77,24 @@ const STOP_TYPES = new Set(["TAKE_PROFIT", "STOP_LOSS"]);
 const KLINE_RESOLUTION = {
     "1m": "1MIN", "5m": "5MINS", "15m": "15MINS", "30m": "30MINS", "1h": "1HOUR", "4h": "4HOURS", "1d": "1DAY",
 };
+/**
+ * Candle volumes. GET /candles returns `usdVolume` (populated) and `baseTokenVolume`, which the
+ * venue leaves "0" on traded candles (live 2026-10-14, CL-USD 1HOUR: baseTokenVolume "0" with
+ * usdVolume "52534.48506" on every row; startingOpenInterest / orderbookMidPrice* are "0" too).
+ * A base "0" next to a non-zero USD volume is a placeholder → null (unknown), never 0; when
+ * both are zero the candle really had no volume.
+ */
+export function qfexCandleVolumes(c) {
+    const decimal = (v, what) => {
+        if (typeof v !== "string" || v.trim() === "" || !Number.isFinite(Number(v))) {
+            throw new PerpError("EXCHANGE_ERROR", `QFEX candles: ${what} is not a decimal string (${JSON.stringify(v)})`, { exchange: "qfex" });
+        }
+        return v;
+    };
+    const quoteVolume = decimal(c.usdVolume, "usdVolume");
+    const base = decimal(c.baseTokenVolume, "baseTokenVolume");
+    return { volume: Number(base) === 0 && Number(quoteVolume) !== 0 ? null : base, quoteVolume };
+}
 /** Client order id sent to the venue: a fresh UUID (the format the venue itself generates). */
 export function qfexClientOrderId() {
     return randomUUID();
@@ -262,7 +279,21 @@ export class QfexAdapter {
         const venueSymbol = qfexVenueSymbol(symbol);
         const i = (await this.instrumentMap()).get(venueSymbol);
         if (i === undefined) {
-            throw new PerpError("SYMBOL_NOT_FOUND", `QFEX has no market ${venueSymbol}`, { exchange: "qfex", remediation: "List markets with: perp market list -e qfex" });
+            throw new PerpError("SYMBOL_NOT_FOUND", `QFEX has no market ${venueSymbol}`, { exchange: "qfex", remediation: "List markets: perp -e qfex market list" });
+        }
+        return i;
+    }
+    /**
+     * Instrument of a per-symbol read (book / funding / kline / info). Unknown → SYMBOL_NOT_FOUND; a
+     * listed market whose /refdata status is not ACTIVE (DELISTED, INACTIVE) → SYMBOL_NOT_FOUND with
+     * that status: it is not a live market. A non-USD ACTIVE market is readable (only orders refuse it).
+     */
+    async readableInstrument(symbol) {
+        const i = await this.instrumentOf(symbol);
+        if (i.status !== "ACTIVE") {
+            throw new PerpError("SYMBOL_NOT_FOUND", `QFEX ${i.venueSymbol} is ${i.status.toLowerCase()} (status ${i.status}) — not a live market`, {
+                exchange: "qfex", status: i.status, remediation: "List tradable markets with: perp market list -e qfex",
+            });
         }
         return i;
     }
@@ -339,7 +370,7 @@ export class QfexAdapter {
     stopOrderGate() {
         if (QFEX_STOP_CLIENT_ID_ECHO === true)
             return null;
-        return unsupported("qfex", "stopOrder", "the stop order acknowledgement is not documented to echo a client order id, so a stop cannot be correlated safely (Q21)", "Set stops / TP / SL on the QFEX web app until docs/TEST-PLAN.md QFEX item Q21 passes");
+        return unsupported("qfex", "stopOrder", "the stop order acknowledgement is not documented to echo a client order id, so a stop cannot be correlated safely (Q21)", "Set stops / TP / SL on the QFEX web app until QFEX item Q21 passes");
     }
     /**
      * One reduce-only stop-market order (add_order with order_type TAKE_PROFIT / STOP_LOSS).
@@ -571,7 +602,7 @@ export class QfexAdapter {
     /**
      * A reduce-only order the venue did not confirm as reduce-only (`reduce_only` false or absent
      * on an order frame — reduceOnlyUnconfirmedFrame — or on a read-back row of THIS order). The order may be live as a normal order, so the outcome is
-     * unknown (ORDER_PENDING, design §14.12 #4e: never re-sent). It is NOT cancelled here: a cancel
+     * unknown (ORDER_PENDING, never re-sent). It is NOT cancelled here: a cancel
      * is a second mutating command with its own unknown outcome and cannot undo a fill.
      */
     reduceOnlyEchoError(i, orderId, clientOrderId, echo, venueRaw) {
@@ -746,7 +777,7 @@ export class QfexAdapter {
             }
             if (isZeroDecimal(filled)) {
                 if (ctx.immediate) {
-                    // A terminal frame with nothing filled — IOC_CANCELLED or CANCELLED alike (§13.10 #4).
+                    // A terminal frame with nothing filled — IOC_CANCELLED or CANCELLED alike.
                     throw new PerpError("ORDER_REJECTED", `QFEX ${i.venueSymbol}: the ${t.time_in_force} order filled nothing and was cancelled (${t.status})`, {
                         exchange: "qfex", reason: "iocNoFill", venueStatus: t.status, orderId: add.orderId, clientOrderId: add.clientOrderId, venueRaw,
                         remediation: "Nothing was filled. Widen --slippage-bps (within the price band), reduce the size, or place a resting limit order",
@@ -781,7 +812,7 @@ export class QfexAdapter {
     }
     /**
      * Final filled size of an order placed through the legacy shim — non-null ONLY when a venue
-     * terminal frame was received (design §14.12 #3). A pending result is never an outcome.
+     * terminal frame was received. A pending result is never an outcome.
      */
     iocOutcomeOf(raw) {
         const r = raw;
@@ -1094,24 +1125,70 @@ export class QfexAdapter {
         return { venue: "qfex", symbol: i.symbol, leverage: raw.leverage, marginMode: "cross", venueRaw: raw };
     }
     // ── Legacy ExchangeAdapter: market data ──
+    /**
+     * Legacy rows plus `tradable` (ACTIVE and USD-quoted, qfexTradable), the /refdata `status`
+     * (ACTIVE / INACTIVE / DELISTED) and `quoteAsset` (prices of KRW / JPY / CNY / SEK / HKD markets
+     * are in that currency, not USD).
+     */
     async getMarkets() {
-        return (await this.getVenueMarkets()).map(toLegacyMarketInfo);
+        const { markets, instruments, volumeNotional } = await fetchQfexMarketsWithInstruments(this.network);
+        const bySymbol = new Map(instruments.map(i => [i.venueSymbol, i]));
+        return markets.map(m => this.marketRow(m, bySymbol.get(m.venueSymbol), volumeNotional));
+    }
+    marketRow(m, i, volumeNotional) {
+        if (i === undefined)
+            throw new PerpError("EXCHANGE_ERROR", `QFEX ${m.venueSymbol} is missing from /refdata`, { exchange: "qfex" });
+        return {
+            ...toLegacyMarketInfo(m), tradable: m.tradable, status: qfexListedStatus(i), quoteAsset: i.quoteAsset,
+            volume24hQuote: volumeNotional.get(i.venueSymbol) ?? null,
+        };
     }
+    /**
+     * `market info` of one ACTIVE market. fundingRate is the CURRENT /md/contracts `funding_rate`
+     * (the rate `market funding` / `arb scan --rates --include-unverified` show), labelled fundingVerified false: QFEX funding
+     * is unverified (Q4, display only). Market lists keep fundingRate null so no scan / bot reads it.
+     */
+    async getMarketInfo(symbol) {
+        const i = await this.readableInstrument(symbol);
+        const snap = await fetchQfexMarketStats(QFEX_ENDPOINTS[this.network].mdsWs, i.venueSymbol, QFEX_MDS_TIMEOUT_MS);
+        const contracts = await this.client.publicGet("/md/contracts", null);
+        const { markets } = buildQfexMarkets([i], snap, Date.now(), qfexIndexPrices(listOf(contracts.data, "/md/contracts data")));
+        if (markets.length === 0)
+            throw new PerpError("PRICE_STALE", `QFEX ${i.venueSymbol}: no mark price in the market_stats snapshot`, { exchange: "qfex" });
+        const { rates } = buildQfexFundingRates([i], listOf(contracts.data, "/md/contracts data").filter(c => c.ticker_id === i.venueSymbol), snap.marks, Date.now());
+        return {
+            ...this.marketRow(markets[0], i, snap.volumeNotional),
+            fundingRate: rates.length === 0 ? null : rates[0].rate,
+            // true = the window in progress is outside the market's funding hours (fundingRate null).
+            marketClosed: rates.length === 0 ? null : rates[0].marketClosed === true,
+            fundingVerified: false,
+            fundingNote: "QFEX funding rate UNVERIFIED (not confirmed against settled payments) — display only, never a basis for trading",
+        };
+    }
+    /** `quoteAsset`: level prices are in the market's quote currency (KRW for SAMSUNG-KRW). */
     async getOrderbook(symbol) {
-        const venueSymbol = qfexVenueSymbol(symbol);
+        // Resolved against refdata first: an unknown symbol is SYMBOL_NOT_FOUND, not the venue's
+        // HTTP 404 surfacing as a retryable EXCHANGE_ERROR.
+        const instrument = await this.readableInstrument(symbol);
+        const venueSymbol = instrument.venueSymbol;
         const book = await this.client.publicGet(`/md/orderbook/${encodeURIComponent(venueSymbol)}`, null);
         // The venue lists empty price levels (quantity "0"); they are not part of the book.
         const side = (v, what) => listOf(v, what)
             .filter(l => Array.isArray(l) && typeof l[0] === "string" && typeof l[1] === "string" && Number(l[1]) > 0)
             .map(l => [l[0], l[1]]);
-        return { bids: side(book.bids, "orderbook bids"), asks: side(book.asks, "orderbook asks") };
+        return { bids: side(book.bids, "orderbook bids"), asks: side(book.asks, "orderbook asks"), quoteAsset: instrument.quoteAsset };
     }
     async getRecentTrades() {
         throw unsupported("qfex", "recentTrades", "the documented public trade endpoint (GET /public/trades) answers 404", "Use the order book: perp market book <symbol> -e qfex");
     }
-    /** Hourly funding windows (GET /funding/{symbol}, intervalMinutes 60). `limit` = hours back (default 24). */
+    /**
+     * Hourly funding windows (GET /funding/{symbol}, intervalMinutes 60). `limit` = hours back (default 24).
+     * A window outside the market's funding hours (qfexFundingWindowClosed) is `rate: null,
+     * marketClosed: true` — the venue prints 0 there, which is "no funding", not a 0 rate.
+     */
     async getFundingHistory(symbol, limit) {
-        const venueSymbol = qfexVenueSymbol(symbol);
+        const instrument = await this.readableInstrument(symbol);
+        const venueSymbol = instrument.venueSymbol;
         const hours = limit === undefined ? 24 : limit;
         if (!Number.isInteger(hours) || hours < 1)
             throw new PerpError("INVALID_PARAMS", `funding history limit must be a positive integer of hours (got ${hours})`);
@@ -1126,23 +1203,31 @@ export class QfexAdapter {
             const time = typeof r.windowStart === "string" ? Date.parse(r.windowStart) : NaN;
             if (!Number.isFinite(time))
                 throw new PerpError("EXCHANGE_ERROR", `QFEX funding history: invalid windowStart ${JSON.stringify(r.windowStart)}`);
-            out.push({ time, rate: plainNumber(r.rate, "funding rate"), price: null });
+            const rate = plainNumber(r.rate, "funding rate");
+            const marketClosed = qfexFundingWindowClosed(instrument.marketHours, time, Number(rate));
+            out.push({ time, rate: marketClosed ? null : rate, price: null, intervalHours: 1, rateKind: marketClosed ? null : "lastSettled", marketClosed });
         }
         return out.sort((a, b) => a.time - b.time);
     }
+    /** Rows carry `quoteAsset`: OHLC prices are in the market's quote currency (KRW for SAMSUNG-KRW). */
     async getKlines(symbol, interval, startTime, endTime) {
         const resolution = KLINE_RESOLUTION[interval.trim()];
         if (resolution === undefined) {
             throw new PerpError("INVALID_PARAMS", `Unsupported kline interval "${interval}" on QFEX`, { remediation: `Use one of: ${Object.keys(KLINE_RESOLUTION).join(", ")}` });
         }
-        const body = await this.client.publicGet(`/candles/${encodeURIComponent(qfexVenueSymbol(symbol))}`, {
+        const instrument = await this.readableInstrument(symbol);
+        const venueSymbol = instrument.venueSymbol;
+        const body = await this.client.publicGet(`/candles/${encodeURIComponent(venueSymbol)}`, {
             resolution, fromISO: new Date(startTime).toISOString(), toISO: new Date(endTime).toISOString(),
         });
         return listOf(body.candles, "candles").map(c => {
             const time = Date.parse(c.startedAt);
             if (!Number.isFinite(time))
                 throw new PerpError("EXCHANGE_ERROR", `QFEX candles: invalid startedAt "${c.startedAt}"`);
-            return { time, open: c.open, high: c.high, low: c.low, close: c.close, volume: c.baseTokenVolume, trades: null };
+            const v = qfexCandleVolumes(c);
+            // `usdVolume` is Σ price × qty in the QUOTE currency (live 2026-10-19: SAMSUNG-KRW 1m candles
+            // equal the KRW trade tape exactly); quoteVolume is USD → null for a non-USD quote.
+            return { time, open: c.open, high: c.high, low: c.low, close: c.close, ...v, quoteVolume: instrument.quoteAsset === "USD" ? v.quoteVolume : null, trades: null, quoteAsset: instrument.quoteAsset };
         }).sort((a, b) => a.time - b.time);
     }
     // ── Legacy ExchangeAdapter: account ──
@@ -1258,7 +1343,7 @@ export class QfexAdapter {
     async getFundingPayments() {
         throw unsupported("qfex", "fundingPayments", "funding payments are GET /executions rows, but the execution_type that marks them is not documented (Q10)", "See funding in the QFEX web app; net funding per position is in: perp account positions -e qfex --json");
     }
-    // ── Legacy ExchangeAdapter: trading (shim → TradingV2, design §10.7). Client ids are generated here. ──
+    // ── Legacy ExchangeAdapter: trading (shim → TradingV2). Client ids are generated here. ──
     async marketOrder(symbol, side, size, opts) {
         return this.placeOrder({
             symbol, side, type: "market", size, price: null, triggerPrice: null, triggerSource: null, tif: null,
@@ -1294,7 +1379,7 @@ export class QfexAdapter {
             reduceOnly: opts?.reduceOnly === true, clientOrderId: qfexClientOrderId(), slippage: null, tpsl: null,
         });
     }
-    // ── Funds (design §14.6, §14.12 #8) ──
+    // ── Funds ──
     /**
      * Deposit address for USDC on Arbitrum One (banker GET /address). The address is returned
      * only when the venue confirms exactly that network and asset — anything else is refused,

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

@@ -1,5 +1,5 @@
 /**
- * QFEX API key import (design §14.5 as amended by §14.12 #9).
+ * QFEX API key import.
  *
  * Keys are created on the QFEX website (Developer Settings, 2FA) — there is no programmatic
  * approval. The public key + secret are entered via hidden prompt / stdin only (never flags,

package/dist/exchanges/qfex/agent.js

@@ -1,5 +1,5 @@
 /**
- * QFEX API key import (design §14.5 as amended by §14.12 #9).
+ * QFEX API key import.
  *
  * Keys are created on the QFEX website (Developer Settings, 2FA) — there is no programmatic
  * approval. The public key + secret are entered via hidden prompt / stdin only (never flags,

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

@@ -1,5 +1,5 @@
 /**
- * QFEX raw REST client (design §14.1, §14.4, §14.6): raw fetch + node:crypto HMAC, no SDK.
+ * QFEX raw REST client: raw fetch + node:crypto HMAC, no SDK.
  *
  * Two hosts: the API (`api.qfex.*` — market data, account reads, leverage, subaccount
  * transfer) and the banker (`banker.qfex.*` — deposit address, withdraw). Both take the same

package/dist/exchanges/qfex/client.js

@@ -1,5 +1,5 @@
 /**
- * QFEX raw REST client (design §14.1, §14.4, §14.6): raw fetch + node:crypto HMAC, no SDK.
+ * QFEX raw REST client: raw fetch + node:crypto HMAC, no SDK.
  *
  * Two hosts: the API (`api.qfex.*` — market data, account reads, leverage, subaccount
  * transfer) and the banker (`banker.qfex.*` — deposit address, withdraw). Both take the same

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

@@ -1,5 +1,5 @@
 /**
- * QFEX venue status / error → PerpError (design §14.3 error table, §14.12 #3, #8, #11).
+ * QFEX venue status / error → PerpError.
  *
  * Three sources:
  *  - order_response.status   engine verdict on one order (definite once correlated);

package/dist/exchanges/qfex/errors.js

@@ -1,5 +1,5 @@
 /**
- * QFEX venue status / error → PerpError (design §14.3 error table, §14.12 #3, #8, #11).
+ * QFEX venue status / error → PerpError.
  *
  * Three sources:
  *  - order_response.status   engine verdict on one order (definite once correlated);
@@ -90,7 +90,7 @@ const STATUS_REMEDIATION = {
     CANNOT_MODIFY_PARTIAL_FILL: "A partially filled order cannot be modified — cancel it and place a new order",
     CANNOT_MODIFY_ALO_WOULD_CROSS: "The new price would cross the book — choose a passive price, or cancel and place a LIMIT order",
     REJECTED_MARKET_CLOSED: "The market is closed for this order right now — check the session: perp market info <symbol> -e qfex",
-    INVALID_CLIENT_ORDER_ID: "The venue refused the generated client order id — report it (docs/TEST-PLAN.md QFEX Q18)",
+    INVALID_CLIENT_ORDER_ID: "The venue refused the generated client order id — report it (QFEX item Q18)",
 };
 /** "… retry after 200ms" / "… retry after 2 seconds" → ms; null when the message carries no hint. */
 export function parseRetryAfterMs(message) {

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

@@ -1,21 +1,30 @@
 /**
- * QFEX public market data (design §14.8 as amended by §14.12 #6, #7, #10).
+ * QFEX public market data.
  *
  * Sources (all public):
  *   GET /refdata                 instruments: tick, lot, min/max quantity, price band, status,
  *                                quote / margin asset, allowed order types + TIFs, market hours
  *   MDS market_stats snapshot    mark price (each entry with its own `time`), open interest,
  *                                24h notional volume
- *   GET /md/contracts            funding_rate / next_funding_rate_timestamp (funding reads only)
+ *   GET /md/contracts            funding_rate / next_funding_rate_timestamp (funding reads);
+ *                                index_price (market rows, best effort)
  *
- * Coupling (§14.12 #10): order-entry precision comes from /refdata ALONE (fetchQfexInstruments).
- * Markets need /refdata + the MDS snapshot. Only funding reads need /md/contracts — its failure
- * fails fetchFundingRates, never market listing or order entry.
+ * Coupling: order-entry precision comes from /refdata ALONE (fetchQfexInstruments).
+ * Markets need /refdata + the MDS snapshot; /md/contracts only adds indexPrice — its failure
+ * leaves indexPrice null (unknown) with a warning, never fails market listing or order entry.
+ * Funding reads need /md/contracts.
+ *
+ * indexPrice = /md/contracts `index_price` (docs contract-specifications: the Index Price is "the
+ * reference spot price for the asset"; the OpenAPI field has no description). Live 2026-10-19 it
+ * tracked the MDS `underlier` channel (AAPL 342.47 = 342.47, GOLD 4170.22 vs 4170.05, SAMSUNG-KRW
+ * 220092 vs 220082 KRW), moved on 122 of 222 markets within 45 s, and sat a median 0.015 % from
+ * the mark (max 5 %, CVNA pre-market). It is in the quote currency (`index_currency`), like the mark.
+ * /md/contracts lists ACTIVE markets only; a non-positive / missing value is null.
  *
  * Funding is UNVERIFIED (venue flag fundingVerified: false, Q4): the rate's unit is not
  * confirmed against settled payments and `funding_rate` vs `next_funding_rate` is undecided.
  * Markets therefore carry fundingRate null; fetchFundingRates returns the raw `funding_rate`
- * for the explicit, flagged reads only (`perp funding`, `arb scan --include-unverified`).
+ * for the explicit, flagged reads only (`arb scan --rates|--compare --include-unverified`).
  *
  * Symbols: "AAPL-USD" → CLI symbol "AAPL". Non-USD quotes keep the suffix ("SKHYNIX-KRW"),
  * have no canonical symbol and are NOT tradable through perp-cli (USD-assuming sizing / risk).
@@ -60,6 +69,14 @@ export interface QfexContractRow {
     funding_rate: string;
     next_funding_rate: string;
     next_funding_rate_timestamp: number;
+    /** Index (reference spot) price in the quote currency — see the module header. */
+    index_price?: string;
+    /**
+     * NOT USD on a non-USD market despite the name: live 2026-10-19 SAMSUNG-KRW 1,234,418 =
+     * open_interest 5.58 × index 221,118 → KRW (as is target_volume). Nothing reads it; never wire it
+     * up as a USD figure. OI is reported in base units (VenueMarket.openInterest, MDS open_interests).
+     */
+    open_interest_usd?: string;
 }
 /** One instrument, as order entry needs it — from /refdata only. */
 export interface QfexInstrument {
@@ -89,18 +106,43 @@ export declare function qfexPlainSymbol(venueSymbol: string): string;
 export declare function qfexVenueSymbol(symbol: string): string;
 export declare function qfexAssetClass(row: Pick<QfexRefdataRow, "symbol" | "product_category" | "base_asset">): AssetClass;
 export declare function toQfexInstrument(raw: unknown): QfexInstrument;
-/** Is the market one perp-cli may send orders to? USD-quoted and ACTIVE (§14.12 #7). */
+/** Is the market one perp-cli may send orders to? USD-quoted and ACTIVE. */
 export declare function qfexTradable(i: Pick<QfexInstrument, "status" | "quoteAsset">): boolean;
 /**
- * Whether `nowMs` falls inside a `session: "open"` window of the instrument's market_hours
- * (weekday + local time in its `tz`). null = the venue published no usable schedule.
- * This is the underlying's regular session only — it is NOT used to infer whether funding
- * accrues (the schedule and the documented funding hours do not map 1:1, Q9).
+ * Whether `nowMs` falls inside a `session: "open"` window of the instrument's market_hours.
+ * null = the venue published no usable schedule. This is the underlying's regular session only;
+ * funding hours are qfexFundingWindowClosed's question.
  */
 export declare function qfexUnderlyingOpen(marketHours: Record<string, unknown> | null, nowMs: number): boolean | null;
+/**
+ * Was the funding window labelled `windowStartMs` outside the market's funding hours? Docs
+ * (docs.qfex.com/qfex/funding): "Funding is only active during a symbol's configured
+ * market_hours"; outside them "funding rate is 0 and no funding payment is exchanged".
+ *
+ * The window labelled T covers the hour BEFORE T (live 2026-10-19, GET /funding, 9 symbols over
+ * 10 days: AAPL-USD prints its last non-zero rate at Sat 00:00Z = Fri 20:00 ET and its first at
+ * Mon 01:00Z = Sun 21:00 ET, i.e. funding Sun 20:00–Fri 20:00 ET as documented, only when each
+ * label is read as the end of its hour).
+ *
+ * market_hours alone does not say whether an unlisted gap funds (US equities fund overnight
+ * between post_market and pre_market; Korean equities do not fund outside "open"), so a window is
+ * closed when the venue printed exactly 0 AND no part of the hour was in a funding session
+ * (anything but "weekend" / "close"). A non-zero rate is never marked closed, and a 0 inside a
+ * session stays a real 0. No usable schedule → never closed.
+ *
+ * Known limits (review B2-4 / B2-5):
+ *  - market holidays are not in market_hours: a holiday inside a configured weekday session
+ *    (SAMSUNG-KRW on Hangul Day) prints the venue's 0 as a real-looking "0", marketClosed false;
+ *  - US equities fund in the weekday overnight gap (post_market → pre_market, docs "Sunday 20:00 –
+ *    Friday 20:00 ET"), so a gap is never closed by schedule alone — only an exact 0 there is, and
+ *    a genuine 0 rate in such a gap is (rarely) reported as closed.
+ */
+export declare function qfexFundingWindowClosed(marketHours: Record<string, unknown> | null, windowStartMs: number, rate: number): boolean;
 export declare function qfexPublicClient(net: Network): QfexClient;
 /** Every instrument of /refdata (all statuses). The only input of order-entry validation. */
 export declare function fetchQfexInstruments(client: QfexClient): Promise<QfexInstrument[]>;
+/** venue symbol → /md/contracts `index_price` (positive finite only). */
+export declare function qfexIndexPrices(contracts: readonly Partial<QfexContractRow>[]): Map<string, string>;
 export declare function buildQfexMarkets(instruments: readonly QfexInstrument[], snap: {
     marks: ReadonlyMap<string, {
         price: string;
@@ -108,10 +150,21 @@ export declare function buildQfexMarkets(instruments: readonly QfexInstrument[],
     }>;
     openInterest: ReadonlyMap<string, string>;
     volumeNotional: ReadonlyMap<string, string>;
-}, nowMs: number): {
+}, nowMs: number, indexPrices?: ReadonlyMap<string, string>): {
     markets: VenueMarket[];
     activeWithoutMark: string[];
 };
+/**
+ * Priced markets, the /refdata instruments they were built from (status / quote asset per row) and
+ * the 24h notional per venue symbol in its QUOTE currency (KRW for SAMSUNG-KRW).
+ */
+export declare function fetchQfexMarketsWithInstruments(net: Network): Promise<{
+    markets: VenueMarket[];
+    instruments: QfexInstrument[];
+    volumeNotional: ReadonlyMap<string, string>;
+}>;
+/** "active" = ACTIVE and USD-quoted; "nonUsdQuote" = ACTIVE, quoted in KRW / JPY / … (readable, never ordered). */
+export declare function qfexListedStatus(i: Pick<QfexInstrument, "status" | "quoteAsset" | "venueSymbol">): "active" | "nonUsdQuote";
 export declare function buildQfexFundingRates(instruments: readonly QfexInstrument[], contracts: readonly QfexContractRow[], marks: ReadonlyMap<string, {
     price: string;
     time: number;