perp-cli 0.12.17 → 0.14.0

package/dist/exchanges/ondo/funds.js

@@ -0,0 +1,290 @@
+/**
+ * Ondo Perps funding (mainnet only) + withdrawal address book.
+ *
+ * Deposit = a plain ERC-20 transfer of USDC to the account's own funding address
+ * (docs.ondoperps.xyz/funding-ondo-perps, api-reference/integration_guide "Deposit USDC").
+ *   - The address comes from POST /v1/wallet/deposit_address/list {coins:["USDC"]}: the FIRST
+ *     listed row for (USDC, chosen network, wallet "margin"), whose depositDestination.id must be
+ *     this account's id (GET /v1/account accountID) — anything else is refused.
+ *   - POST /v1/provision_address creates ANOTHER address on every call, so it is called only when
+ *     the list has no address for that network.
+ *   - USDC token addresses / chain ids / RPCs are pinned in the venue definition
+ *     (venues/ondo.ts ONDO_DEPOSIT_CHAINS); decimals are read on-chain.
+ *   - With a probe amount the transfer is two-step: probe → wait until GET /v1/wallet/deposits
+ *     shows it confirmed → remainder. A probe that is not credited within the window stops the
+ *     flow (ORDER_PENDING with the probe tx hash); the remainder is NOT sent.
+ *
+ * Address book: withdrawals go only to addresses on the account's address book. An address is
+ * added by signing a SIWE challenge with the account's wallet
+ * (POST /v1/auth/erc-4361/address_book/get_challenge → personal_sign → …/complete_challenge).
+ */
+import { formatUnits, parseUnits, verifyMessage } from "ethers";
+import { PerpError } from "../../errors.js";
+import { ERC20, EVM_ADDRESS_RE, assertRpcChainId, erc20Balance, erc20Decimals, evmProvider, sameAddress, sendMasterTx, } from "../../evm-master-tx.js";
+import { unsupported } from "../trading-v2.js";
+import { ONDO_DEPOSIT_CHAINS } from "../venues/ondo.js";
+export const ONDO_DEPOSIT_CREDIT_TIMEOUT_MS = 600_000;
+export const ONDO_DEPOSIT_CREDIT_POLL_MS = 10_000;
+function venueError(msg) {
+    return new PerpError("EXCHANGE_ERROR", `ondo: ${msg}`, { exchange: "ondo" });
+}
+/** Funding by on-chain transfer exists on mainnet only (the sandbox is funded with demo funds). */
+export function requireOndoDepositNetwork(net) {
+    if (net === "testnet") {
+        throw unsupported("Ondo Perps", "deposit", "the sandbox is funded with demo funds, not on-chain transfers", "Fund the sandbox account in the sandbox app (app.ondoperps-sandbox.xyz)");
+    }
+}
+export function ondoDepositChain(raw) {
+    const c = raw.toLowerCase();
+    if (c === "arbitrum" || c === "ethereum")
+        return c;
+    throw new PerpError("INVALID_PARAMS", `Unsupported Ondo deposit chain "${raw}"`, { remediation: "Use --chain arbitrum or --chain ethereum (USDC only)" });
+}
+// ── Funding address ──
+/**
+ * The first listed USDC funding address of `network` for the margin wallet. Returns null when the
+ * list has none for that network (the caller may then provision one). Refuses when the first
+ * listed address does not belong to `accountId`.
+ */
+export function selectOndoDepositAddress(rows, network, accountId) {
+    if (!Array.isArray(rows))
+        throw venueError(`deposit_address/list returned ${JSON.stringify(rows).slice(0, 120)}, expected a list`);
+    for (const r of rows) {
+        const row = (r !== null && typeof r === "object" ? r : {});
+        if (row.coin !== "USDC" || row.network !== network)
+            continue;
+        const dest = row.depositDestination;
+        if (dest === null || dest === undefined || dest.wallet !== "margin")
+            continue;
+        if (String(dest.id) !== accountId) {
+            throw venueError(`the first listed USDC ${network} funding address belongs to account ${String(dest.id)}, not this account ${accountId} — refusing to send`);
+        }
+        if (typeof row.address !== "string" || !EVM_ADDRESS_RE.test(row.address)) {
+            throw venueError(`the listed USDC ${network} funding address is not an EVM address (${JSON.stringify(row.address)})`);
+        }
+        return row.address;
+    }
+    return null;
+}
+/** Resolve (or, only when none exists, provision) the account's USDC funding address on `network`. */
+export async function resolveOndoDepositAddress(client, network) {
+    const account = await client.get("/v1/account", null);
+    if (typeof account.accountID !== "string" || account.accountID === "")
+        throw venueError("GET /v1/account returned no accountID");
+    const accountId = account.accountID;
+    const list = () => client.post("/v1/wallet/deposit_address/list", { coins: ["USDC"] });
+    const existing = selectOndoDepositAddress(await list(), network, accountId);
+    if (existing !== null)
+        return { accountId, address: existing, provisioned: false };
+    const created = await client.post("/v1/provision_address", {
+        network, symbol: "USDC", deposit_destination: { id: accountId, wallet: "margin" },
+    });
+    if (String(created.accountId) !== accountId) {
+        throw venueError(`provision_address answered for account ${String(created.accountId)}, not ${accountId} — refusing to send`);
+    }
+    const listed = selectOndoDepositAddress(await list(), network, accountId);
+    if (listed === null || typeof created.address !== "string" || !sameAddress(listed, created.address)) {
+        throw venueError(`the provisioned USDC ${network} address ${String(created.address)} is not the one the address list shows (${String(listed)}) — refusing to send`);
+    }
+    return { accountId, address: listed, provisioned: true };
+}
+/** Read-only checks on the pinned chain. Throws before anything is signed. */
+export async function planOndoDeposit(p) {
+    requireOndoDepositNetwork(p.network);
+    if (!EVM_ADDRESS_RE.test(p.depositor)) {
+        throw new PerpError("NO_SIGNER_AVAILABLE", "Ondo deposit needs the master wallet address", {
+            remediation: "Run with the master wallet: perp --ows <wallet> funds deposit ondo <amount>",
+        });
+    }
+    const pins = ONDO_DEPOSIT_CHAINS[p.chain];
+    const rpc = evmProvider(pins.rpcUrl, pins.chainId);
+    await assertRpcChainId(rpc, pins.rpcUrl, pins.chainId, "ondo");
+    const decimals = await erc20Decimals(rpc, pins.usdc);
+    const raw = (x, what) => {
+        if (!/^\d+(\.\d+)?$/.test(x) || !(Number(x) > 0))
+            throw new PerpError("INVALID_PARAMS", `${what} must be a positive decimal (got "${x}")`);
+        try {
+            return parseUnits(x, decimals);
+        }
+        catch {
+            throw new PerpError("INVALID_PARAMS", `${what} ${x} has more than ${decimals} decimals (USDC on ${pins.label})`);
+        }
+    };
+    const amountRaw = raw(p.amount, "Deposit amount");
+    const probeRaw = p.probe === null ? null : raw(p.probe, "--probe");
+    if (probeRaw !== null && probeRaw >= amountRaw) {
+        throw new PerpError("INVALID_PARAMS", `--probe ${String(p.probe)} must be smaller than the deposit amount ${p.amount} (the remainder is sent after the probe is credited)`);
+    }
+    const [tokenBalance, gas] = await Promise.all([erc20Balance(rpc, pins.usdc, p.depositor), rpc.getBalance(p.depositor)]);
+    if (tokenBalance < amountRaw) {
+        throw new PerpError("INSUFFICIENT_BALANCE", `Wallet ${p.depositor} holds ${formatUnits(tokenBalance, decimals)} USDC on ${pins.label}; the deposit needs ${p.amount}`, {
+            exchange: "ondo", remediation: `Fund ${p.depositor} with USDC on ${pins.label} (chainId ${pins.chainId}) first — e.g. perp funds bridge send --to ${p.chain} --to-asset USDC`,
+        });
+    }
+    if (gas === 0n) {
+        throw new PerpError("INSUFFICIENT_BALANCE", `Wallet ${p.depositor} has no ETH for gas on ${pins.label}`, {
+            exchange: "ondo", remediation: `Fund ${p.depositor} with ETH on ${pins.label} (chainId ${pins.chainId})`,
+        });
+    }
+    return {
+        network: p.network, chain: p.chain, chainId: pins.chainId, chainLabel: pins.label, rpcUrl: pins.rpcUrl, token: pins.usdc, decimals,
+        amount: p.amount, amountRaw, probe: p.probe, probeRaw, depositor: p.depositor,
+        depositAddress: p.funding.address, accountId: p.funding.accountId, tokenBalance,
+    };
+}
+/**
+ * Wait until GET /v1/wallet/deposits lists this transaction as `confirmed`. Not listed / pending /
+ * unreadable until the deadline → ORDER_PENDING with the tx hash (the transfer itself is mined).
+ */
+export async function awaitOndoDepositCredit(readDeposits, txHash, what, timing) {
+    const deadline = timing.now() + timing.timeoutMs;
+    let last = "not listed yet";
+    for (;;) {
+        try {
+            const rows = await readDeposits();
+            if (!Array.isArray(rows))
+                throw venueError(`GET /v1/wallet/deposits returned ${JSON.stringify(rows).slice(0, 120)}, expected a list`);
+            const row = rows.find(r => typeof r?.txid === "string" && r.txid.toLowerCase() === txHash.toLowerCase());
+            if (row !== undefined) {
+                if (row.status === "confirmed")
+                    return;
+                last = `status ${String(row.status)}`;
+            }
+        }
+        catch (e) {
+            last = e instanceof Error ? e.message : String(e);
+        }
+        if (timing.now() + timing.pollMs > deadline)
+            break;
+        await timing.sleep(timing.pollMs);
+    }
+    throw new PerpError("ORDER_PENDING", `ondo: ${what} ${txHash} is mined but not yet credited by Ondo Perps after ${timing.timeoutMs / 1000}s (${last})`, {
+        exchange: "ondo", txHash,
+        remediation: "Do NOT send again — the transfer is on-chain and deposits can take longer to confirm. Check: perp -e ondo account balance (or the Ondo Perps app → deposits)",
+    });
+}
+/**
+ * Send the USDC transfer(s). With a probe: probe → credited → remainder → credited; the
+ * remainder is never sent while the probe is uncredited (the ORDER_PENDING carries `sent`).
+ */
+export async function executeOndoDeposit(plan, sign, readDeposits, timing) {
+    const rpc = evmProvider(plan.rpcUrl, plan.chainId);
+    const transfers = [];
+    const send = async (step, raw) => {
+        const amount = formatUnits(raw, plan.decimals);
+        const { txHash } = await sendMasterTx(rpc, {
+            venue: "ondo", chainLabel: plan.chainLabel, chainId: plan.chainId, from: plan.depositor, to: plan.token, value: 0n,
+            data: ERC20.encodeFunctionData("transfer", [plan.depositAddress, raw]), label: `USDC ${step} transfer (${amount})`,
+        }, sign);
+        transfers.push({ step, txHash, amount });
+        try {
+            await awaitOndoDepositCredit(readDeposits, txHash, `${step} transfer`, timing);
+        }
+        catch (e) {
+            if (e instanceof PerpError && e.structured.code === "ORDER_PENDING") {
+                const notSent = step === "probe" ? ` The remaining ${formatUnits(plan.amountRaw - raw, plan.decimals)} USDC was NOT sent.` : "";
+                throw new PerpError("ORDER_PENDING", `${e.message}.${notSent}`, {
+                    exchange: "ondo", txHash, sent: transfers, depositAddress: plan.depositAddress,
+                    remediation: e.structured.remediation,
+                });
+            }
+            throw e;
+        }
+    };
+    if (plan.probeRaw !== null) {
+        await send("probe", plan.probeRaw);
+        await send("deposit", plan.amountRaw - plan.probeRaw);
+    }
+    else {
+        await send("deposit", plan.amountRaw);
+    }
+    return { transfers, depositAddress: plan.depositAddress };
+}
+// ── Address book ──
+const ADDRESS_BOOK_UI = "add the address in the Ondo Perps web app (Withdraw → address book)";
+/** Withdrawal addresses on the account's address book (GET /v1/wallet/address_book). */
+export async function ondoAddressBook(client) {
+    const res = await client.get("/v1/wallet/address_book", null);
+    if (!Array.isArray(res.addressBook))
+        throw venueError("GET /v1/wallet/address_book returned no addressBook list");
+    return res.addressBook.map(e => {
+        if (typeof e?.withdrawalAddress !== "string")
+            throw venueError("address book entry has no withdrawalAddress");
+        return e.withdrawalAddress;
+    });
+}
+/** Refusal for a withdraw destination that is not on the address book (nothing was sent). */
+export function ondoAddressNotOnBook(destination, book) {
+    return new PerpError("INVALID_PARAMS", `${destination} is not on the Ondo Perps withdrawal address book (${book.length === 0 ? "the book is empty" : `listed: ${book.join(", ")}`}) — nothing was sent`, {
+        exchange: "ondo",
+        remediation: `Ondo only withdraws to address-book entries. An entry is added by signing a SIWE challenge with the account's wallet (api-reference/auth/get-siwe-address-book-challenge + complete). For the master wallet's own address run: perp funds address-book add ondo ${destination} — otherwise ${ADDRESS_BOOK_UI}`,
+    });
+}
+/** A challenge the master key will sign must be about this address book entry — never an arbitrary message. */
+export function assertOndoAddressBookChallenge(message, wallet, withdrawalAddress, restUrl) {
+    const refuse = (why) => {
+        throw new PerpError("POLICY_DENIED", `Ondo address-book challenge refused: ${why}. Nothing was signed.`, {
+            exchange: "ondo", challenge: message.slice(0, 600), remediation: `If this message is expected, ${ADDRESS_BOOK_UI}`,
+        });
+    };
+    if (!message.toLowerCase().includes(withdrawalAddress.toLowerCase()))
+        refuse(`the message does not name the withdrawal address ${withdrawalAddress}`);
+    // The endpoint is POST /v1/auth/erc-4361/address_book/get_challenge — "Get a Sign-In with Ethereum
+    // challenge for adding a withdrawal address" (Ondo REST spec). ERC-4361 shape:
+    // "<domain> wants you to sign in with your Ethereum account:\n<address>\n…". Any other message
+    // is refused: the master key never signs free-form text.
+    const siwe = /^(\S+) wants you to sign in with your Ethereum account:\n(0x[0-9a-fA-F]{40})\n/.exec(message);
+    if (siwe === null)
+        return refuse("the message is not a Sign-In with Ethereum (ERC-4361) message");
+    const venueHost = new URL(restUrl).hostname.split(".").slice(-2).join(".");
+    const domain = siwe[1].replace(/^[a-z]+:\/\//, "").split(":")[0];
+    if (domain !== venueHost && !domain.endsWith(`.${venueHost}`))
+        refuse(`its domain "${siwe[1]}" is not ${venueHost}`);
+    if (!sameAddress(siwe[2], wallet))
+        refuse(`it is addressed to ${siwe[2]}, not the signing wallet ${wallet}`);
+}
+/** A venue refusal of the SIWE address-book endpoints, re-raised with the web-app route. */
+function addressBookAuthError(e, step) {
+    if (!(e instanceof PerpError) || e.structured.code === "ORDER_PENDING")
+        return e;
+    return new PerpError(e.structured.code, `${e.message} — Ondo refused the address-book ${step} with API-key auth`, {
+        ...e.structured.details, exchange: "ondo",
+        remediation: `These endpoints may need a wallet (SIWE/JWT) session instead of an API key: ${ADDRESS_BOOK_UI}`,
+    });
+}
+/**
+ * Add the signing wallet's own address to the address book: get_challenge → personal_sign
+ * (EIP-191) with the wallet → complete_challenge. Challenge chainId "1" (enum: 1 | 43114).
+ */
+export async function addOndoAddressBookEntry(client, p) {
+    const before = await ondoAddressBook(client);
+    if (before.some(a => sameAddress(a, p.wallet)))
+        return { address: p.wallet, alreadyListed: true, listed: true, challengeId: null };
+    let challenge;
+    try {
+        challenge = await client.post("/v1/auth/erc-4361/address_book/get_challenge", {
+            walletAddress: p.wallet, chainId: "1", withdrawalAddress: p.wallet,
+        });
+    }
+    catch (e) {
+        throw addressBookAuthError(e, "challenge");
+    }
+    if (typeof challenge.id !== "string" || typeof challenge.message !== "string" || challenge.message === "") {
+        throw venueError("address_book/get_challenge returned no id / message");
+    }
+    assertOndoAddressBookChallenge(challenge.message, p.wallet, p.wallet, p.restUrl);
+    const signature = await p.signMessage(challenge.message);
+    if (!sameAddress(verifyMessage(challenge.message, signature), p.wallet)) {
+        throw new PerpError("SIGNATURE_FAILED", `The address-book challenge signature does not recover to ${p.wallet} — nothing was submitted`, { exchange: "ondo" });
+    }
+    try {
+        await client.postNoResult("/v1/auth/erc-4361/address_book/complete_challenge", {
+            id: challenge.id, signature, ...(p.label !== null ? { addressLabel: p.label } : {}),
+        });
+    }
+    catch (e) {
+        throw addressBookAuthError(e, "completion");
+    }
+    const after = await ondoAddressBook(client);
+    return { address: p.wallet, alreadyListed: false, listed: after.some(a => sameAddress(a, p.wallet)), challengeId: challenge.id };
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Ondo Perps public market data (design §10.6).
+ *
+ * Sources (all public, live-verified 2026-09-30):
+ *   GET /v1/markets           result.perps.tradingPairs[] — increments, margin
+ *                             brackets, tags (asset class), trading schedule
+ *   GET /v1/perps/contracts   result[] — ticker, funding, OI, volume, status
+ *   GET /v1/perps/mark_prices result{market: MarkPrice} — mark price and the
+ *                             weekend discovery band (discoveryLower/Upper,
+ *                             inPriceDiscovery; not in the OpenAPI spec but
+ *                             returned live)
+ *
+ * Funding is hourly: `fundingRate` is a 1h rate (docs funding-rates), so the
+ * basis is perHours 1 and settlement is every hour.
+ *
+ * Symbols: venue symbol "TSLA-USD.P" → CLI symbol "TSLA". Spot pairs
+ * (result.spot) are not perp markets; OndoSpotAdapter reads them via
+ * fetchOndoSpotTradingPairs.
+ */
+import type { VenuePublicData } from "../venue.js";
+import type { AssetClass, FundingRateBasis, Network } from "../venue-types.js";
+import { OndoClient } from "./client.js";
+export declare const ONDO_PERP_SUFFIX = "-USD.P";
+export declare const ONDO_FUNDING_BASIS: FundingRateBasis;
+export declare const ONDO_SETTLEMENT_HOURS = 1;
+export interface OndoMarginBracket {
+    positionBracketUsd: string;
+    maxLeverage: string;
+    maintenanceMarginRate: string;
+    maintenanceAmount: string;
+}
+export interface OndoTradingPair {
+    market: string;
+    pair: {
+        base: string;
+        quote: string;
+    };
+    baseIncrement: string;
+    quoteIncrement: string;
+    marginInfo: OndoMarginBracket[];
+    tags: string[] | null;
+    /** Present on listings with a trading schedule (non-crypto); absent for 24/7 crypto. */
+    schedule?: unknown;
+    /** Present (true) on delisted / paused listings. */
+    disabled?: boolean;
+}
+/** Spot pair from /v1/markets result.spot.tradingPairs (live; not in the OpenAPI spec). */
+export interface OndoSpotTradingPair {
+    market: string;
+    pair: {
+        base: string;
+        quote: string;
+    };
+    longName?: string;
+    baseIncrement: string;
+    quoteIncrement: string;
+    makerFee: string;
+    takerFee: string;
+    tags: string[] | null;
+    /** Present (true) on pairs that are listed but not tradable. */
+    disabled?: boolean;
+}
+export interface OndoContract {
+    market: string;
+    disabled: boolean;
+    lastPrice?: string;
+    usdVolume?: string;
+    openInterest?: string;
+    indexPrice?: string;
+    fundingRate?: string;
+    nextFundingRateTimestamp?: string;
+    isClosed?: boolean;
+    reduceOnly?: boolean;
+    tags?: string[];
+}
+export interface OndoMarkPrice {
+    market: string;
+    markPrice: string;
+    oraclePrice: string;
+    discoveryLower?: string;
+    discoveryUpper?: string;
+    inPriceDiscovery?: boolean;
+}
+export declare function ondoAssetClass(market: string, tags: readonly string[] | null | undefined): AssetClass;
+/** "TSLA-USD.P" → "TSLA". Throws for non-perp symbols. */
+export declare function ondoPlainSymbol(venueSymbol: string): string;
+/** CLI symbol ("tsla", "TSLA", "TSLA-USD.P") → venue symbol "TSLA-USD.P". */
+export declare function ondoVenueSymbol(symbol: string): string;
+/** Empty string / absent → null. Ondo omits or blanks fields it does not publish. */
+export declare function strOrNull(v: string | undefined | null): string | null;
+export declare function parseOndoTime(iso: string, what: string): number;
+export declare function ondoPublicClient(net: Network): OndoClient;
+export declare function fetchOndoTradingPairs(client: OndoClient): Promise<OndoTradingPair[]>;
+export declare function fetchOndoSpotTradingPairs(client: OndoClient): Promise<OndoSpotTradingPair[]>;
+export declare const ondoPublicData: VenuePublicData;

package/dist/exchanges/ondo/public.js

@@ -0,0 +1,214 @@
+/**
+ * Ondo Perps public market data (design §10.6).
+ *
+ * Sources (all public, live-verified 2026-09-30):
+ *   GET /v1/markets           result.perps.tradingPairs[] — increments, margin
+ *                             brackets, tags (asset class), trading schedule
+ *   GET /v1/perps/contracts   result[] — ticker, funding, OI, volume, status
+ *   GET /v1/perps/mark_prices result{market: MarkPrice} — mark price and the
+ *                             weekend discovery band (discoveryLower/Upper,
+ *                             inPriceDiscovery; not in the OpenAPI spec but
+ *                             returned live)
+ *
+ * Funding is hourly: `fundingRate` is a 1h rate (docs funding-rates), so the
+ * basis is perHours 1 and settlement is every hour.
+ *
+ * Symbols: venue symbol "TSLA-USD.P" → CLI symbol "TSLA". Spot pairs
+ * (result.spot) are not perp markets; OndoSpotAdapter reads them via
+ * fetchOndoSpotTradingPairs.
+ */
+import { PerpError } from "../../errors.js";
+import { canonicalFor } from "../canonical-symbols.js";
+import { networkConfig } from "../venue.js";
+import { ondoVenue } from "../venues/ondo.js";
+import { OndoClient } from "./client.js";
+export const ONDO_PERP_SUFFIX = "-USD.P";
+export const ONDO_FUNDING_BASIS = { kind: "perHours", hours: 1 };
+export const ONDO_SETTLEMENT_HOURS = 1;
+// ── Helpers ──
+const TAG_TO_ASSET_CLASS = {
+    Crypto: "crypto",
+    Stock: "equity",
+    ETF: "etf",
+    Index: "index",
+    Commodity: "commodity",
+    FX: "fx",
+};
+export function ondoAssetClass(market, tags) {
+    if (tags === null || tags === undefined) {
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: ${market} has no tags; cannot classify asset class`);
+    }
+    const known = tags.map(t => TAG_TO_ASSET_CLASS[t]).filter((c) => c !== undefined);
+    if (known.length !== 1) {
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: cannot classify ${market} from tags ${JSON.stringify(tags)}`, {
+            remediation: "Update TAG_TO_ASSET_CLASS in src/exchanges/ondo/public.ts for the new venue tag",
+        });
+    }
+    return known[0];
+}
+/** "TSLA-USD.P" → "TSLA". Throws for non-perp symbols. */
+export function ondoPlainSymbol(venueSymbol) {
+    if (!venueSymbol.endsWith(ONDO_PERP_SUFFIX)) {
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: unexpected perp market symbol "${venueSymbol}"`);
+    }
+    return venueSymbol.slice(0, -ONDO_PERP_SUFFIX.length);
+}
+/** CLI symbol ("tsla", "TSLA", "TSLA-USD.P") → venue symbol "TSLA-USD.P". */
+export function ondoVenueSymbol(symbol) {
+    const up = symbol.trim().toUpperCase();
+    if (up.length === 0)
+        throw new PerpError("INVALID_PARAMS", "symbol is empty");
+    return up.endsWith(ONDO_PERP_SUFFIX) ? up : `${up}${ONDO_PERP_SUFFIX}`;
+}
+/** Empty string / absent → null. Ondo omits or blanks fields it does not publish. */
+export function strOrNull(v) {
+    return v === undefined || v === null || v === "" ? null : v;
+}
+export function parseOndoTime(iso, what) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: invalid ${what} timestamp "${iso}"`);
+    return t;
+}
+function marginTiersOf(pair) {
+    if (pair.marginInfo.length === 0) {
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: ${pair.market} has no marginInfo brackets`);
+    }
+    // Brackets are ascending by positionBracketUsd (the bracket's upper bound).
+    const tiers = [];
+    let lower = 0;
+    for (const b of pair.marginInfo) {
+        const lev = Number(b.maxLeverage);
+        const upper = Number(b.positionBracketUsd);
+        if (!Number.isFinite(lev) || lev <= 0 || !Number.isFinite(upper)) {
+            throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: ${pair.market} invalid margin bracket ${JSON.stringify(b)}`);
+        }
+        tiers.push({ lowerBound: lower, maxLeverage: lev });
+        lower = upper;
+    }
+    return { maxLeverage: Math.max(...tiers.map(t => t.maxLeverage)), tiers };
+}
+/**
+ * Weekend/holiday discovery band (docs weekend-trading). Only non-crypto
+ * listings carry a schedule; for 24/7 crypto the session is null.
+ * `inPriceDiscovery` = external feeds unavailable (underlying closed) and the
+ * mark is bounded by [discoveryLower, discoveryUpper].
+ */
+function sessionOf(pair, mark) {
+    if (pair.schedule === undefined || pair.schedule === null)
+        return null;
+    if (typeof mark.inPriceDiscovery !== "boolean")
+        return null;
+    if (!mark.inPriceDiscovery)
+        return { underlyingOpen: true, priceBand: null, marginMultiplier: null };
+    const lower = strOrNull(mark.discoveryLower);
+    const upper = strOrNull(mark.discoveryUpper);
+    return {
+        underlyingOpen: false,
+        priceBand: lower !== null && upper !== null ? { lower, upper } : null,
+        marginMultiplier: null,
+    };
+}
+// ── Fetchers ──
+export function ondoPublicClient(net) {
+    return new OndoClient({
+        restUrl: networkConfig(ondoVenue, net).restUrl,
+        network: net,
+        rateLimit: ondoVenue.rateLimit,
+        credentials: null,
+    });
+}
+export async function fetchOndoTradingPairs(client) {
+    const r = await client.publicGet("/v1/markets", null);
+    return r.perps.tradingPairs;
+}
+export async function fetchOndoSpotTradingPairs(client) {
+    const r = await client.publicGet("/v1/markets", null);
+    if (r.spot === undefined || !Array.isArray(r.spot.tradingPairs)) {
+        throw new PerpError("EXCHANGE_ERROR", "Ondo Perps: /v1/markets has no result.spot.tradingPairs");
+    }
+    return r.spot.tradingPairs;
+}
+function byMarket(rows) {
+    return new Map(rows.map(r => [r.market, r]));
+}
+function requireRow(m, market, source) {
+    const row = m.get(market);
+    if (row === undefined) {
+        throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: ${market} is missing from ${source}`);
+    }
+    return row;
+}
+async function fetchMarkets(net) {
+    const client = ondoPublicClient(net);
+    const pairs = await fetchOndoTradingPairs(client);
+    const contracts = byMarket(await client.publicGet("/v1/perps/contracts", null));
+    const marks = await client.publicGet("/v1/perps/mark_prices", null);
+    // A listing with no mark price has no price feed (seen on the sandbox, e.g.
+    // SHEIN/COPPER/NATGAS with lastPrice 0). It cannot be priced or traded, so it
+    // is excluded with a warning rather than given a made-up mark.
+    const noMark = pairs.filter(p => marks[p.market] === undefined).map(p => p.market);
+    if (noMark.length > 0) {
+        console.warn(`[ondo] excluded ${noMark.length} market(s) without a mark price: ${noMark.join(", ")}`);
+    }
+    return pairs.filter(p => marks[p.market] !== undefined).map((pair) => {
+        const contract = requireRow(contracts, pair.market, "/v1/perps/contracts");
+        const mark = marks[pair.market];
+        const symbol = ondoPlainSymbol(pair.market);
+        const assetClass = ondoAssetClass(pair.market, pair.tags);
+        const { maxLeverage, tiers } = marginTiersOf(pair);
+        return {
+            venue: "ondo",
+            venueSymbol: pair.market,
+            symbol,
+            canonical: canonicalFor("ondo", symbol, assetClass),
+            assetClass,
+            settle: "USDC",
+            quoteAsset: pair.pair.quote,
+            markPrice: mark.markPrice,
+            indexPrice: strOrNull(contract.indexPrice),
+            fundingRate: strOrNull(contract.fundingRate),
+            fundingRateBasis: ONDO_FUNDING_BASIS,
+            settlementIntervalHours: ONDO_SETTLEMENT_HOURS,
+            openInterest: strOrNull(contract.openInterest),
+            volume24h: strOrNull(contract.usdVolume),
+            tickSize: pair.quoteIncrement,
+            stepSize: pair.baseIncrement,
+            minSize: null,
+            minNotional: null,
+            maxLeverage,
+            marginTiers: tiers,
+            session: sessionOf(pair, mark),
+            tradable: pair.disabled !== true && !contract.disabled && contract.isClosed !== true && contract.reduceOnly !== true,
+        };
+    });
+}
+async function fetchFundingRates(net) {
+    const client = ondoPublicClient(net);
+    const contracts = await client.publicGet("/v1/perps/contracts", null);
+    const marks = await client.publicGet("/v1/perps/mark_prices", null);
+    const out = [];
+    for (const c of contracts) {
+        if (c.disabled)
+            continue; // delisted/paused listings carry a stale rate and a zero last price
+        const rate = strOrNull(c.fundingRate);
+        if (rate === null) {
+            throw new PerpError("EXCHANGE_ERROR", `Ondo Perps: ${c.market} has no fundingRate in /v1/perps/contracts`);
+        }
+        const symbol = ondoPlainSymbol(c.market);
+        const next = strOrNull(c.nextFundingRateTimestamp);
+        const mark = marks[c.market];
+        out.push({
+            venue: "ondo",
+            venueSymbol: c.market,
+            symbol,
+            canonical: canonicalFor("ondo", symbol, ondoAssetClass(c.market, c.tags)),
+            rate,
+            basis: ONDO_FUNDING_BASIS,
+            markPrice: mark === undefined ? null : mark.markPrice,
+            nextFundingTime: next === null ? null : parseOndoTime(next, "nextFundingRateTimestamp"),
+        });
+    }
+    return out;
+}
+export const ondoPublicData = { fetchMarkets, fetchFundingRates };