perp-cli 0.12.17 → 0.14.1

package/dist/exchanges/ondo/funds.js

@@ -0,0 +1,198 @@
+/**
+ * Ondo Perps funding (mainnet only). Withdrawals are web-app only (the API cannot withdraw).
+ *
+ * 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.
+ */
+import { formatUnits, parseUnits } 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 };
+}

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 };

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

@@ -0,0 +1,127 @@
+/**
+ * Ondo Perps spot adapter (design §12, §12.4).
+ *
+ * Same host and HMAC API key as perps (shares OndoAdapter's OndoClient).
+ * Account model "separate": the Spot wallet ("spot") next to the Perps margin
+ * wallet ("margin"); POST /v1/spot/transfers moves funds between them. Docs
+ * (docs.ondoperps.xyz/api-reference/spot-api-guide, read 2026-10-05):
+ *   "The wallet identifiers are `spot` for Spot trading, `margin` for Perps
+ *    collateral, and `main` for the main wallet. Funds in another wallet do not
+ *    automatically fund a Spot order."
+ *   "`POST /v1/spot/transfers` requires `transfer`. It accepts `main` ↔ `spot`
+ *    and `margin` ↔ `spot` transfers on the same account."
+ *
+ * Paths and shapes were first taken from the production web app (route table
+ * module 10215, spot trade chunk 7609, balances parser 82886) and live public
+ * GETs (2026-10-01); the Spot API guide now documents them:
+ *   public  GET    /v1/markets            result.spot.tradingPairs
+ *   public  GET    /v1/spot/ticker        [{market,disabled,lastPrice,bid,ask,baseVolume,quoteVolume,...}]
+ *   public  GET    /v1/spot/depth         ?market=TSLA-USDC&depth= → {market,time,asks,bids}
+ *   auth    GET    /v1/spot/balances      [{coin,total,free,usdValue}]
+ *   auth    POST   /v1/spot/orders        {market,type,side,size,postOnly,price?,timeInForce?}
+ *   auth    GET    /v1/spot/orders        ?activeOnly=true&market=&limit=&cursor=
+ *   auth    DELETE /v1/spot/orders/{id}
+ *   auth    DELETE /v1/spot/orders        ?market=
+ *   auth    POST   /v1/spot/transfers     {symbol,amount,from:{wallet},to:{wallet}}
+ *
+ * Delayed placement (POST /v1/spot/orders/delayed) is NOT implemented. The guide
+ * says "If the server rejects placement with a message directing you to a delayed
+ * path, sign a new request using that exact path and a fresh timestamp", but it
+ * documents neither an error_code nor the message for that rejection ("treat
+ * `error` as descriptive text whose wording can change"), so there is no
+ * documented signal to switch paths on. A rejection that names the delayed path
+ * is reported as CAPABILITY_UNSUPPORTED (definitely not placed) — see submitFailure.
+ *
+ * Market orders: IOC LIMIT at
+ *   alignProtectionPrice(slippagePrice(mid, side, bps), quoteIncrement, side)
+ * which is the web app's own pattern. bps = the caller's resolveSlippage()
+ * value (design §13.2). The mid comes from the spot
+ * ticker's bid/ask; a one-sided book is PRICE_STALE (no lastPrice fallback).
+ *
+ * Unverified (needs a funded key):
+ *   - whether API-key HMAC auth is accepted on /v1/spot/* (the web app uses a
+ *     JWT). Auth rejections there map to NOT_IMPLEMENTED with remediation;
+ *   - balance `coin` naming/units. The app indexes balances by the
+ *     tokenConfig id / pair base ("TSLA", not the custodied "TSLAon"), and
+ *     tokenConfig marks equities as ledgerUnit "shares" (displayed units, not
+ *     raw GM-token units). Values are passed through as reported;
+ *   - whether DELETE /v1/spot/orders returns a `result` (ignored either way);
+ *   - minimum order size (not published).
+ */
+import type { ResolvedSlippage } from "../slippage.js";
+import type { SpotAdapter, SpotBalance, SpotCancelAllCapable, SpotMarketInfo, SpotOpenOrdersCapable, SpotOrderResult, SpotTransferCapable } from "../spot-interface.js";
+import type { OndoAdapter } from "./adapter.js";
+/** OpenAPI SpotWalletKey.wallet (rest-spec.json: main | margin | spot); spot ↔ perp uses these two. */
+type Wallet = "spot" | "margin";
+export declare class OndoSpotAdapter implements SpotAdapter, SpotTransferCapable, SpotOpenOrdersCapable, SpotCancelAllCapable {
+    readonly name = "ondo";
+    private readonly perp;
+    /** BASE (upper-cased) → enabled pair */
+    private enabled;
+    /** wire market ("TSLA-USDC") → pair, incl. disabled (for mapping order rows) */
+    private byMarket;
+    private initialized;
+    constructor(perp: OndoAdapter);
+    private get client();
+    init(): Promise<void>;
+    private loadPairs;
+    /** bare base ("tsla") or "TSLA/USDC" → enabled pair (wire "TSLA-USDC"). */
+    private resolve;
+    /** wire "TSLA-USDC" → "TSLA/USDC". */
+    private displaySymbol;
+    /**
+     * Authenticated spot calls. HMAC acceptance on /v1/spot/* is unverified: a
+     * 401/403 that is not a scope/IP/clock problem is reported as NOT_IMPLEMENTED
+     * (the key works on perps but the spot route refuses it).
+     */
+    private authed;
+    private ticker;
+    /** Book mid from the ticker. One-sided / empty book → PRICE_STALE (no lastPrice fallback). */
+    private mid;
+    private toResult;
+    private place;
+    getSpotMarkets(): Promise<SpotMarketInfo[]>;
+    getSpotOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getSpotBalances(): Promise<SpotBalance[]>;
+    /** IOC limit at the protection price for the caller's resolved slippage bound. */
+    spotMarketOrder(symbol: string, side: "buy" | "sell", size: string, opts: {
+        slippage: ResolvedSlippage;
+    }): Promise<SpotOrderResult>;
+    /** tif: GTC (default) | IOC | ALO (= GTC + postOnly). */
+    spotLimitOrder(symbol: string, side: "buy" | "sell", price: string, size: string, opts?: {
+        tif?: string;
+    }): Promise<SpotOrderResult>;
+    spotCancelOrder(symbol: string, orderId: string): Promise<SpotOrderResult>;
+    getSpotOpenOrders(symbol: string | null): Promise<Array<{
+        orderId: string;
+        symbol: string;
+        side: "buy" | "sell";
+        price: string;
+        size: string;
+        filled: string;
+    }>>;
+    spotCancelAllOrders(symbol: string | null): Promise<{
+        venue: "ondo";
+        market: string | null;
+        cancelled: "all";
+    }>;
+    transferToSpot(amount: string, asset: string): Promise<{
+        venue: "ondo";
+        asset: string;
+        amount: string;
+        from: Wallet;
+        to: Wallet;
+    }>;
+    transferToPerp(amount: string, asset: string): Promise<{
+        venue: "ondo";
+        asset: string;
+        amount: string;
+        from: Wallet;
+        to: Wallet;
+    }>;
+    private transfer;
+}
+export {};