perp-cli 0.14.3 → 0.15.0

package/dist/exchanges/derive/options.js

@@ -0,0 +1,360 @@
+/**
+ * Derive options — read-only `OptionsVenue` over the v3 public API (official, no auth).
+ *
+ * Reads (docs.derive.xyz/openapi.json, shapes checked live 2026-10-18):
+ *  - `get_all_currencies` → currencies with an `option` asset (underlyings).
+ *  - `get_all_instruments {instrument_type:"option", currency, expired:false, page_size:1000, page}`
+ *    → instruments; `option_details {expiry (unix s), strike, option_type "C"|"P"}`. Paginated
+ *    (`pagination.num_pages`, page_size ≤ 1000). `is_active:false` = listed for a future activation
+ *    (`scheduled_activation`), not tradable and with no ticker — left out of expiries / chains.
+ *    An unknown currency is RPC 12001.
+ *  - `get_tickers {instrument_type:"option", currency, expiry_date:"YYYYMMDD"}` → `{tickers: {name: TickerSlim}}`;
+ *    expiry_date is required for options. ONE call per chain (never one per instrument).
+ *  - `get_instrument` + `get_ticker` for a single quote (unknown instrument = RPC 12001).
+ *
+ * Ticker encoding (live): an empty book side is price "0" / size "0" → `null` side; an IV the
+ * pricer could not compute (no quote, or a quote below intrinsic) is "0" → `null`; 24 h high / low
+ * are "0" when there were no trades → `null`. Greeks are passed through verbatim (a delta of 0 is real).
+ */
+import { PerpError } from "../../errors.js";
+import { OPTIONS_SCHEMA, } from "../options-interface.js";
+import { DERIVE_INSTRUMENT_NOT_FOUND, DERIVE_INVALID_PARAMS, DeriveClient, deriveRpcCode, deriveShapeError } from "./client.js";
+const VENUE = "derive";
+const PAGE_SIZE = 1000;
+function obj(v, what) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        throw deriveShapeError(`${what} is not an object`);
+    return v;
+}
+function str(o, key, what) {
+    const v = o[key];
+    if (typeof v !== "string")
+        throw deriveShapeError(`${what}.${key} is not a string`);
+    return v;
+}
+/** A decimal string (checked to parse as a finite number; returned verbatim). */
+function dec(o, key, what) {
+    const v = str(o, key, what);
+    if (v.trim() === "" || !Number.isFinite(Number(v)))
+        throw deriveShapeError(`${what}.${key} is not a decimal ("${v}")`);
+    return v;
+}
+function int(o, key, what) {
+    const v = o[key];
+    if (typeof v !== "number" || !Number.isInteger(v))
+        throw deriveShapeError(`${what}.${key} is not an integer`);
+    return v;
+}
+/** Derive's "0" placeholder → null; anything else verbatim. */
+function nonZero(v) {
+    return Number(v) === 0 ? null : v;
+}
+// ── dates ──
+/** ms epoch → UTC YYYY-MM-DD. */
+export function utcDate(ms) {
+    return new Date(ms).toISOString().slice(0, 10);
+}
+/** User expiry, exactly "2026-12-25" or "20261225" (not mixed) → YYYY-MM-DD; anything else INVALID_PARAMS. */
+export function normalizeExpiry(input) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(input.trim()) ?? /^(\d{4})(\d{2})(\d{2})$/.exec(input.trim());
+    const iso = m !== null ? `${m[1]}-${m[2]}-${m[3]}` : null;
+    if (iso === null || Number.isNaN(Date.parse(`${iso}T00:00:00Z`)) || utcDate(Date.parse(`${iso}T00:00:00Z`)) !== iso) {
+        throw new PerpError("INVALID_PARAMS", `Invalid expiry "${input}" — expected YYYY-MM-DD (UTC)`, {
+            remediation: `List expiries: perp -e ${VENUE} options expiries <UNDERLYING>`,
+        });
+    }
+    return iso;
+}
+/** User underlying → venue currency (upper case); INVALID_PARAMS for anything that is not a ticker. */
+export function normalizeUnderlying(input) {
+    const u = input.trim().toUpperCase();
+    if (!/^[A-Z0-9_]{1,20}$/.test(u)) {
+        throw new PerpError("INVALID_PARAMS", `Invalid underlying "${input}"`, {
+            remediation: `List underlyings: perp -e ${VENUE} options underlyings`,
+        });
+    }
+    return u;
+}
+// ── parsing ──
+export function parseDeriveInstrument(raw) {
+    const o = obj(raw, "instrument");
+    const name = str(o, "instrument_name", "instrument");
+    const what = `instrument ${name}`;
+    if (str(o, "instrument_type", what) !== "option")
+        throw deriveShapeError(`${what} is not an option`);
+    const d = obj(o.option_details, `${what}.option_details`);
+    const t = str(d, "option_type", `${what}.option_details`);
+    if (t !== "C" && t !== "P")
+        throw deriveShapeError(`${what}.option_details.option_type "${t}" is not C / P`);
+    const expiryMs = int(d, "expiry", `${what}.option_details`) * 1000;
+    const isActive = o.is_active;
+    if (typeof isActive !== "boolean")
+        throw deriveShapeError(`${what}.is_active is not a boolean`);
+    return {
+        name,
+        underlying: str(o, "base_currency", what),
+        quoteCurrency: str(o, "quote_currency", what),
+        kind: t === "C" ? "call" : "put",
+        strike: dec(d, "strike", `${what}.option_details`),
+        expiryMs,
+        expiry: utcDate(expiryMs),
+        isActive,
+        activationMs: int(o, "scheduled_activation", what) * 1000,
+    };
+}
+/** A ticker_slim snapshot (get_ticker / get_tickers value) of `inst` → OptionQuote. */
+export function parseDeriveOptionTicker(raw, inst) {
+    const what = `ticker ${inst.name}`;
+    const t = obj(raw, what);
+    const bidPx = dec(t, "b", what), bidSz = dec(t, "B", what);
+    const askPx = dec(t, "a", what), askSz = dec(t, "A", what);
+    const bid = Number(bidPx) === 0 ? null : { price: bidPx, size: bidSz };
+    const ask = Number(askPx) === 0 ? null : { price: askPx, size: askSz };
+    const s = obj(t.stats, `${what}.stats`);
+    const trades = int(s, "n", `${what}.stats`);
+    const pr = t.option_pricing;
+    let p = null;
+    if (pr !== null && pr !== undefined)
+        p = obj(pr, `${what}.option_pricing`);
+    const pw = `${what}.option_pricing`;
+    return {
+        schema: OPTIONS_SCHEMA,
+        venue: VENUE,
+        instrument: inst.name,
+        underlying: inst.underlying,
+        quoteCurrency: inst.quoteCurrency,
+        kind: inst.kind,
+        strike: inst.strike,
+        expiry: inst.expiry,
+        expiryMs: inst.expiryMs,
+        bid,
+        ask,
+        mark: dec(t, "M", what),
+        index: dec(t, "I", what),
+        forward: p === null ? null : dec(p, "f", pw),
+        discountFactor: p === null ? null : dec(p, "df", pw),
+        iv: {
+            mark: p === null ? null : nonZero(dec(p, "i", pw)),
+            bid: p === null || bid === null ? null : nonZero(dec(p, "bi", pw)),
+            ask: p === null || ask === null ? null : nonZero(dec(p, "ai", pw)),
+        },
+        greeks: p === null ? null : {
+            delta: dec(p, "d", pw), gamma: dec(p, "g", pw), theta: dec(p, "t", pw), vega: dec(p, "v", pw), rho: dec(p, "r", pw),
+        },
+        openInterest: dec(s, "oi", `${what}.stats`),
+        stats24h: {
+            contracts: dec(s, "c", `${what}.stats`),
+            notional: dec(s, "v", `${what}.stats`),
+            premium: dec(s, "pr", `${what}.stats`),
+            trades,
+            high: trades === 0 ? null : dec(s, "h", `${what}.stats`),
+            low: trades === 0 ? null : dec(s, "l", `${what}.stats`),
+        },
+        timestampMs: int(t, "t", what),
+    };
+}
+/** Distinct active expiries of `instruments`, soonest first. */
+export function expiriesOf(instruments) {
+    const by = new Map();
+    for (const i of instruments) {
+        if (!i.isActive)
+            continue;
+        const e = by.get(i.expiryMs) ?? { strikes: new Set(), n: 0 };
+        e.strikes.add(i.strike);
+        e.n++;
+        by.set(i.expiryMs, e);
+    }
+    return [...by.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([ms, e]) => ({ expiry: utcDate(ms), expiryMs: ms, strikes: e.strikes.size, instruments: e.n }));
+}
+/** The `n` strikes closest to `price` (ties → lower strike), returned ascending. */
+export function strikesAround(strikes, price, n) {
+    const p = Number(price);
+    const nearest = [...strikes].sort((a, b) => (Math.abs(Number(a) - p) - Math.abs(Number(b) - p)) || (Number(a) - Number(b)));
+    return nearest.slice(0, n).sort((a, b) => Number(a) - Number(b));
+}
+/**
+ * Chain for one expiry from its instruments and the `get_tickers` map. Rows come from the listed
+ * instruments; a listed instrument without a ticker leaves its side null and is named in
+ * `missingTickers`. Index / forward are those of the newest ticker (largest `t`) — one ticker's values,
+ * not an average over the expiry.
+ */
+export function buildChain(underlying, expiry, selection, instruments, tickersRaw, strikesAroundAtm) {
+    const tickers = obj(tickersRaw, "get_tickers result.tickers");
+    const rowsByStrike = new Map();
+    const missingTickers = [];
+    let latest = null;
+    for (const inst of instruments) {
+        const row = rowsByStrike.get(inst.strike) ?? { strike: inst.strike, call: null, put: null };
+        rowsByStrike.set(inst.strike, row);
+        if (!(inst.name in tickers)) {
+            missingTickers.push(inst.name);
+            continue;
+        }
+        const q = parseDeriveOptionTicker(tickers[inst.name], inst);
+        row[inst.kind] = q;
+        if (latest === null || q.timestampMs > latest.timestampMs)
+            latest = q;
+    }
+    const strikes = [...rowsByStrike.keys()];
+    let atm = null;
+    if (latest !== null) {
+        const reference = latest.forward !== null ? "forward" : "index";
+        const price = latest.forward !== null ? latest.forward : latest.index;
+        atm = { strike: strikesAround(strikes, price, 1)[0], reference, price };
+    }
+    let keep = strikes;
+    if (strikesAroundAtm !== null) {
+        if (atm === null) {
+            throw new PerpError("EXCHANGE_ERROR", `Derive returned no ticker for ${underlying} ${expiry.expiry}; the ATM strike for --strikes is unknown`, {
+                exchange: VENUE, remediation: `Run without --strikes to see the listed strikes`,
+            });
+        }
+        keep = strikesAround(strikes, atm.price, strikesAroundAtm);
+    }
+    const rows = keep
+        .sort((a, b) => Number(a) - Number(b))
+        .map(k => rowsByStrike.get(k));
+    return {
+        schema: OPTIONS_SCHEMA,
+        venue: VENUE,
+        underlying,
+        expiry: expiry.expiry,
+        expiryMs: expiry.expiryMs,
+        expirySelection: selection,
+        index: latest === null ? null : latest.index,
+        forward: latest === null ? null : latest.forward,
+        atm,
+        strikesListed: strikes.length,
+        rows,
+        missingTickers: missingTickers.sort(),
+    };
+}
+// ── venue ──
+function noOptions(underlying) {
+    return new PerpError("SYMBOL_NOT_FOUND", `Derive has no ${underlying} options`, {
+        exchange: VENUE, remediation: `List underlyings: perp -e ${VENUE} options underlyings`,
+    });
+}
+export class DeriveOptionsVenue {
+    client;
+    id = VENUE;
+    displayName = "Derive";
+    constructor(client) {
+        this.client = client;
+    }
+    static forNetwork(network) {
+        return new DeriveOptionsVenue(new DeriveClient(network));
+    }
+    async listUnderlyings() {
+        const raw = await this.client.call("get_all_currencies", {});
+        if (!Array.isArray(raw))
+            throw deriveShapeError("get_all_currencies result is not a list");
+        const underlyings = raw
+            .map((c, i) => obj(c, `currency #${i}`))
+            .filter(c => c.option !== null && c.option !== undefined)
+            .map(c => {
+            const what = `currency ${String(c.currency)}`;
+            return { underlying: str(c, "currency", what), spotPrice: c.spot_price === null ? null : dec(c, "spot_price", what) };
+        })
+            .sort((a, b) => a.underlying.localeCompare(b.underlying));
+        return { schema: OPTIONS_SCHEMA, venue: VENUE, underlyings };
+    }
+    /** Every non-expired option instrument of `underlying` (all pages). 12001 → SYMBOL_NOT_FOUND. */
+    async instruments(underlying) {
+        const out = [];
+        for (let page = 1, pages = 1; page <= pages; page++) {
+            let res;
+            try {
+                res = await this.client.call("get_all_instruments", {
+                    instrument_type: "option", currency: underlying, expired: false, page_size: PAGE_SIZE, page,
+                });
+            }
+            catch (e) {
+                if (deriveRpcCode(e) === DERIVE_INSTRUMENT_NOT_FOUND)
+                    throw noOptions(underlying);
+                throw e;
+            }
+            const r = obj(res, "get_all_instruments result");
+            if (!Array.isArray(r.instruments))
+                throw deriveShapeError("get_all_instruments result.instruments is not a list");
+            pages = int(obj(r.pagination, "get_all_instruments result.pagination"), "num_pages", "pagination");
+            for (const i of r.instruments)
+                out.push(parseDeriveInstrument(i));
+        }
+        return out;
+    }
+    async listExpiries(underlyingInput) {
+        const underlying = normalizeUnderlying(underlyingInput);
+        const expiries = expiriesOf(await this.instruments(underlying));
+        if (expiries.length === 0)
+            throw noOptions(underlying);
+        return { schema: OPTIONS_SCHEMA, venue: VENUE, underlying, expiries };
+    }
+    async getChain(q) {
+        const underlying = normalizeUnderlying(q.underlying);
+        const wanted = q.expiry === null ? null : normalizeExpiry(q.expiry);
+        if (q.strikesAroundAtm !== null && (!Number.isInteger(q.strikesAroundAtm) || q.strikesAroundAtm < 1)) {
+            throw new PerpError("INVALID_PARAMS", `--strikes must be a positive integer (got ${q.strikesAroundAtm})`, {
+                remediation: "Pass a positive integer, e.g. --strikes 10",
+            });
+        }
+        const all = await this.instruments(underlying);
+        const expiries = expiriesOf(all);
+        if (expiries.length === 0)
+            throw noOptions(underlying);
+        const expiry = wanted === null ? expiries[0] : expiries.find(e => e.expiry === wanted);
+        if (expiry === undefined) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Derive has no active ${underlying} option expiry ${wanted}`, {
+                exchange: VENUE,
+                remediation: `Active expiries: ${expiries.map(e => e.expiry).join(", ")} (perp -e ${VENUE} options expiries ${underlying})`,
+            });
+        }
+        const listed = all.filter(i => i.isActive && i.expiryMs === expiry.expiryMs);
+        const res = obj(await this.client.call("get_tickers", {
+            instrument_type: "option", currency: underlying, expiry_date: expiry.expiry.replace(/-/g, ""),
+        }), "get_tickers result");
+        return buildChain(underlying, expiry, wanted === null ? "nearest" : "requested", listed, res.tickers, q.strikesAroundAtm);
+    }
+    async getQuote(instrumentInput) {
+        const name = instrumentInput.trim().toUpperCase();
+        // Both reads are needed (instrument facts + live ticker); issued together, judged instrument first.
+        const [instR, tickR] = await Promise.allSettled([
+            this.client.call("get_instrument", { instrument_name: name }),
+            this.client.call("get_ticker", { instrument_name: name }),
+        ]);
+        if (instR.status === "rejected") {
+            if (deriveRpcCode(instR.reason) === DERIVE_INSTRUMENT_NOT_FOUND) {
+                throw new PerpError("SYMBOL_NOT_FOUND", `Derive has no instrument ${name}`, {
+                    exchange: VENUE, remediation: `Find option names: perp -e ${VENUE} options chain <UNDERLYING>`,
+                });
+            }
+            throw instR.reason;
+        }
+        const o = obj(instR.value, "get_instrument result");
+        if (o.instrument_type !== "option") {
+            throw new PerpError("INVALID_PARAMS", `${name} is a Derive ${String(o.instrument_type)}, not an option`, {
+                exchange: VENUE, remediation: `Find option names: perp -e ${VENUE} options chain <UNDERLYING>`,
+            });
+        }
+        const inst = parseDeriveInstrument(o);
+        if (!inst.isActive) {
+            throw new PerpError("SYMBOL_NOT_FOUND", `Derive option ${name} is listed but not active (activation ${new Date(inst.activationMs).toISOString()})`, {
+                exchange: VENUE, remediation: `Active expiries: perp -e ${VENUE} options expiries ${inst.underlying}`,
+            });
+        }
+        if (tickR.status === "rejected") {
+            // An active instrument with no ticker (-32602 "Ticker not found for instrument", live): an
+            // activation / expiry race on Derive's side — transient, never the user's INVALID_PARAMS.
+            if (deriveRpcCode(tickR.reason) === DERIVE_INVALID_PARAMS) {
+                throw new PerpError("EXCHANGE_ERROR", `Derive has no live ticker for active option ${name} (${tickR.reason instanceof Error ? tickR.reason.message : String(tickR.reason)})`, {
+                    exchange: VENUE, rpcCode: DERIVE_INVALID_PARAMS,
+                    remediation: `The option may be activating or expiring right now; retry in a moment, or list live instruments: perp -e ${VENUE} options chain ${inst.underlying} --expiry ${inst.expiry}`,
+                });
+            }
+            throw tickR.reason;
+        }
+        return parseDeriveOptionTicker(tickR.value, inst);
+    }
+}

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

@@ -0,0 +1,82 @@
+/**
+ * Extended public-only adapter — official API, MARKET DATA ONLY in this version (venues/extended.ts).
+ *
+ * Market data (markets, orderbook, trades, funding history, candles) is implemented with the
+ * documented public endpoints (https://api.docs.extended.exchange/ "Public REST-API"). Every
+ * account / trading method refuses with CAPABILITY_UNSUPPORTED before any request — there is no
+ * Extended account, order or signing code.
+ *
+ * A symbol is resolved first (resolveExtendedMarketRemote: `?market=<name>` reads, the full listing
+ * only when no wire-name candidate matches), so an unlisted symbol is SYMBOL_NOT_FOUND before any
+ * per-market request (the orderbook of an unknown market answers `{"status":"OK"}` without data,
+ * its trades `[]` — live 2026-10-19).
+ */
+import type { ExchangeAdapter, ExchangeBalance, ExchangeFundingPayment, ExchangeKline, ExchangeMarketInfo, ExchangeOrder, ExchangePosition, ExchangeTrade, ExchangePublicTrade } from "../interface.js";
+import { type VenueDefinition } from "../venue.js";
+import { type AssetClass, type Network } from "../venue-types.js";
+/** CLI candle interval → Extended ISO-8601 duration (docs "Get candles history" / candles stream). */
+export declare const EXTENDED_KLINE_INTERVALS: Readonly<Record<string, {
+    wire: string;
+    ms: number;
+}>>;
+/** Documented per-request maximum of the candles and funding-history endpoints. */
+export declare const EXTENDED_MAX_RECORDS = 10000;
+/** Legacy market row plus the Extended fields shown in JSON (asset class, precision, schedule). */
+export type ExtendedMarketInfo = ExchangeMarketInfo & {
+    venueSymbol: string;
+    canonical: string | null;
+    assetClass: AssetClass;
+    tickSize: string;
+    minSize: string;
+    tradable: boolean;
+    status: "ACTIVE" | "REDUCE_ONLY";
+    isRfq: boolean;
+    tradingHours: string;
+    isOffHours: boolean;
+    /** `fundingRate` is the current hour's accruing rate (fraction per hour), applied at nextFundingTime. */
+    fundingRateKind: "accruing";
+    nextFundingTime: number | null;
+};
+/** One applied hourly funding print (fraction per hour) with its normalization. */
+export interface ExtendedFundingPrint {
+    time: number;
+    rate: string;
+    price: null;
+    rateKind: "lastSettled";
+    intervalHours: 1;
+    /** rate × 24 × 365 × 100 (APR %, simple). */
+    annualizedPct: number;
+}
+export declare class ExtendedPublicAdapter implements ExchangeAdapter {
+    readonly venue: VenueDefinition;
+    readonly network: Network;
+    readonly name: "extended";
+    readonly aliases: readonly ["ext", "x10"];
+    private readonly client;
+    constructor(venue: VenueDefinition, network: Network);
+    /** Per-market reads resolve the symbol with the small `?market=` read (public.ts), not the full listing. */
+    private market;
+    getMarkets(): Promise<ExtendedMarketInfo[]>;
+    getOrderbook(symbol: string): Promise<{
+        bids: [string, string][];
+        asks: [string, string][];
+    }>;
+    getRecentTrades(symbol: string, limit?: number): Promise<ExchangePublicTrade[]>;
+    /** Applied (settled) hourly rates, newest first — fraction per hour; no oracle price published. */
+    getFundingHistory(symbol: string, limit?: number): Promise<ExtendedFundingPrint[]>;
+    getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    private refuse;
+    getBalance(): Promise<ExchangeBalance>;
+    getPositions(): Promise<ExchangePosition[]>;
+    getOpenOrders(): Promise<ExchangeOrder[]>;
+    getOrderHistory(): Promise<ExchangeOrder[]>;
+    getTradeHistory(): Promise<ExchangeTrade[]>;
+    getFundingPayments(): Promise<ExchangeFundingPayment[]>;
+    marketOrder(): Promise<unknown>;
+    limitOrder(): Promise<unknown>;
+    editOrder(): Promise<unknown>;
+    cancelOrder(): Promise<unknown>;
+    cancelAllOrders(): Promise<unknown>;
+    setLeverage(): Promise<unknown>;
+    stopOrder(): Promise<unknown>;
+}

package/dist/exchanges/extended/adapter.js

@@ -0,0 +1,179 @@
+/**
+ * Extended public-only adapter — official API, MARKET DATA ONLY in this version (venues/extended.ts).
+ *
+ * Market data (markets, orderbook, trades, funding history, candles) is implemented with the
+ * documented public endpoints (https://api.docs.extended.exchange/ "Public REST-API"). Every
+ * account / trading method refuses with CAPABILITY_UNSUPPORTED before any request — there is no
+ * Extended account, order or signing code.
+ *
+ * A symbol is resolved first (resolveExtendedMarketRemote: `?market=<name>` reads, the full listing
+ * only when no wire-name candidate matches), so an unlisted symbol is SYMBOL_NOT_FOUND before any
+ * per-market request (the orderbook of an unknown market answers `{"status":"OK"}` without data,
+ * its trades `[]` — live 2026-10-19).
+ */
+import { PerpError } from "../../errors.js";
+import { annualizeHourlyRate } from "../../funding/normalize.js";
+import { roleUnsupported } from "../venue.js";
+import { toLegacyMarketInfo } from "../venue-types.js";
+import { extendedShapeError } from "./client.js";
+import { extendedClient, fetchExtendedMarketRows, resolveExtendedMarketRemote } from "./public.js";
+/** CLI candle interval → Extended ISO-8601 duration (docs "Get candles history" / candles stream). */
+export const EXTENDED_KLINE_INTERVALS = {
+    "1m": { wire: "PT1M", ms: 60_000 },
+    "5m": { wire: "PT5M", ms: 300_000 },
+    "15m": { wire: "PT15M", ms: 900_000 },
+    "30m": { wire: "PT30M", ms: 1_800_000 },
+    "1h": { wire: "PT1H", ms: 3_600_000 },
+    "2h": { wire: "PT2H", ms: 7_200_000 },
+    "4h": { wire: "PT4H", ms: 14_400_000 },
+    "8h": { wire: "PT8H", ms: 28_800_000 },
+    "12h": { wire: "PT12H", ms: 43_200_000 },
+    "1d": { wire: "PT24H", ms: 86_400_000 },
+    "1w": { wire: "P7D", ms: 604_800_000 },
+};
+/** Documented per-request maximum of the candles and funding-history endpoints. */
+export const EXTENDED_MAX_RECORDS = 10_000;
+const DEC = /^-?\d+(\.\d+)?$/;
+function dec(v, what) {
+    if (typeof v !== "string" || !DEC.test(v))
+        throw extendedShapeError(`${what} is not a decimal string`);
+    return v;
+}
+function ms(v, what) {
+    if (typeof v !== "number" || !Number.isInteger(v) || v <= 0)
+        throw extendedShapeError(`${what} is not a ms timestamp`);
+    return v;
+}
+export class ExtendedPublicAdapter {
+    venue;
+    network;
+    name = "extended";
+    aliases = ["ext", "x10"];
+    client;
+    constructor(venue, network) {
+        this.venue = venue;
+        this.network = network;
+        this.client = extendedClient(network);
+    }
+    /** Per-market reads resolve the symbol with the small `?market=` read (public.ts), not the full listing. */
+    async market(symbol) {
+        return resolveExtendedMarketRemote(this.client, symbol);
+    }
+    // ── Market data ──
+    async getMarkets() {
+        const rows = await fetchExtendedMarketRows(this.client);
+        return rows.map(({ meta, market, nextFundingTime }) => ({
+            ...toLegacyMarketInfo(market),
+            venueSymbol: market.venueSymbol,
+            canonical: market.canonical,
+            assetClass: market.assetClass,
+            tickSize: market.tickSize,
+            minSize: market.minSize,
+            tradable: market.tradable,
+            status: meta.status,
+            isRfq: meta.isRfq,
+            tradingHours: meta.tradingHours,
+            isOffHours: meta.isOffHours,
+            fundingRateKind: "accruing",
+            nextFundingTime,
+        }));
+    }
+    async getOrderbook(symbol) {
+        const m = await this.market(symbol);
+        const body = await this.client.get(`/info/markets/${encodeURIComponent(m.name)}/orderbook`);
+        const data = body.data;
+        if (data === undefined || data === null || !Array.isArray(data.bid) || !Array.isArray(data.ask)) {
+            throw extendedShapeError(`orderbook of ${m.name} has no bid / ask lists`);
+        }
+        const side = (rows, what) => rows.map(r => {
+            const x = r;
+            return [dec(x.price, `${what} price`), dec(x.qty, `${what} qty`)];
+        });
+        return { bids: side(data.bid, "orderbook bid"), asks: side(data.ask, "orderbook ask") };
+    }
+    async getRecentTrades(symbol, limit = 50) {
+        const m = await this.market(symbol);
+        const body = await this.client.get(`/info/markets/${encodeURIComponent(m.name)}/trades`);
+        if (!Array.isArray(body.data))
+            throw extendedShapeError(`trades of ${m.name} is not a list`);
+        const trades = body.data.map(t => {
+            const x = t;
+            if (x.S !== "BUY" && x.S !== "SELL")
+                throw extendedShapeError(`trade side ${String(x.S)}`);
+            // Public tape carries no fee.
+            return { time: ms(x.T, "trade T"), symbol: m.symbol, side: x.S === "BUY" ? "buy" : "sell", price: dec(x.p, "trade p"), size: dec(x.q, "trade q"), fee: null };
+        });
+        // Newest first, like every other venue's tape.
+        return trades.sort((a, b) => b.time - a.time).slice(0, limit);
+    }
+    /** Applied (settled) hourly rates, newest first — fraction per hour; no oracle price published. */
+    async getFundingHistory(symbol, limit = 10) {
+        if (!Number.isInteger(limit) || limit < 1 || limit > EXTENDED_MAX_RECORDS) {
+            throw new PerpError("INVALID_PARAMS", `Extended: funding history limit must be 1..${EXTENDED_MAX_RECORDS} (got ${limit})`);
+        }
+        const m = await this.market(symbol);
+        const end = Date.now();
+        // One record per hour; two spare hours cover the in-progress hour and clock skew.
+        const start = end - (limit + 2) * 3_600_000;
+        const body = await this.client.get(`/info/${encodeURIComponent(m.name)}/funding`, [
+            ["startTime", String(start)], ["endTime", String(end)], ["limit", String(limit)],
+        ]);
+        if (!Array.isArray(body.data))
+            throw extendedShapeError(`funding history of ${m.name} is not a list`);
+        return body.data
+            .map(r => {
+            const x = r;
+            const rate = dec(x.f, "funding f");
+            return { time: ms(x.T, "funding T"), rate, price: null, rateKind: "lastSettled", intervalHours: 1, annualizedPct: annualizeHourlyRate(Number(rate)) };
+        })
+            .sort((a, b) => b.time - a.time)
+            .slice(0, limit);
+    }
+    async getKlines(symbol, interval, startTime, endTime) {
+        const iv = Object.prototype.hasOwnProperty.call(EXTENDED_KLINE_INTERVALS, interval) ? EXTENDED_KLINE_INTERVALS[interval] : undefined;
+        if (iv === undefined) {
+            throw new PerpError("INVALID_PARAMS", `Extended: unsupported candle interval "${interval}"`, {
+                remediation: `Use one of: ${Object.keys(EXTENDED_KLINE_INTERVALS).join(", ")}`,
+            });
+        }
+        if (!(endTime > startTime))
+            throw new PerpError("INVALID_PARAMS", "Extended: candle end time must be after the start time");
+        const m = await this.market(symbol);
+        const limit = Math.min(EXTENDED_MAX_RECORDS, Math.ceil((endTime - startTime) / iv.ms) + 1);
+        const body = await this.client.get(`/info/candles/${encodeURIComponent(m.name)}/trades`, [
+            ["interval", iv.wire], ["limit", String(limit)], ["endTime", String(endTime)],
+        ]);
+        if (!Array.isArray(body.data))
+            throw extendedShapeError(`candles of ${m.name} is not a list`);
+        return body.data
+            .map(c => {
+            const x = c;
+            return {
+                time: ms(x.T, "candle T"),
+                open: dec(x.o, "candle o"), high: dec(x.h, "candle h"), low: dec(x.l, "candle l"), close: dec(x.c, "candle c"),
+                volume: dec(x.v, "candle v"),
+                quoteVolume: null,
+                trades: null,
+            };
+        })
+            .filter(k => k.time >= startTime && k.time <= endTime)
+            .sort((a, b) => a.time - b.time);
+    }
+    // ── Account / trading: refused (market data only in this version) ──
+    refuse(feature) {
+        throw roleUnsupported(this.venue, feature);
+    }
+    async getBalance() { return this.refuse("account"); }
+    async getPositions() { return this.refuse("account"); }
+    async getOpenOrders() { return this.refuse("account"); }
+    async getOrderHistory() { return this.refuse("account"); }
+    async getTradeHistory() { return this.refuse("account"); }
+    async getFundingPayments() { return this.refuse("account"); }
+    async marketOrder() { return this.refuse("trading"); }
+    async limitOrder() { return this.refuse("trading"); }
+    async editOrder() { return this.refuse("trading"); }
+    async cancelOrder() { return this.refuse("trading"); }
+    async cancelAllOrders() { return this.refuse("trading"); }
+    async setLeverage() { return this.refuse("trading"); }
+    async stopOrder() { return this.refuse("trading"); }
+}

package/dist/exchanges/extended/client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Extended public REST transport (official API, https://api.docs.extended.exchange/).
+ *
+ * Every response is `{status:"OK", data, pagination?}` or `{status:"ERROR", error:{code, message}}`
+ * (live 2026-10-19: an unknown market on /info/markets?market= or /info/<m>/funding is HTTP 400
+ * `{"code":1001,"message":"Market not found"}`). A User-Agent header is mandatory (docs
+ * "Mandatory headers"; without one the API answers 403). GET only — there is no write path.
+ */
+import { PerpError } from "../../errors.js";
+import type { RateLimitPolicy } from "../venue.js";
+export declare const EXTENDED_HTTP_TIMEOUT_MS = 15000;
+export declare const EXTENDED_USER_AGENT = "perp-cli";
+/** Extended's error code for an unknown market (live 2026-10-19). */
+export declare const EXTENDED_MARKET_NOT_FOUND = 1001;
+/** A body that does not match the documented shape: an explicit EXCHANGE_ERROR, never a guess. */
+export declare function extendedShapeError(what: string): PerpError;
+export interface ExtendedErrorBody {
+    code: number | string | null;
+    message: string;
+}
+export declare class ExtendedClient {
+    private readonly restUrl;
+    private readonly rateLimit;
+    /** Limiter bucket: one per network (the documented limit is per IP, per host). */
+    private readonly bucket;
+    constructor(restUrl: string, rateLimit: RateLimitPolicy, 
+    /** Limiter bucket: one per network (the documented limit is per IP, per host). */
+    bucket: string);
+    /**
+     * GET <rest><path>; returns the parsed body (`status: "OK"`). Every failure is a PerpError:
+     * transport → EXCHANGE_UNREACHABLE, 429 → RATE_LIMITED, `{status:"ERROR"}` / non-2xx /
+     * non-JSON → EXCHANGE_ERROR (an unknown market keeps the venue's 1001 code in details).
+     */
+    get<T = unknown>(path: string, query?: ReadonlyArray<[string, string]>): Promise<{
+        status: "OK";
+        data?: T;
+    } & Record<string, unknown>>;
+}