perp-cli 0.14.3 → 0.16.0

package/dist/exchanges/qfex/public.js

@@ -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).
@@ -103,26 +112,24 @@ export function toQfexInstrument(raw) {
         marketHours: hours !== null && typeof hours === "object" && !Array.isArray(hours) ? hours : null,
     };
 }
-/** 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 function qfexTradable(i) {
     return i.status === "ACTIVE" && i.quoteAsset === "USD";
 }
 // ── 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/signing.d.ts

@@ -1,5 +1,5 @@
 /**
- * QFEX request signing + wire-number conversion (design §14.2, §14.3).
+ * QFEX request signing + wire-number conversion.
  *
  * Auth (docs /websocket/channels/trade/authenticate, OpenAPI securitySchemes):
  *   signature = hex(HMAC-SHA256(secret, `${nonce}:${unix_ts}`))
@@ -12,7 +12,7 @@
  * fromWireNumber are the only places a decimal string becomes a float or the reverse.
  *
  * Wire facts that needed a live check are single constants here; while one is unset every code
- * path that needs it refuses with the uniform CAPABILITY_UNSUPPORTED response (design §14.12).
+ * path that needs it refuses with the uniform CAPABILITY_UNSUPPORTED response.
  */
 import { PerpError } from "../../errors.js";
 export interface QfexCredentials {

package/dist/exchanges/qfex/signing.js

@@ -1,5 +1,5 @@
 /**
- * QFEX request signing + wire-number conversion (design §14.2, §14.3).
+ * QFEX request signing + wire-number conversion.
  *
  * Auth (docs /websocket/channels/trade/authenticate, OpenAPI securitySchemes):
  *   signature = hex(HMAC-SHA256(secret, `${nonce}:${unix_ts}`))
@@ -12,7 +12,7 @@
  * fromWireNumber are the only places a decimal string becomes a float or the reverse.
  *
  * Wire facts that needed a live check are single constants here; while one is unset every code
- * path that needs it refuses with the uniform CAPABILITY_UNSUPPORTED response (design §14.12).
+ * path that needs it refuses with the uniform CAPABILITY_UNSUPPORTED response.
  */
 import { createHmac, randomBytes } from "node:crypto";
 import { PerpError } from "../../errors.js";
@@ -108,8 +108,7 @@ export const QFEX_MODIFY_KEEPS_CLIENT_ID = true;
  * (it may be the user id). true → a mismatch is ORDER_PENDING.
  */
 export const QFEX_USER_ID_IS_ACCOUNT = null;
-const Q2_REMEDIATION = "Reduce / close the position on the QFEX web app. perp-cli sends reduce-only orders on QFEX only with the wire format of item Q2 "
-    + "(docs/TEST-PLAN.md) set";
+const Q2_REMEDIATION = "Reduce / close the position on the QFEX web app. perp-cli sends reduce-only orders on QFEX only with the wire format of item Q2 set";
 /** The uniform refusal of every reduce-only path when the wire format is unset; null when it is set. */
 export function qfexReduceOnlyGate(wire) {
     if (wire !== null)
@@ -121,7 +120,7 @@ export function qfexAutomationGate(verified) {
     if (verified === true)
         return null;
     return unsupported("qfex", "automation", "funding is unverified (Q4) and a resting reduce-only order the market reaches while flat is not proven harmless (Q2), and no automated flow places its own protective stop yet", "Trade QFEX with the manual commands (perp trade market / limit / stop / tpsl / close / reduce / close-all / flatten -e qfex) and watch the position yourself; "
-        + "automation opens once docs/TEST-PLAN.md QFEX items Q2 / Q4 are settled");
+        + "automation opens once QFEX items Q2 / Q4 are settled");
 }
 /** `reduce_only` value for the wire in the verified format. */
 export function reduceOnlyWireValue(wire, reduceOnly) {

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

@@ -1,5 +1,5 @@
 /**
- * QFEX Trade WebSocket transport (design §14.2 as amended by §14.12 #2, #3, #4, #11, #13).
+ * QFEX Trade WebSocket transport.
  *
  * The venue has no request id. Correlation therefore rests on four rules:
  *  1. ONE command at a time per connection (FIFO) — reads share the queue.
@@ -94,7 +94,7 @@ export interface QfexFillResponse {
 export declare function orderResponseOf(frame: QfexFrame): QfexOrderResponse | null;
 export declare function fillResponseOf(frame: QfexFrame): QfexFillResponse | null;
 /**
- * Error frame in any documented shape (design §14.12 #11):
+ * Error frame in any documented shape:
  *   { "err": { error_code, message, incoming_message } }            /websocket/errors + AsyncAPI
  *   { "type": "Err", error_code, message, incoming_message }         /websocket/rate
  *   { "type": "error", error_code, message }                         the docs' own client samples
@@ -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/qfex/ws-transport.js

@@ -1,5 +1,5 @@
 /**
- * QFEX Trade WebSocket transport (design §14.2 as amended by §14.12 #2, #3, #4, #11, #13).
+ * QFEX Trade WebSocket transport.
  *
  * The venue has no request id. Correlation therefore rests on four rules:
  *  1. ONE command at a time per connection (FIFO) — reads share the queue.
@@ -66,7 +66,7 @@ export function fillResponseOf(frame) {
     return r;
 }
 /**
- * Error frame in any documented shape (design §14.12 #11):
+ * Error frame in any documented shape:
  *   { "err": { error_code, message, incoming_message } }            /websocket/errors + AsyncAPI
  *   { "type": "Err", error_code, message, incoming_message }         /websocket/rate
  *   { "type": "error", error_code, message }                         the docs' own client samples
@@ -86,7 +86,7 @@ export function errFrameOf(frame) {
         : null;
     return { errorCode: body.error_code, message: typeof body.message === "string" ? body.message : null, echo };
 }
-/** Auth outcome frame: both documented success shapes are accepted (§14.12 #11). */
+/** Auth outcome frame: both documented success shapes are accepted. */
 function authVerdictOf(frame) {
     if (typeof frame.authenticated === "boolean")
         return frame.authenticated;

package/dist/exchanges/rate-limiter.d.ts

@@ -1,5 +1,5 @@
 /**
- * Per-process token-bucket rate limiter keyed by venue (design §3 L4, §10.9).
+ * Per-process token-bucket rate limiter keyed by venue.
  *
  * Limitation (documented): this only coordinates requests inside one process.
  * CLI + MCP server + bots running at once can still exceed a venue's limit.

package/dist/exchanges/rate-limiter.js

@@ -1,5 +1,5 @@
 /**
- * Per-process token-bucket rate limiter keyed by venue (design §3 L4, §10.9).
+ * Per-process token-bucket rate limiter keyed by venue.
  *
  * Limitation (documented): this only coordinates requests inside one process.
  * CLI + MCP server + bots running at once can still exceed a venue's limit.
@@ -19,7 +19,10 @@ class TokenBucket {
     }
     refill() {
         const now = Date.now();
-        this.tokens = Math.min(this.policy.capacity, this.tokens + ((now - this.last) / 1000) * this.policy.refillPerSec);
+        // Clamped: a wall clock stepping backwards (NTP, VM resume, fake timers) must not drive the bucket
+        // negative and stall every request until the clock catches up.
+        const elapsedMs = Math.max(0, now - this.last);
+        this.tokens = Math.min(this.policy.capacity, this.tokens + (elapsedMs / 1000) * this.policy.refillPerSec);
         this.last = now;
     }
     acquire(weight) {

package/dist/exchanges/registry.d.ts

@@ -1,6 +1,6 @@
 /**
  * Adapter registry — legacy name/alias API, now derived from the venue
- * definitions (src/exchanges/venues/, design §10.10). New venues are added by
+ * definitions (src/exchanges/venues/). New venues are added by
  * registering a VenueDefinition, not here.
  */
 import "./venues/index.js";

package/dist/exchanges/registry.js

@@ -1,6 +1,6 @@
 /**
  * Adapter registry — legacy name/alias API, now derived from the venue
- * definitions (src/exchanges/venues/, design §10.10). New venues are added by
+ * definitions (src/exchanges/venues/). New venues are added by
  * registering a VenueDefinition, not here.
  */
 import { getVenue, listVenues, tryResolveVenueId } from "./venue.js";

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

@@ -0,0 +1,160 @@
+/**
+ * RISEx adapter — market data (public), account reads (public by address) and trading through the
+ * registered, trading-only session signer (EIP-712 VerifyWitness permits; the server submits the
+ * on-chain transaction and pays gas).
+ *
+ * Account address: the signer's account (agent meta), else the master wallet's address (reads
+ * only, nothing is signed with it here). Writes need the signer.
+ *
+ * Order safety:
+ *  - every refusal (market flags, maintenance, precision, pins) happens before a nonce is
+ *    allocated or anything is signed;
+ *  - every permit consumes a fresh (anchor, bit) pair that is persisted BEFORE the send, so a
+ *    pair is never reused, even when the outcome is unknown;
+ *  - a client order id is always attached (generated uint64 when the caller gives none);
+ *  - an unknown send outcome → one read-only reconciliation (permit nonce consumed on-chain? the
+ *    client order id in open orders / order history?) → a proven result carries notes
+ *    ["reconciled"]; otherwise ORDER_PENDING ("do NOT resubmit") and the symbol is quarantined.
+ *    The permit deadline is short (RISEX_PERMIT_TTL_S), so an unproven permit expires quickly.
+ */
+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, FundingHistoryRow } from "../interface.js";
+import type { ResolvedSlippage } from "../slippage.js";
+import { type TradingV2 } from "../trading-v2.js";
+import type { VenueCreateContext, VenueDefinition } from "../venue.js";
+import { type AmendRequest, type CancelResult, type LeverageResult, type Network, type OrderRef, type OrderRequest, type OrderResult, type VenueMarket } from "../venue-types.js";
+import { type RisexChainReader } from "./session.js";
+/** Permit lifetime: long enough for the server to submit, short enough that an unproven permit expires soon. */
+export declare const RISEX_PERMIT_TTL_S = 120;
+/** How long a successful on-chain trading-only proof is trusted before the next permit re-checks it. */
+export declare const RISEX_TRADING_ONLY_TTL_MS = 60000;
+export interface RisexAdapterDeps {
+    /** Account the reads and permits are for; null = public market data only. */
+    account: string | null;
+    /** Trading-only session signer; null = no trading. */
+    signer: EvmSigner | null;
+    /** Agent meta the signer came from (for messages); null when none. */
+    meta: RisexAgentMeta | null;
+    /** Why trading is unavailable when `signer` is null (the uniform refusal). */
+    noSignerReason: PerpError | null;
+    nonceDir?: string;
+    chain?: RisexChainReader;
+    sleep?: (ms: number) => Promise<void>;
+    /** Quarantine hook for unknown outcomes (default: bot/quarantine.ts). */
+    quarantine?: (symbol: string, reason: string, remediation: string) => void;
+}
+export declare class RisexAdapter implements ExchangeAdapter, TradingV2 {
+    readonly name: "risex";
+    readonly aliases: readonly ["rise"];
+    readonly venue: VenueDefinition;
+    readonly network: Network;
+    private readonly client;
+    private readonly deps;
+    private markets;
+    constructor(def: VenueDefinition, network: Network, deps: RisexAdapterDeps);
+    /** Resolve the account and the trading-only signer from the create context (OWS only). */
+    static create(def: VenueDefinition, ctx: VenueCreateContext): Promise<RisexAdapter>;
+    /**
+     * Trading capabilities — also the adapter-level release gate: while the trading role is gated
+     * (risex-release.ts) this throws CAPABILITY_UNSUPPORTED before any validation, nonce or
+     * signature. Read paths never touch it, so the adapter still serves market data / account reads.
+     */
+    private get caps();
+    private requireAccount;
+    private requireSigner;
+    private sleep;
+    private rawMarkets;
+    /** Active market by symbol ("BTC", "BTC/USDC", "BTC-PERP") or market id. */
+    private market;
+    private symbolOfId;
+    /**
+     * The on-chain trading-only proof, re-checked at most every RISEX_TRADING_ONLY_TTL_MS before a
+     * permit (long-lived adapters — perp-mcp, bots — must notice a contract upgrade). A failed proof
+     * (refusal or RPC error) is never cached.
+     */
+    private tradingOnlyProof;
+    private permit;
+    private chainRead;
+    private quarantine;
+    /** The account reads / permits are for (signer's account, else the master address). */
+    accountAddress(): string;
+    /** Testnet faucet: 1000 test USDC, once per wallet (also registers the account). Refused on mainnet. */
+    testnetFaucet(): Promise<{
+        txHash: string | null;
+    }>;
+    getVenueMarkets(): Promise<VenueMarket[]>;
+    /** Legacy rows plus the venue's market-level order restrictions. */
+    getMarkets(): Promise<Array<ExchangeMarketInfo & {
+        marketId: string;
+        reduceOnlyMarket: boolean;
+        postOnlyMarket: boolean;
+        tradable: boolean;
+    }>>;
+    /** `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[]>;
+    /**
+     * 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>;
+    getPositions(): Promise<ExchangePosition[]>;
+    private openOrdersRaw;
+    private historyOrders;
+    private toExchangeOrder;
+    /** On-chain open orders, enriched with the indexer's decimals / fills (one retry for indexer lag). */
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    /** `payment` is positive when RECEIVED (RISEx `funding_payment` is positive when paid — negated here). */
+    getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+    placeOrder(req: OrderRequest): Promise<OrderResult>;
+    /** One read-only reconciliation of an unknown place outcome. */
+    private reconcilePlace;
+    amendOrder(_req: AmendRequest): Promise<OrderResult>;
+    cancelByRef(symbol: string, ref: OrderRef): Promise<CancelResult>;
+    cancelAllV2(symbol: string | null): Promise<CancelResult>;
+    applyLeverage(symbol: string, leverage: number, marginMode: "cross" | "isolated" | null): Promise<LeverageResult>;
+    private sendAccountAction;
+    getOrderStatus(symbol: string, ref: OrderRef): Promise<OrderResult>;
+    marketOrder(symbol: string, side: "buy" | "sell", size: string, opts: {
+        reduceOnly: boolean;
+        slippage: ResolvedSlippage;
+        clientOrderId?: string;
+    }): Promise<unknown>;
+    limitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        reduceOnly?: boolean;
+        tif?: string;
+        clientOrderId?: string;
+    }): Promise<unknown>;
+    editOrder(): Promise<unknown>;
+    cancelOrder(symbol: string, orderId: string): Promise<unknown>;
+    cancelAllOrders(symbol?: string): Promise<unknown>;
+    setLeverage(symbol: string, leverage: number, marginMode?: "cross" | "isolated"): Promise<unknown>;
+    stopOrder(): Promise<unknown>;
+    /** TP/SL entries are refused before the entry is sent (not implemented yet). */
+    stopOrderGate(): PerpError;
+    /** Bots / TWAP / grid / funding-arb legs stay off until RISEx trading is verified on mainnet. */
+    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>>;