perp-cli 0.14.2 → 0.15.0

package/dist/exchanges/risex/client.js

@@ -0,0 +1,174 @@
+/**
+ * RISEx REST transport.
+ *
+ * Every response is `{data, request_id}` on success or `{error:{code, message}, request_id}` on
+ * failure, where `code` is a gRPC status name ("InvalidArgument", "FailedPrecondition",
+ * "Unauthenticated", "ResourceExhausted", "Internal", "Unavailable", …) and the message may carry a
+ * decoded contract revert ("FailedPrecondition: PlaceOrder reverted: SignerNotAuthorized(address)").
+ *
+ * Reads (GET) map to EXCHANGE_UNREACHABLE / EXCHANGE_ERROR / RATE_LIMITED. Writes (POST) are
+ * NEVER retried and classify their outcome:
+ *   - no connection at all                          → not sent (definite, `sent: false`)
+ *   - 4xx gRPC rejection (InvalidArgument, FailedPrecondition, Unauthenticated, NotFound,
+ *     PermissionDenied, OutOfRange, AlreadyExists)  → definite rejection (`sent: false` /
+ *     ORDER_REJECTED) with the decoded error name
+ *   - 429 ResourceExhausted                         → RATE_LIMITED, definite (`sent: false`)
+ *   - timeout, reset, 5xx (E0701 ChainTransactionFailed, E0702 SequencerUnavailable, …),
+ *     an unreadable body                            → outcome UNKNOWN (RisexSendUnknown)
+ */
+import { PerpError, extractErrorMessage, isConnectFailure } from "../../errors.js";
+import { acquireRate, rateLimitedError } from "../rate-limiter.js";
+export const RISEX_HTTP_TIMEOUT_MS = 30_000;
+/** gRPC codes that are a definite refusal of the request (nothing executed). */
+const DEFINITE_REJECT_CODES = new Set([
+    "InvalidArgument", "FailedPrecondition", "Unauthenticated", "NotFound", "PermissionDenied", "OutOfRange", "AlreadyExists",
+]);
+/** Decoded contract error name in a revert message ("… reverted: InvalidNonceIndex(uint8) => (208)" → "InvalidNonceIndex"). */
+export function revertNameOf(message) {
+    const m = /reverted:\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/.exec(message);
+    return m ? m[1] : null;
+}
+/** The send of a write could not be classified: it may have executed. Carries the cause for the caller's reconciliation. */
+export class RisexSendUnknown extends Error {
+    what;
+    cause;
+    status;
+    constructor(what, cause, status) {
+        super(`${what}: outcome unknown — ${extractErrorMessage(cause)}`);
+        this.what = what;
+        this.cause = cause;
+        this.status = status;
+        this.name = "RisexSendUnknown";
+    }
+}
+function errorBodyOf(parsed) {
+    const e = parsed?.error;
+    if (e === null || typeof e !== "object")
+        return null;
+    const code = e.code;
+    const message = e.message;
+    return { code: typeof code === "string" ? code : "Unknown", message: typeof message === "string" ? message : JSON.stringify(e) };
+}
+function readError(path, status, body, text) {
+    const msg = body !== null ? `${body.code}: ${body.message}` : `HTTP ${status} ${text.slice(0, 200)}`;
+    if (status === 404 || body?.code === "NotFound") {
+        return new PerpError("EXCHANGE_ERROR", `RISEx ${path}: ${msg}`, { exchange: "risex", status });
+    }
+    if (body?.code === "InvalidArgument") {
+        return new PerpError("INVALID_PARAMS", `RISEx ${path}: ${msg}`, { exchange: "risex", status });
+    }
+    if (status >= 500 || body?.code === "Unavailable" || body?.code === "Internal") {
+        return new PerpError("EXCHANGE_UNREACHABLE", `RISEx ${path}: ${msg}`, { exchange: "risex", status });
+    }
+    return new PerpError("EXCHANGE_ERROR", `RISEx ${path}: ${msg}`, { exchange: "risex", status });
+}
+export class RisexClient {
+    restUrl;
+    rateLimit;
+    rateKey;
+    constructor(restUrl, rateLimit, rateKey) {
+        this.restUrl = restUrl;
+        this.rateLimit = rateLimit;
+        this.rateKey = rateKey;
+    }
+    url(path, query) {
+        const u = new URL(this.restUrl + path);
+        if (query)
+            for (const [k, v] of Object.entries(query))
+                if (v !== null && v !== undefined)
+                    u.searchParams.set(k, String(v));
+        return u.toString();
+    }
+    /** GET → `data`. */
+    async get(path, query) {
+        await acquireRate(this.rateKey, this.rateLimit, path);
+        let res;
+        try {
+            res = await fetch(this.url(path, query), { method: "GET", signal: AbortSignal.timeout(RISEX_HTTP_TIMEOUT_MS) });
+        }
+        catch (e) {
+            throw new PerpError("EXCHANGE_UNREACHABLE", `RISEx ${path}: ${extractErrorMessage(e)}`, { exchange: "risex" });
+        }
+        let text;
+        try {
+            text = await res.text();
+        }
+        catch (e) {
+            throw new PerpError("EXCHANGE_UNREACHABLE", `RISEx ${path}: response body unreadable (${extractErrorMessage(e)})`, { exchange: "risex" });
+        }
+        if (res.status === 429)
+            throw rateLimitedError("risex", res.headers.get("retry-after"), text);
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = undefined;
+        }
+        const err = errorBodyOf(parsed);
+        if (!res.ok || err !== null)
+            throw readError(path, res.status, err, text);
+        const data = parsed?.data;
+        if (data === undefined || data === null) {
+            throw new PerpError("EXCHANGE_ERROR", `RISEx ${path}: response has no data`, { exchange: "risex", status: res.status });
+        }
+        return data;
+    }
+    /**
+     * POST a write. Returns `data` on success. Definite refusals throw a PerpError with
+     * `details.sent === false`; anything that may have executed throws RisexSendUnknown.
+     */
+    async post(path, body, what) {
+        await acquireRate(this.rateKey, this.rateLimit, path);
+        let res;
+        try {
+            res = await fetch(this.url(path), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(RISEX_HTTP_TIMEOUT_MS),
+            });
+        }
+        catch (e) {
+            if (isConnectFailure(e)) {
+                throw new PerpError("EXCHANGE_UNREACHABLE", `RISEx ${what}: could not connect — nothing was sent`, { exchange: "risex", sent: false });
+            }
+            throw new RisexSendUnknown(`RISEx ${what}`, e, null);
+        }
+        let text;
+        try {
+            text = await res.text();
+        }
+        catch (e) {
+            throw new RisexSendUnknown(`RISEx ${what}`, e, res.status);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = undefined;
+        }
+        const err = errorBodyOf(parsed);
+        if (res.status === 429 || err?.code === "ResourceExhausted") {
+            const r = rateLimitedError("risex", res.headers.get("retry-after"), text);
+            throw new PerpError("RATE_LIMITED", `RISEx ${what} refused: ${err !== null ? err.message : "rate limited"}`, {
+                ...(r.structured.details ?? {}), exchange: "risex", sent: false,
+                remediation: "Nothing was executed. Wait, then retry (RISEx also applies a per-address transaction quota: +1 per $5 traded)",
+            });
+        }
+        if (err !== null && res.status >= 400 && res.status < 500 && DEFINITE_REJECT_CODES.has(err.code)) {
+            const revert = revertNameOf(err.message);
+            throw new PerpError("ORDER_REJECTED", `RISEx ${what} rejected: ${err.code}: ${err.message}`, {
+                exchange: "risex", sent: false, grpcCode: err.code, ...(revert !== null ? { revert } : {}),
+            });
+        }
+        if (!res.ok || err !== null || parsed === undefined) {
+            throw new RisexSendUnknown(`RISEx ${what}`, new Error(err !== null ? `${err.code}: ${err.message}` : `HTTP ${res.status} ${text.slice(0, 200)}`), res.status);
+        }
+        const data = parsed.data;
+        if (data === undefined || data === null)
+            throw new RisexSendUnknown(`RISEx ${what}`, new Error("response has no data"), res.status);
+        return data;
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * RISEx permit nonces: (anchor uint48, bit 0..207) pairs, each consumable once on-chain.
+ *
+ * Allocation (one per signed action), under an exclusive per-account file lock:
+ *   remote  = GET /v1/nonce-state/{account}  → nonce_anchor A
+ *   base    = (A + 1, bit 0)                  — "sign with nonce_anchor + 1 and start at bit 0"
+ *   local   = last pair THIS machine handed out for the account (~/.perp/risex-nonce/…)
+ *   next    = local successor when local ≥ base (bit + 1; after bit 207 the next anchor), else base
+ * The contract accepts only the current anchor or current + 1, so a successor beyond A + 1 (208
+ * permits signed on A + 1 while the chain has not caught up) is refused, never guessed.
+ * `current_bitmap_index` describes the CURRENT anchor A, which perp-cli deliberately never signs on
+ * (developer.rise.trade "Integration" → Nonces: "Sign with nonce_anchor + 1 and start at bit 0 …
+ * starting a fresh anchor guarantees you cannot collide with a permit already in flight"), so it
+ * does not enter the rule. Gaps in a bitmap are harmless (same doc).
+ *
+ * The allocated pair is persisted BEFORE the caller signs or sends: a pair is handed out once and
+ * never reused, even when the send fails or its outcome is unknown (an unknown outcome burns the
+ * bit). Restart-safe: the next allocation takes the max of the chain state and the local file.
+ * The state file holds no secrets.
+ */
+import type { Network } from "../venue-types.js";
+import type { NonceSlot } from "./typed-data.js";
+export declare const RISEX_MAX_BIT = 207;
+export interface RemoteNonceState {
+    anchor: bigint;
+    currentBitmapIndex: number;
+}
+export declare function risexNonceDir(): string;
+/** Pure allocation rule (see module doc). */
+export declare function nextSlot(remote: RemoteNonceState, local: NonceSlot | null): NonceSlot;
+export declare function parseRemoteNonceState(data: unknown): RemoteNonceState;
+/**
+ * Allocate one nonce pair for `account` and persist it before returning (burned from here on).
+ * `fetchRemote` reads /v1/nonce-state inside the lock.
+ */
+export declare function allocateNonce(net: Network, account: string, fetchRemote: () => Promise<RemoteNonceState>, dir?: string): Promise<NonceSlot>;
+/** Last pair handed out on this machine (diagnostics / reconciliation), or null. */
+export declare function lastAllocated(net: Network, account: string, dir?: string): NonceSlot | null;
+/** Whether (anchor, bit) is consumed according to /v1/nonce-state's `bitmap` (only when the anchor matches). null = cannot tell. */
+export declare function bitConsumed(state: {
+    anchor: bigint;
+    bitmap: string | null;
+}, slot: NonceSlot): boolean | null;

package/dist/exchanges/risex/nonce.js

@@ -0,0 +1,212 @@
+/**
+ * RISEx permit nonces: (anchor uint48, bit 0..207) pairs, each consumable once on-chain.
+ *
+ * Allocation (one per signed action), under an exclusive per-account file lock:
+ *   remote  = GET /v1/nonce-state/{account}  → nonce_anchor A
+ *   base    = (A + 1, bit 0)                  — "sign with nonce_anchor + 1 and start at bit 0"
+ *   local   = last pair THIS machine handed out for the account (~/.perp/risex-nonce/…)
+ *   next    = local successor when local ≥ base (bit + 1; after bit 207 the next anchor), else base
+ * The contract accepts only the current anchor or current + 1, so a successor beyond A + 1 (208
+ * permits signed on A + 1 while the chain has not caught up) is refused, never guessed.
+ * `current_bitmap_index` describes the CURRENT anchor A, which perp-cli deliberately never signs on
+ * (developer.rise.trade "Integration" → Nonces: "Sign with nonce_anchor + 1 and start at bit 0 …
+ * starting a fresh anchor guarantees you cannot collide with a permit already in flight"), so it
+ * does not enter the rule. Gaps in a bitmap are harmless (same doc).
+ *
+ * The allocated pair is persisted BEFORE the caller signs or sends: a pair is handed out once and
+ * never reused, even when the send fails or its outcome is unknown (an unknown outcome burns the
+ * bit). Restart-safe: the next allocation takes the max of the chain state and the local file.
+ * The state file holds no secrets.
+ */
+import { existsSync, linkSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { PerpError } from "../../errors.js";
+export const RISEX_MAX_BIT = 207;
+const LOCK_WAIT_MS = 5_000;
+const LOCK_STALE_MS = 60_000;
+export function risexNonceDir() {
+    return resolve(process.env.HOME || "~", ".perp", "risex-nonce");
+}
+function statePath(dir, net, account) {
+    return resolve(dir, `${net}-${account.toLowerCase()}.json`);
+}
+function readLocal(path) {
+    if (!existsSync(path))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        parsed = null;
+    }
+    const p = parsed;
+    if (p === null || typeof p.anchor !== "string" || !/^\d+$/.test(p.anchor) || typeof p.bit !== "number" || !Number.isInteger(p.bit) || p.bit < 0 || p.bit > RISEX_MAX_BIT) {
+        throw new PerpError("INVALID_PARAMS", `RISEx nonce state ${path} is corrupt`, {
+            exchange: "risex",
+            remediation: `Delete ${path} (it only records the last permit nonce handed out; the chain state is re-read) and retry`,
+        });
+    }
+    return { anchor: BigInt(p.anchor), bit: p.bit };
+}
+function writeLocal(path, slot) {
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ anchor: slot.anchor.toString(), bit: slot.bit, updatedAt: new Date().toISOString() }), { mode: 0o600 });
+    renameSync(tmp, path);
+}
+function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+/**
+ * A lock is stale only when it is older than LOCK_STALE_MS AND its holder process is gone. A young
+ * lock, a live holder, or unparseable content (never written that way — the lock is linked into
+ * place complete) is respected.
+ */
+function lockIsStale(content, mtimeMs) {
+    if (Date.now() - mtimeMs <= LOCK_STALE_MS)
+        return false;
+    const pid = Number(content.split("\n")[0]);
+    return !pidAlive(pid);
+}
+/**
+ * Take over a stale lock without racing another process doing the same: the lock is RENAMED to a
+ * name unique to this process (atomic — only one taker wins), and only if the moved file is still
+ * the one judged stale is it deleted; a fresh lock moved by mistake is put back (link fails if a
+ * new lock already exists, in which case that one stands).
+ */
+function takeOverStale(lock, seen) {
+    const mine = `${lock}.stale.${process.pid}.${Math.random().toString(36).slice(2)}`;
+    try {
+        renameSync(lock, mine);
+    }
+    catch {
+        return;
+    } // another process took it first
+    let moved = null;
+    try {
+        moved = readFileSync(mine, "utf-8");
+    }
+    catch { /* vanished */ }
+    if (moved !== null && moved !== seen) {
+        try {
+            linkSync(mine, lock);
+        }
+        catch { /* a newer lock exists: it stands */ }
+    }
+    try {
+        unlinkSync(mine);
+    }
+    catch { /* already gone */ }
+}
+async function withLock(path, fn) {
+    const lock = `${path}.lock`;
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    const token = `${process.pid}\n${Date.now()}\n${Math.random().toString(36).slice(2)}`;
+    for (;;) {
+        // The lock is written to a private temp file first and LINKED into place (link fails if the
+        // lock exists), so a reader never sees an empty or partial lock.
+        const tmp = `${lock}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+        writeFileSync(tmp, token, { mode: 0o600 });
+        try {
+            linkSync(tmp, lock);
+            unlinkSync(tmp);
+            break;
+        }
+        catch (e) {
+            try {
+                unlinkSync(tmp);
+            }
+            catch { /* gone */ }
+            if (e.code !== "EEXIST")
+                throw e;
+            let content;
+            let mtimeMs;
+            try {
+                content = readFileSync(lock, "utf-8");
+                mtimeMs = statSync(lock).mtimeMs;
+            }
+            catch {
+                continue;
+            } // released between the open and the read: try again
+            if (lockIsStale(content, mtimeMs)) {
+                takeOverStale(lock, content);
+                continue;
+            }
+            if (Date.now() > deadline) {
+                throw new PerpError("LOCK_HELD", `RISEx nonce state is locked by another perp process (${lock})`, {
+                    exchange: "risex", remediation: `Retry shortly; if no other perp process is running, delete ${lock}`,
+                });
+            }
+            await new Promise(r => setTimeout(r, 25));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        // Release only our own lock (never one a stale-takeover replaced).
+        try {
+            if (readFileSync(lock, "utf-8") === token)
+                unlinkSync(lock);
+        }
+        catch { /* already gone */ }
+    }
+}
+/** Pure allocation rule (see module doc). */
+export function nextSlot(remote, local) {
+    const base = { anchor: remote.anchor + 1n, bit: 0 };
+    let next = base;
+    if (local !== null && (local.anchor > base.anchor || (local.anchor === base.anchor && local.bit >= base.bit))) {
+        next = local.bit + 1 > RISEX_MAX_BIT ? { anchor: local.anchor + 1n, bit: 0 } : { anchor: local.anchor, bit: local.bit + 1 };
+    }
+    if (next.anchor > remote.anchor + 1n) {
+        throw new PerpError("EXCHANGE_ERROR", `RISEx nonce anchor ${remote.anchor + 1n} is used up locally and the chain still reports anchor ${remote.anchor} — nothing was signed`, {
+            exchange: "risex", remediation: "Wait a few seconds for pending RISEx actions to land, then retry",
+        });
+    }
+    return next;
+}
+export function parseRemoteNonceState(data) {
+    const d = data;
+    if (d === null || typeof d.nonce_anchor !== "string" || !/^\d+$/.test(d.nonce_anchor) || typeof d.current_bitmap_index !== "number") {
+        throw new PerpError("EXCHANGE_ERROR", `RISEx /v1/nonce-state: malformed response ${JSON.stringify(data).slice(0, 120)}`, { exchange: "risex" });
+    }
+    return { anchor: BigInt(d.nonce_anchor), currentBitmapIndex: d.current_bitmap_index };
+}
+/**
+ * Allocate one nonce pair for `account` and persist it before returning (burned from here on).
+ * `fetchRemote` reads /v1/nonce-state inside the lock.
+ */
+export async function allocateNonce(net, account, fetchRemote, dir = risexNonceDir()) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const path = statePath(dir, net, account);
+    return withLock(path, async () => {
+        const remote = await fetchRemote();
+        const slot = nextSlot(remote, readLocal(path));
+        writeLocal(path, slot);
+        return slot;
+    });
+}
+/** Last pair handed out on this machine (diagnostics / reconciliation), or null. */
+export function lastAllocated(net, account, dir = risexNonceDir()) {
+    return readLocal(statePath(dir, net, account));
+}
+/** Whether (anchor, bit) is consumed according to /v1/nonce-state's `bitmap` (only when the anchor matches). null = cannot tell. */
+export function bitConsumed(state, slot) {
+    if (state.anchor > slot.anchor)
+        return null; // the chain moved past this anchor: the bitmap no longer describes it
+    if (state.anchor < slot.anchor)
+        return false; // the anchor was never reached on-chain
+    if (state.bitmap === null || !/^0x[0-9a-fA-F]+$/.test(state.bitmap))
+        return null;
+    return ((BigInt(state.bitmap) >> BigInt(slot.bit)) & 1n) === 1n;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * RISEx public market data — GET /v1/markets (one call serves markets and funding).
+ *
+ * Mapping:
+ *  - symbol: config.name "BTC/USDC" → "BTC"; venueSymbol = market_id ("1").
+ *  - inactive markets (`active: false`, e.g. the deprecated DOGE market 13) are excluded.
+ *    tradable = active && config.unlocked && !reduce_only (a reduce-only market can only close).
+ *  - tick = config.step_price, step = config.step_size, min size = config.min_order_size.
+ *  - assetClass from `category`: crypto / commodity / stocks (→ equity, or etf when tagged
+ *    "etf") / index_etf (→ etf). An unknown category is skipped with a warning.
+ *  - funding: `current_funding_rate` is a FRACTION PER HOUR and equals the last settled print in
+ *    /funding-rate-history (lastSettled) — verified against public funding payments
+ *    (payment = position size × index × rate, 2026-10-14). `funding_interval` is in ns and must
+ *    be 3600e9; a market with another interval gets no funding row (warned).
+ *  - all timestamps are ns → ms.
+ */
+import { type VenuePublicData } from "../venue.js";
+import type { AssetClass, FundingRateBasis, Network, VenueFundingRate, VenueMarket } from "../venue-types.js";
+import { RisexClient } from "./client.js";
+export declare const RISEX_FUNDING_BASIS: FundingRateBasis;
+export declare const RISEX_FUNDING_INTERVAL_NS = "3600000000000";
+export interface RisexMarketConfig {
+    name: string;
+    step_size: string;
+    step_price: string;
+    max_leverage: string;
+    min_order_size: string;
+    unlocked: boolean;
+    match_price_band?: string;
+}
+export interface RisexRawMarket {
+    market_id: string;
+    config: RisexMarketConfig;
+    mark_price?: string;
+    index_price?: string;
+    last_price?: string;
+    open_interest?: string;
+    quote_volume_24h?: string;
+    funding_interval?: string;
+    next_funding_time?: string;
+    current_funding_rate?: string;
+    predicted_funding_rate?: string;
+    post_only: boolean;
+    reduce_only: boolean;
+    active: boolean;
+    category: string;
+    search_tags?: string[];
+}
+export declare function risexClient(net: Network): RisexClient;
+export declare function fetchRisexRawMarkets(client: RisexClient): Promise<RisexRawMarket[]>;
+/**
+ * A listed market: `active` and not a deprecated listing ("DOGE/USDC [deprecated-…]" — testnet keeps
+ * such a market active but locked, next to its replacement with the same base).
+ */
+export declare function isListedRisexMarket(m: Pick<RisexRawMarket, "active" | "config">): boolean;
+/** "BTC/USDC" → "BTC". */
+export declare function risexSymbolOf(m: Pick<RisexRawMarket, "config">): string;
+export declare function risexAssetClass(m: Pick<RisexRawMarket, "category" | "search_tags">): AssetClass | null;
+/** Hourly funding fraction, or null when the market's interval is not one hour / no rate is published. */
+export declare function risexHourlyFunding(m: RisexRawMarket): string | null;
+/** Active markets only (inactive / deprecated markets are excluded). Unknown categories are warned and skipped. */
+export declare function toRisexVenueMarkets(raw: readonly RisexRawMarket[], warn: (msg: string) => void): VenueMarket[];
+export declare function toRisexFundingRates(raw: readonly RisexRawMarket[], markets: readonly VenueMarket[]): VenueFundingRate[];
+export declare const risexPublicData: VenuePublicData;

package/dist/exchanges/risex/public.js

@@ -0,0 +1,150 @@
+/**
+ * RISEx public market data — GET /v1/markets (one call serves markets and funding).
+ *
+ * Mapping:
+ *  - symbol: config.name "BTC/USDC" → "BTC"; venueSymbol = market_id ("1").
+ *  - inactive markets (`active: false`, e.g. the deprecated DOGE market 13) are excluded.
+ *    tradable = active && config.unlocked && !reduce_only (a reduce-only market can only close).
+ *  - tick = config.step_price, step = config.step_size, min size = config.min_order_size.
+ *  - assetClass from `category`: crypto / commodity / stocks (→ equity, or etf when tagged
+ *    "etf") / index_etf (→ etf). An unknown category is skipped with a warning.
+ *  - funding: `current_funding_rate` is a FRACTION PER HOUR and equals the last settled print in
+ *    /funding-rate-history (lastSettled) — verified against public funding payments
+ *    (payment = position size × index × rate, 2026-10-14). `funding_interval` is in ns and must
+ *    be 3600e9; a market with another interval gets no funding row (warned).
+ *  - all timestamps are ns → ms.
+ */
+import { canonicalFor } from "../canonical-symbols.js";
+import { networkConfig } from "../venue.js";
+import { risexVenue } from "../venues/risex.js";
+import { RisexClient } from "./client.js";
+import { decOrNull, nsToMsOrNull, trimDecimal } from "./units.js";
+import { PerpError } from "../../errors.js";
+export const RISEX_FUNDING_BASIS = { kind: "perHours", hours: 1 };
+export const RISEX_FUNDING_INTERVAL_NS = "3600000000000";
+export function risexClient(net) {
+    return new RisexClient(networkConfig(risexVenue, net).restUrl, risexVenue.rateLimit, `risex:${net}`);
+}
+export async function fetchRisexRawMarkets(client) {
+    const data = await client.get("/v1/markets");
+    if (!Array.isArray(data.markets))
+        throw new PerpError("EXCHANGE_ERROR", "RISEx /v1/markets: missing markets array", { exchange: "risex" });
+    for (const m of data.markets) {
+        if (typeof m?.market_id !== "string" || m.config === null || typeof m.config !== "object" || typeof m.config.name !== "string"
+            || typeof m.active !== "boolean" || typeof m.reduce_only !== "boolean" || typeof m.post_only !== "boolean") {
+            throw new PerpError("EXCHANGE_ERROR", `RISEx /v1/markets: malformed market row ${JSON.stringify(m).slice(0, 120)}`, { exchange: "risex" });
+        }
+    }
+    return data.markets;
+}
+/**
+ * A listed market: `active` and not a deprecated listing ("DOGE/USDC [deprecated-…]" — testnet keeps
+ * such a market active but locked, next to its replacement with the same base).
+ */
+export function isListedRisexMarket(m) {
+    return m.active && !/\[deprecated/i.test(m.config.name);
+}
+/** "BTC/USDC" → "BTC". */
+export function risexSymbolOf(m) {
+    const base = m.config.name.split("/")[0].trim().toUpperCase();
+    if (base === "")
+        throw new PerpError("EXCHANGE_ERROR", `RISEx market name "${m.config.name}" has no base`, { exchange: "risex" });
+    return base;
+}
+export function risexAssetClass(m) {
+    switch (m.category) {
+        case "crypto": return "crypto";
+        case "commodity": return "commodity";
+        case "stocks": return (m.search_tags ?? []).includes("etf") ? "etf" : "equity";
+        case "index_etf": return "etf";
+        default: return null;
+    }
+}
+/** Hourly funding fraction, or null when the market's interval is not one hour / no rate is published. */
+export function risexHourlyFunding(m) {
+    if (m.funding_interval !== RISEX_FUNDING_INTERVAL_NS)
+        return null;
+    const r = decOrNull(m.current_funding_rate);
+    return r === null ? null : trimDecimal(r);
+}
+/** Active markets only (inactive / deprecated markets are excluded). Unknown categories are warned and skipped. */
+export function toRisexVenueMarkets(raw, warn) {
+    const out = [];
+    for (const m of raw) {
+        if (!isListedRisexMarket(m))
+            continue;
+        const assetClass = risexAssetClass(m);
+        if (assetClass === null) {
+            warn(`[risex] skipped market ${m.market_id} (${m.config.name}): unknown category "${m.category}"`);
+            continue;
+        }
+        const mark = decOrNull(m.mark_price);
+        if (mark === null) {
+            warn(`[risex] skipped market ${m.market_id} (${m.config.name}): no mark price`);
+            continue;
+        }
+        if (m.funding_interval !== RISEX_FUNDING_INTERVAL_NS) {
+            warn(`[risex] market ${m.config.name}: funding interval ${String(m.funding_interval)} ns is not 1h — funding shown as unknown`);
+        }
+        const symbol = risexSymbolOf(m);
+        const maxLev = Number(m.config.max_leverage);
+        const idx = decOrNull(m.index_price);
+        out.push({
+            venue: "risex",
+            venueSymbol: m.market_id,
+            symbol,
+            canonical: canonicalFor("risex", symbol, assetClass),
+            assetClass,
+            settle: "USDC",
+            quoteAsset: "USDC",
+            markPrice: trimDecimal(mark),
+            indexPrice: idx === null ? null : trimDecimal(idx),
+            fundingRate: risexHourlyFunding(m),
+            fundingRateBasis: RISEX_FUNDING_BASIS,
+            settlementIntervalHours: 1,
+            // Base units [inferred: BTC open_interest ≈ 204 vs config.open_interest_limit 750 — contracts,
+            // not USD; the docs do not state the unit], as Hyperliquid publishes it.
+            openInterest: decOrNull(m.open_interest),
+            volume24h: decOrNull(m.quote_volume_24h),
+            tickSize: decOrNull(m.config.step_price),
+            stepSize: decOrNull(m.config.step_size),
+            minSize: decOrNull(m.config.min_order_size),
+            minNotional: null,
+            maxLeverage: Number.isInteger(maxLev) && maxLev > 0 ? maxLev : null,
+            marginTiers: null,
+            session: null,
+            tradable: m.active && m.config.unlocked === true && !m.reduce_only,
+        });
+    }
+    return out;
+}
+export function toRisexFundingRates(raw, markets) {
+    const byId = new Map(raw.map(r => [r.market_id, r]));
+    const out = [];
+    for (const m of markets) {
+        if (m.fundingRate === null)
+            continue;
+        const r = byId.get(m.venueSymbol);
+        out.push({
+            venue: "risex",
+            venueSymbol: m.venueSymbol,
+            symbol: m.symbol,
+            canonical: m.canonical,
+            rate: m.fundingRate,
+            basis: RISEX_FUNDING_BASIS,
+            markPrice: m.markPrice,
+            nextFundingTime: r === undefined ? null : nsToMsOrNull(r.next_funding_time),
+        });
+    }
+    return out;
+}
+const warnStderr = (msg) => { process.stderr.write(`${msg}\n`); };
+export const risexPublicData = {
+    async fetchMarkets(net) {
+        return toRisexVenueMarkets(await fetchRisexRawMarkets(risexClient(net)), warnStderr);
+    },
+    async fetchFundingRates(net) {
+        const raw = await fetchRisexRawMarkets(risexClient(net));
+        return toRisexFundingRates(raw, toRisexVenueMarkets(raw, warnStderr));
+    },
+};