perp-cli 0.15.0 → 0.16.0

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

@@ -6,16 +6,25 @@
  *                                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: 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.
+ * 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 {
@@ -92,15 +109,40 @@ export declare function toQfexInstrument(raw: unknown): QfexInstrument;
 /** 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;

package/dist/exchanges/qfex/public.js

@@ -6,16 +6,25 @@
  *                                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: 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.
+ * 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).
@@ -110,19 +119,17 @@ export function qfexTradable(i) {
 // ── Market hours → session ──
 const WEEKDAYS = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
 /**
- * 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).
+ * Session names of the instrument's market_hours that contain `ms` (weekday + local time in its
+ * `tz`); [] = no window listed at that time. null = the venue published no usable schedule.
  */
-export function qfexUnderlyingOpen(marketHours, nowMs) {
+function qfexSessionsAt(marketHours, ms) {
     if (marketHours === null || typeof marketHours.tz !== "string")
         return null;
     let parts;
     try {
         parts = new Intl.DateTimeFormat("en-US", {
             timeZone: marketHours.tz, weekday: "long", hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23",
-        }).formatToParts(new Date(nowMs));
+        }).formatToParts(new Date(ms));
     }
     catch {
         return null; // an unknown IANA zone name is "no usable schedule", not a closed market
@@ -135,19 +142,70 @@ export function qfexUnderlyingOpen(marketHours, nowMs) {
     const now = `${h}:${m}:${s}`;
     const day = marketHours[weekday];
     if (day === undefined)
-        return false; // no window listed for this weekday
+        return []; // no window listed for this weekday
     if (!Array.isArray(day))
         return null;
+    const out = [];
     for (const w of day) {
         if (w === null || typeof w !== "object")
             return null;
         const win = w;
         if (typeof win.session !== "string" || typeof win.open !== "string" || typeof win.close !== "string")
             return null;
-        if (win.session === "open" && now >= win.open && now <= win.close)
-            return true;
+        if (now >= win.open && now <= win.close)
+            out.push(win.session);
     }
-    return false;
+    return out;
+}
+/**
+ * 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 function qfexUnderlyingOpen(marketHours, nowMs) {
+    const sessions = qfexSessionsAt(marketHours, nowMs);
+    return sessions === null ? null : sessions.includes("open");
+}
+/** market_hours session names during which no funding accrues. */
+const QFEX_NON_FUNDING_SESSIONS = new Set(["weekend", "close"]);
+/**
+ * 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 function qfexFundingWindowClosed(marketHours, windowStartMs, rate) {
+    if (rate !== 0)
+        return false;
+    const from = windowStartMs - 3_600_000;
+    // Sampled inside the hour, never on its edges: market_hours closes are inclusive and often on
+    // the hour (GOLD-USD Fri close "17:00:00"), so a sample AT `from` would put the hour after the
+    // close inside the session (GOLD printed 0 for Fri 17:00–18:00 ET on 2026-10-09 and 10-16).
+    for (const t of [from + 1_000, from + 900_000, from + 1_800_000, from + 2_700_000, windowStartMs - 1_000]) {
+        const sessions = qfexSessionsAt(marketHours, t);
+        if (sessions === null)
+            return false;
+        if (sessions.some(x => !QFEX_NON_FUNDING_SESSIONS.has(x)))
+            return false;
+    }
+    return true;
 }
 function sessionOf(i, nowMs) {
     const open = qfexUnderlyingOpen(i.marketHours, nowMs);
@@ -173,10 +231,24 @@ function canonicalOf(i) {
         return null;
     return canonicalFor("qfex", i.symbol, i.assetClass);
 }
-export function buildQfexMarkets(instruments, snap, nowMs) {
+/** venue symbol → /md/contracts `index_price` (positive finite only). */
+export function qfexIndexPrices(contracts) {
+    const out = new Map();
+    for (const c of contracts) {
+        const v = c.index_price;
+        if (typeof c.ticker_id === "string" && typeof v === "string" && Number.isFinite(Number(v)) && Number(v) > 0)
+            out.set(c.ticker_id, v);
+    }
+    return out;
+}
+export function buildQfexMarkets(instruments, snap, nowMs, indexPrices = new Map()) {
     const markets = [];
     const activeWithoutMark = [];
     for (const i of instruments) {
+        // Listing policy: a DELISTED / INACTIVE market is not listed (per-symbol reads refuse it); only
+        // ACTIVE markets are, with tradable false when perp-cli cannot trade them (non-USD quote).
+        if (i.status !== "ACTIVE")
+            continue;
         const mark = snap.marks.get(i.venueSymbol);
         if (mark === undefined) {
             if (i.status === "ACTIVE")
@@ -194,12 +266,16 @@ export function buildQfexMarkets(instruments, snap, nowMs) {
             settle: i.marginAsset,
             quoteAsset: i.quoteAsset,
             markPrice: mark.price,
-            indexPrice: null,
+            indexPrice: indexPrices.get(i.venueSymbol) ?? null,
             fundingRate: null, // unverified (Q4) — see module header
             fundingRateBasis: QFEX_FUNDING_BASIS,
             settlementIntervalHours: QFEX_SETTLEMENT_HOURS,
             openInterest: oi === undefined ? null : oi,
-            volume24h: vol === undefined ? null : vol,
+            // daily_volumes_notional is in the QUOTE currency (live 2026-10-19: SAMSUNG-KRW 9,827,530 =
+            // /md/contracts target_volume 9,763,491 KRW ≈ base_volume 45.16 × ~216,000 KRW, and the
+            // 24 hourly candles' usdVolume sum to 9,821,767). VenueMarket.volume24h is USD, and the venue
+            // publishes no USD-KRW / JPY / CNY / SEK / HKD rate → null for a non-USD quote.
+            volume24h: vol === undefined || i.quoteAsset !== "USD" ? null : vol,
             tickSize: i.tickSize,
             stepSize: i.lotSize,
             minSize: i.minQuantity,
@@ -212,14 +288,40 @@ export function buildQfexMarkets(instruments, snap, nowMs) {
     }
     return { markets, activeWithoutMark };
 }
-async function fetchMarkets(net) {
-    const instruments = await fetchQfexInstruments(qfexPublicClient(net));
+/**
+ * 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 async function fetchQfexMarketsWithInstruments(net) {
+    const client = qfexPublicClient(net);
+    const instruments = await fetchQfexInstruments(client);
     const snap = await fetchQfexMarketStats(QFEX_ENDPOINTS[net].mdsWs, "*", QFEX_MDS_TIMEOUT_MS);
-    const { markets, activeWithoutMark } = buildQfexMarkets(instruments, snap, Date.now());
+    let indexPrices = new Map();
+    try {
+        const body = await client.publicGet("/md/contracts", null);
+        if (!Array.isArray(body.data))
+            throw new Error("response has no data list");
+        indexPrices = qfexIndexPrices(body.data);
+    }
+    catch (e) {
+        console.warn(`[qfex] index prices unavailable (/md/contracts: ${e instanceof Error ? e.message : String(e)}); indexPrice left null`);
+    }
+    const { markets, activeWithoutMark } = buildQfexMarkets(instruments, snap, Date.now(), indexPrices);
     if (activeWithoutMark.length > 0) {
         console.warn(`[qfex] excluded ${activeWithoutMark.length} active market(s) without a mark price: ${activeWithoutMark.join(", ")}`);
     }
-    return markets;
+    return { markets, instruments, volumeNotional: snap.volumeNotional };
+}
+/** "active" = ACTIVE and USD-quoted; "nonUsdQuote" = ACTIVE, quoted in KRW / JPY / … (readable, never ordered). */
+export function qfexListedStatus(i) {
+    if (i.status !== "ACTIVE")
+        throw new PerpError("EXCHANGE_ERROR", `QFEX ${i.venueSymbol} is ${i.status}; it is not listed`, { exchange: "qfex" });
+    return qfexTradable(i) ? "active" : "nonUsdQuote";
+}
+async function fetchMarkets(net) {
+    const { markets, instruments } = await fetchQfexMarketsWithInstruments(net);
+    const bySymbol = new Map(instruments.map(i => [i.venueSymbol, i]));
+    return markets.map(m => { const i = bySymbol.get(m.venueSymbol); return i === undefined ? m : { ...m, status: qfexListedStatus(i) }; });
 }
 export function buildQfexFundingRates(instruments, contracts, marks, nowMs) {
     const byVenueSymbol = new Map(instruments.map(i => [i.venueSymbol, i]));
@@ -238,12 +340,16 @@ export function buildQfexFundingRates(instruments, contracts, marks, nowMs) {
         }
         const mark = marks.get(c.ticker_id);
         const nextMs = typeof c.next_funding_rate_timestamp === "number" ? c.next_funding_rate_timestamp * 1000 : null;
+        // `funding_rate` is the implied rate of the window in progress, labelled by its END (the next
+        // top of the hour, = next_funding_rate_timestamp live) — the same window rule as history.
+        const marketClosed = qfexFundingWindowClosed(i.marketHours, Math.floor(nowMs / 3_600_000) * 3_600_000 + 3_600_000, Number(c.funding_rate));
         rates.push({
             venue: "qfex",
             venueSymbol: c.ticker_id,
             symbol: i.symbol,
             canonical: canonicalOf(i),
-            rate: c.funding_rate,
+            rate: marketClosed ? null : c.funding_rate,
+            marketClosed,
             basis: QFEX_FUNDING_BASIS,
             markPrice: mark === undefined ? null : mark.price,
             // A timestamp in the past is not a "next" funding time (seen on closed markets).

package/dist/exchanges/qfex/ws-transport.d.ts

@@ -277,7 +277,7 @@ export interface QfexMdsSnapshot {
     }>;
     /** Venue symbol → open interest (base units). */
     openInterest: Map<string, string>;
-    /** Venue symbol → 24h volume, quote notional. */
+    /** Venue symbol → 24h volume, notional in the market's QUOTE currency (KRW for SAMSUNG-KRW — not USD). */
     volumeNotional: Map<string, string>;
     frame: QfexFrame;
 }

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

@@ -20,7 +20,7 @@
 import { PerpError } from "../../errors.js";
 import type { RisexAgentMeta } from "../../settings.js";
 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";
@@ -92,16 +92,19 @@ export declare class RisexAdapter implements ExchangeAdapter, TradingV2 {
         postOnlyMarket: boolean;
         tradable: boolean;
     }>>;
-    getOrderbook(symbol: string): Promise<{
+    /** `depth` levels per side (API max 250, developer.rise.trade; was always 50). */
+    getOrderbook(symbol: string, depth?: number): Promise<{
         bids: [string, string][];
         asks: [string, string][];
     }>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangePublicTrade[]>;
-    getFundingHistory(symbol: string, limit?: number): Promise<{
-        time: number;
-        rate: string;
-        price: string | null;
-    }[]>;
+    /**
+     * Settled hourly prints, newest first. The API defaults `start_time` to now − 7 d (168 rows, any
+     * `limit`), so the window is sent explicitly (`limit` hours back, one spare) and pages are
+     * followed with `page` / `has_next_page` (max 1000 rows per page; developer.rise.trade
+     * getfundingratehistory; verified live 2026-10-19).
+     */
+    getFundingHistory(symbol: string, limit?: number): Promise<FundingHistoryRow[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     private portfolio;
     getBalance(): Promise<ExchangeBalance>;
@@ -145,4 +148,13 @@ export declare class RisexAdapter implements ExchangeAdapter, TradingV2 {
     automationGate(): PerpError;
 }
 /** Candle intervals → ms (the venue takes the interval in ns). */
+/**
+ * Candle intervals verified live (2026-10-19, market 1): each returns rows labelled with that
+ * interval. 3m / 30m / 2h / 8h / 12h / 3d are answered with 1m bars (no error), so they are not
+ * listed — getKlines refuses them with INVALID_PARAMS instead of returning 1m candles.
+ */
+export declare const RISEX_BOOK_MAX = 250;
+export declare const RISEX_TRADES_CAP = 1000;
+/** funding-rate-history: max rows per page (docs) and pages followed before giving up. */
+export declare const RISEX_FUNDING_PAGE_MAX = 1000;
 export declare const KLINE_INTERVAL_MS: Readonly<Record<string, number>>;

package/dist/exchanges/risex/adapter.js

@@ -19,6 +19,7 @@
  */
 import { PerpError, extractErrorMessage } from "../../errors.js";
 import { quarantineSymbol } from "../../bot/quarantine.js";
+import { assertCandleInterval } from "../interface.js";
 import { alignProtectionPrice, exactUnits, mulDecimal, slippagePrice, subDecimal } from "../precision.js";
 import { newVenueClientOrderId, unsupported, validateLegacyTif, validateOrderRequest, } from "../trading-v2.js";
 import { networkConfig, requireCapabilities, roleUnsupported } from "../venue.js";
@@ -250,9 +251,13 @@ export class RisexAdapter {
             return { ...toLegacyMarketInfo(m), marketId: m.venueSymbol, reduceOnlyMarket: r.reduce_only, postOnlyMarket: r.post_only, tradable: m.tradable };
         });
     }
-    async getOrderbook(symbol) {
+    /** `depth` levels per side (API max 250, developer.rise.trade; was always 50). */
+    async getOrderbook(symbol, depth = 50) {
+        if (!Number.isInteger(depth) || depth < 1 || depth > RISEX_BOOK_MAX) {
+            throw new PerpError("INVALID_PARAMS", `RISEx: book depth must be 1..${RISEX_BOOK_MAX} (got ${depth})`);
+        }
         const m = await this.market(symbol);
-        const d = await this.client.get("/v1/orderbook", { market_id: m.market_id, limit: 50 });
+        const d = await this.client.get("/v1/orderbook", { market_id: m.market_id, limit: depth });
         const side = (rows, what) => {
             if (!Array.isArray(rows))
                 throw new PerpError("EXCHANGE_ERROR", `RISEx /v1/orderbook: no ${what}`, { exchange: "risex" });
@@ -261,8 +266,12 @@ export class RisexAdapter {
         return { bids: side(d.bids, "bids"), asks: side(d.asks, "asks") };
     }
     async getRecentTrades(symbol, limit = 50) {
+        // Venue cap (live 2026-10-19: "page_size cannot exceed 1000"); refused, never clamped.
+        if (!Number.isInteger(limit) || limit < 1 || limit > RISEX_TRADES_CAP) {
+            throw new PerpError("INVALID_PARAMS", `RISEx: trades limit must be 1..${RISEX_TRADES_CAP} (got ${limit})`, { remediation: `RISEx serves at most ${RISEX_TRADES_CAP} trades per request` });
+        }
         const m = await this.market(symbol);
-        const d = await this.client.get(`/v1/markets/id/${m.market_id}/trade-history`, { limit: Math.min(limit, 1000) });
+        const d = await this.client.get(`/v1/markets/id/${m.market_id}/trade-history`, { limit });
         if (!Array.isArray(d.trades))
             throw new PerpError("EXCHANGE_ERROR", "RISEx trade-history: no trades array", { exchange: "risex" });
         const sym = risexSymbolOf(m);
@@ -271,19 +280,38 @@ export class RisexAdapter {
             if (x.maker_side !== "BUY" && x.maker_side !== "SELL")
                 throw new PerpError("EXCHANGE_ERROR", `RISEx trade maker_side ${String(x.maker_side)}`, { exchange: "risex" });
             // The tape side is the taker's: a SELL maker means a buy took it.
-            // 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 { time: nsToMs(str(x.time, "trade time")), symbol: sym, side: x.maker_side === "SELL" ? "buy" : "sell", price: decReq(x.price, "trade price"), size: decReq(x.size, "trade size"), fee: null };
         });
     }
+    /**
+     * Settled hourly prints, newest first. The API defaults `start_time` to now − 7 d (168 rows, any
+     * `limit`), so the window is sent explicitly (`limit` hours back, one spare) and pages are
+     * followed with `page` / `has_next_page` (max 1000 rows per page; developer.rise.trade
+     * getfundingratehistory; verified live 2026-10-19).
+     */
     async getFundingHistory(symbol, limit = 100) {
+        if (!Number.isInteger(limit) || limit < 1)
+            throw new PerpError("INVALID_PARAMS", `RISEx: funding history limit must be a positive integer (got ${limit})`);
         const m = await this.market(symbol);
-        const d = await this.client.get(`/v1/markets/id/${m.market_id}/funding-rate-history`, { limit: Math.min(limit, 1000) });
-        if (!Array.isArray(d.records))
-            throw new PerpError("EXCHANGE_ERROR", "RISEx funding-rate-history: no records", { exchange: "risex" });
-        return d.records.map(r => {
-            const x = r;
-            return { time: nsToMs(str(x.end_time, "funding end_time")), rate: decReq(x.funding_rate, "funding_rate"), price: positiveOrNull(x.index_price) };
-        });
+        const startNs = (BigInt(Date.now() - (limit + 1) * 3_600_000) * 1000000n).toString();
+        const perPage = Math.min(limit, RISEX_FUNDING_PAGE_MAX);
+        const out = [];
+        for (let page = 1; out.length < limit; page++) {
+            if (page > RISEX_FUNDING_MAX_PAGES)
+                throw new PerpError("EXCHANGE_ERROR", `RISEx funding-rate-history: still paging after ${RISEX_FUNDING_MAX_PAGES} pages`, { exchange: "risex" });
+            const d = await this.client.get(`/v1/markets/id/${m.market_id}/funding-rate-history`, { limit: perPage, page, start_time: startNs });
+            if (!Array.isArray(d.records))
+                throw new PerpError("EXCHANGE_ERROR", "RISEx funding-rate-history: no records", { exchange: "risex" });
+            for (const r of d.records) {
+                const x = r;
+                out.push({ time: nsToMs(str(x.end_time, "funding end_time")), rate: decReq(x.funding_rate, "funding_rate"), price: positiveOrNull(x.index_price), intervalHours: 1, rateKind: "lastSettled" });
+            }
+            if (d.has_next_page !== true || d.records.length === 0)
+                break;
+        }
+        const seen = new Set();
+        return out.filter(r => (seen.has(r.time) ? false : (seen.add(r.time), true))).sort((a, b) => b.time - a.time).slice(0, limit);
     }
     async getKlines(symbol, interval, startTime, endTime) {
         const ms = KLINE_INTERVAL_MS[interval];
@@ -300,6 +328,14 @@ export class RisexAdapter {
             throw new PerpError("EXCHANGE_ERROR", "RISEx trading-view-data: not an array", { exchange: "risex" });
         return d.map(c => {
             const x = c;
+            // The venue answers an interval it does not serve with 1m bars: a row of another interval
+            // is never returned as the requested one.
+            // OHLC are mapped by field name, unscaled. RISEx opens a bar at the PREVIOUS bar's close
+            // while high / low are the bar's own trades, so `open` can lie outside [low, high] (live
+            // 2026-10-19: 2555 of 7187 1m bars, 5 of 121 1h bars; daily bars none). That is the venue's
+            // data, passed through as published — never clamped or "fixed" (documented in the CHANGELOG).
+            // Required on every row here (the field is always sent; null/absent would skip the check).
+            assertCandleInterval("risex", interval, x.interval === undefined ? null : x.interval, `Use one of: ${Object.keys(KLINE_INTERVAL_MS).join(", ")}`);
             return {
                 time: nsToMs(str(x.time, "candle time")),
                 open: decReq(x.open, "open"), high: decReq(x.high, "high"), low: decReq(x.low, "low"), close: decReq(x.close, "close"),
@@ -791,6 +827,16 @@ function historyStatus(o) {
     }
 }
 /** Candle intervals → ms (the venue takes the interval in ns). */
+/**
+ * Candle intervals verified live (2026-10-19, market 1): each returns rows labelled with that
+ * interval. 3m / 30m / 2h / 8h / 12h / 3d are answered with 1m bars (no error), so they are not
+ * listed — getKlines refuses them with INVALID_PARAMS instead of returning 1m candles.
+ */
+export const RISEX_BOOK_MAX = 250;
+export const RISEX_TRADES_CAP = 1000;
+/** funding-rate-history: max rows per page (docs) and pages followed before giving up. */
+export const RISEX_FUNDING_PAGE_MAX = 1000;
+const RISEX_FUNDING_MAX_PAGES = 20;
 export const KLINE_INTERVAL_MS = {
-    "1m": 60_000, "5m": 300_000, "15m": 900_000, "30m": 1_800_000, "1h": 3_600_000, "4h": 14_400_000, "1d": 86_400_000,
+    "1m": 60_000, "5m": 300_000, "15m": 900_000, "1h": 3_600_000, "4h": 14_400_000, "1d": 86_400_000, "1w": 604_800_000,
 };

package/dist/exchanges/spot-factory.js

@@ -427,5 +427,5 @@ export function matchSpotPerp(spotVenue, spotMarkets, perpVenue, perpMarkets, wa
 }
 /** The perp venue's public markets (canonical + asset class + mark) on `net` (default: process network). */
 export function fetchPerpMarketsForMatching(perpVenue, net = sharedApiNetwork()) {
-    return getVenue(perpVenue).publicData.fetchMarkets(net);
+    return getVenue(perpVenue).publicData.fetchMarkets(net, { funding: false });
 }

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

@@ -5,11 +5,22 @@
  * readable (the unofficial API refuses it) and every account / trading method refuses with
  * CAPABILITY_UNSUPPORTED before any request — there is no TxFlow account or order code.
  */
-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 VenueDefinition } from "../venue.js";
 import { type Network, type VenueMarket } from "../venue-types.js";
-/** Candle intervals the TxFlow app requests (HL-style). */
+/**
+ * Candle intervals that return bars (verified live 2026-10-19, coin 1). 3d / 1w / 1M are
+ * accepted by the API but answer [] for every window, so they are not offered.
+ */
+export declare const TXFLOW_KLINE_MS: Readonly<Record<string, number>>;
 export declare const TXFLOW_KLINE_INTERVALS: ReadonlySet<string>;
+/**
+ * candleSnapshot answers `200 []` (no error) when the window spans more than ~3000 bars
+ * (measured 2026-10-19: 3000 bars OK, 3050 → [] at 1h; same at 1m / 5m / 1d), so ranges are
+ * read in windows of at most 2900 bars and merged.
+ */
+export declare const TXFLOW_KLINE_WINDOW_BARS = 2900;
+export declare const TXFLOW_KLINE_MAX_WINDOWS = 50;
 /** Legacy market row plus the labels every TxFlow row carries in JSON output. */
 export type TxflowMarketInfo = ExchangeMarketInfo & {
     venueApi: "unofficial";
@@ -31,11 +42,7 @@ export declare class TxflowPublicAdapter implements ExchangeAdapter {
         asks: [string, string][];
     }>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangePublicTrade[]>;
-    getFundingHistory(): Promise<{
-        time: number;
-        rate: string;
-        price: string | null;
-    }[]>;
+    getFundingHistory(): Promise<FundingHistoryRow[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     private refuse;
     getBalance(): Promise<ExchangeBalance>;