perp-cli 0.14.3 → 0.16.0

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

@@ -0,0 +1,96 @@
+/**
+ * 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 (accepted `limit`). */
+export declare const EXTENDED_MAX_RECORDS = 10000;
+/**
+ * Real server caps, measured live 2026-10-19 (BTC-USD; no pagination field, no error): candles
+ * return at most 2800 rows on every interval with that much history (PT1M … PT4H: 2800; PT8H 2445,
+ * PT12H 1631, PT24H 816, P7D 118, P30D 28 = the whole history since 2024-07), funding history at
+ * most 1000 (the newest). Both page backwards with `endTime` = before the oldest row and stop only
+ * on an empty page or at the window start — a short page is never taken as the end.
+ */
+export declare const EXTENDED_CANDLES_PAGE_CAP = 2800;
+export declare const EXTENDED_FUNDING_PAGE_CAP = 1000;
+export declare const EXTENDED_TRADES_CAP = 50;
+/** 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.
+     * Paged backwards in pages of EXTENDED_FUNDING_PAGE_CAP until `limit` rows or the window start.
+     */
+    getFundingHistory(symbol: string, limit?: number): Promise<ExtendedFundingPrint[]>;
+    /** Candles paged backwards from `endTime` in pages of EXTENDED_CANDLES_PAGE_CAP (newest first on the wire). */
+    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,241 @@
+/**
+ * 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 },
+    // P30D answers calendar-month candles (live 2026-10-19: opens on the 1st, 00:00 UTC); ms is
+    // the nominal 30 d used only to size requests.
+    "1M": { wire: "P30D", ms: 2_592_000_000 },
+};
+/** Documented per-request maximum of the candles and funding-history endpoints (accepted `limit`). */
+export const EXTENDED_MAX_RECORDS = 10_000;
+/**
+ * Real server caps, measured live 2026-10-19 (BTC-USD; no pagination field, no error): candles
+ * return at most 2800 rows on every interval with that much history (PT1M … PT4H: 2800; PT8H 2445,
+ * PT12H 1631, PT24H 816, P7D 118, P30D 28 = the whole history since 2024-07), funding history at
+ * most 1000 (the newest). Both page backwards with `endTime` = before the oldest row and stop only
+ * on an empty page or at the window start — a short page is never taken as the end.
+ */
+export const EXTENDED_CANDLES_PAGE_CAP = 2800;
+export const EXTENDED_FUNDING_PAGE_CAP = 1000;
+const EXTENDED_MAX_PAGES = 50;
+export const EXTENDED_TRADES_CAP = 50;
+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) {
+        // The endpoint takes no limit and answers the last 50 trades (live 2026-10-19, `limit=500` → 50).
+        if (!Number.isInteger(limit) || limit < 1 || limit > EXTENDED_TRADES_CAP) {
+            throw new PerpError("INVALID_PARAMS", `Extended: trades limit must be 1..${EXTENDED_TRADES_CAP} (got ${limit})`, { remediation: `Extended publishes only the last ${EXTENDED_TRADES_CAP} trades` });
+        }
+        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.
+     * Paged backwards in pages of EXTENDED_FUNDING_PAGE_CAP until `limit` rows or the window start.
+     */
+    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 byTime = new Map();
+        let cursor = end;
+        for (let page = 0; byTime.size < limit; page++) {
+            if (page >= EXTENDED_MAX_PAGES)
+                throw new PerpError("EXCHANGE_ERROR", `Extended: funding history of ${m.name} did not end after ${EXTENDED_MAX_PAGES} pages`);
+            const want = Math.min(EXTENDED_FUNDING_PAGE_CAP, limit - byTime.size);
+            const body = await this.client.get(`/info/${encodeURIComponent(m.name)}/funding`, [
+                ["startTime", String(start)], ["endTime", String(cursor)], ["limit", String(want)],
+            ]);
+            if (!Array.isArray(body.data))
+                throw extendedShapeError(`funding history of ${m.name} is not a list`);
+            const rows = 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)) };
+            });
+            for (const r of rows)
+                byTime.set(r.time, r);
+            // Only an empty page ends the window (a short page is not trusted as the end).
+            if (rows.length === 0)
+                break;
+            const oldest = Math.min(...rows.map(r => r.time));
+            if (oldest <= start)
+                break;
+            if (oldest >= cursor)
+                throw extendedShapeError(`funding history of ${m.name} did not move back past ${new Date(cursor).toISOString()}`);
+            cursor = oldest - 1;
+        }
+        return [...byTime.values()].sort((a, b) => b.time - a.time).slice(0, limit);
+    }
+    /** Candles paged backwards from `endTime` in pages of EXTENDED_CANDLES_PAGE_CAP (newest first on the wire). */
+    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 bars = Math.ceil((endTime - startTime) / iv.ms) + 1;
+        const pages = Math.ceil(bars / EXTENDED_CANDLES_PAGE_CAP);
+        if (pages > EXTENDED_MAX_PAGES) {
+            throw new PerpError("INVALID_PARAMS", `Extended: ${interval} candles over this range need ${pages} requests (max ${EXTENDED_MAX_PAGES})`, {
+                remediation: "Narrow --start / --end or use a longer interval",
+            });
+        }
+        const m = await this.market(symbol);
+        const byTime = new Map();
+        // `endTime` is exclusive on the wire (a bar opening exactly at it is not returned): +1 ms makes
+        // `--end` inclusive like every other venue.
+        let cursor = endTime + 1;
+        for (let page = 0; page < EXTENDED_MAX_PAGES + 1; page++) {
+            const want = Math.min(EXTENDED_CANDLES_PAGE_CAP, Math.ceil((cursor - startTime) / iv.ms) + 1);
+            const body = await this.client.get(`/info/candles/${encodeURIComponent(m.name)}/trades`, [
+                ["interval", iv.wire], ["limit", String(want)], ["endTime", String(cursor)],
+            ]);
+            if (!Array.isArray(body.data))
+                throw extendedShapeError(`candles of ${m.name} is not a list`);
+            const rows = 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,
+                };
+            });
+            for (const k of rows)
+                if (k.time >= startTime && k.time <= endTime)
+                    byTime.set(k.time, k);
+            // Only an EMPTY page ends the history: a short page is not trusted as the end (the cap is
+            // per interval and was measured, not documented), it just costs one more request.
+            if (rows.length === 0)
+                break;
+            const oldest = Math.min(...rows.map(k => k.time));
+            if (oldest <= startTime)
+                break;
+            if (oldest >= cursor)
+                throw extendedShapeError(`candles of ${m.name} did not move back past ${new Date(cursor).toISOString()}`);
+            cursor = oldest - 1;
+        }
+        return [...byTime.values()].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>>;
+}

package/dist/exchanges/extended/client.js

@@ -0,0 +1,88 @@
+/**
+ * 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, extractErrorMessage } from "../../errors.js";
+import { acquireRate, rateLimitedError } from "../rate-limiter.js";
+export const EXTENDED_HTTP_TIMEOUT_MS = 15_000;
+export const EXTENDED_USER_AGENT = "perp-cli";
+/** Extended's error code for an unknown market (live 2026-10-19). */
+export const EXTENDED_MARKET_NOT_FOUND = 1001;
+/** A body that does not match the documented shape: an explicit EXCHANGE_ERROR, never a guess. */
+export function extendedShapeError(what) {
+    return new PerpError("EXCHANGE_ERROR", `Extended API response did not match the documented shape: ${what}`, {
+        exchange: "extended",
+        remediation: "Extended changed its public API; perp-cli needs an update to read it",
+    });
+}
+function errorBodyOf(parsed) {
+    if (parsed === null || typeof parsed !== "object")
+        return null;
+    const p = parsed;
+    if (p.status !== "ERROR")
+        return null;
+    const e = p.error;
+    const code = typeof e?.code === "number" || typeof e?.code === "string" ? e.code : null;
+    return { code, message: typeof e?.message === "string" ? e.message : JSON.stringify(p.error === undefined ? null : p.error) };
+}
+export class ExtendedClient {
+    restUrl;
+    rateLimit;
+    bucket;
+    constructor(restUrl, rateLimit, 
+    /** Limiter bucket: one per network (the documented limit is per IP, per host). */
+    bucket) {
+        this.restUrl = restUrl;
+        this.rateLimit = rateLimit;
+        this.bucket = bucket;
+    }
+    /**
+     * 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).
+     */
+    async get(path, query = []) {
+        await acquireRate(this.bucket, this.rateLimit, path);
+        const qs = query.length > 0 ? `?${query.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&")}` : "";
+        let res;
+        try {
+            res = await fetch(`${this.restUrl}${path}${qs}`, {
+                headers: { accept: "application/json", "user-agent": EXTENDED_USER_AGENT },
+                signal: AbortSignal.timeout(EXTENDED_HTTP_TIMEOUT_MS),
+            });
+        }
+        catch (e) {
+            throw new PerpError("EXCHANGE_UNREACHABLE", `Extended ${path}: ${extractErrorMessage(e)}`, { exchange: "extended" });
+        }
+        const text = await res.text().catch((e) => {
+            throw new PerpError("EXCHANGE_UNREACHABLE", `Extended ${path}: response body unreadable (${extractErrorMessage(e)})`, { exchange: "extended" });
+        });
+        if (res.status === 429)
+            throw rateLimitedError("extended", res.headers.get("retry-after"), text);
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = undefined;
+        }
+        const err = errorBodyOf(parsed);
+        if (err !== null || !res.ok) {
+            const msg = err !== null ? `${err.code === null ? "" : `${err.code} `}${err.message}` : `HTTP ${res.status} ${text.slice(0, 200)}`;
+            throw new PerpError("EXCHANGE_ERROR", `Extended ${path}: ${msg}`, {
+                exchange: "extended", status: res.status,
+                ...(err !== null && err.code !== null ? { venueCode: err.code } : {}),
+            });
+        }
+        if (parsed === undefined)
+            throw extendedShapeError(`${path} returned a non-JSON body`);
+        if (parsed === null || typeof parsed !== "object" || parsed.status !== "OK") {
+            throw extendedShapeError(`${path} has no status "OK"`);
+        }
+        return parsed;
+    }
+}

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

@@ -0,0 +1,133 @@
+/**
+ * Extended public market data — GET /api/v1/info/markets (one call serves markets and funding).
+ * Docs: https://api.docs.extended.exchange/ ("Get markets").
+ *
+ * Mapping:
+ *  - Only `type: "PERPETUAL"` rows with `status` ACTIVE or REDUCE_ONLY are markets here. The
+ *    `active` flag is NOT a listing state (live 2026-10-19: 54 DELISTED and 12 PRELISTED rows have
+ *    `active: true`); SPOT rows carry perp fields as 0 (docs) and are excluded.
+ *  - venueSymbol = `name` ("BTC-USD", "TSLA_24_5-USD", "SPX500m-USD"), the wire id of every
+ *    per-market endpoint. symbol = `assetName` upper-cased with the `_24_5` naming suffix removed
+ *    ("TSLA_24_5" → "TSLA", "SPX500m" → "SPX500M"). Two listed markets with one symbol: the single
+ *    ACTIVE one is kept, else both are skipped (warned).
+ *  - tradable = status ACTIVE && !isOffHours (docs "Trading hours": while isOffHours, order
+ *    placement and execution are unavailable). REDUCE_ONLY rows are listed, not tradable.
+ *  - tick = tradingConfig.minPriceChange, step = minOrderSizeChange, min size = minOrderSize,
+ *    maxLeverage = tradingConfig.maxLeverage; marginTiers from riskFactorConfig (rows available to
+ *    users; leverage = 1 / riskFactor — the first tier equals maxLeverage on every live market).
+ *  - open interest = marketStats.openInterestBase (base units); 24h volume = dailyVolume (USD).
+ *
+ * Asset class (`category` / `subCategory`): Crypto → crypto; RWA → Equity: equity, Commodity:
+ * commodity, FX: fx, Pre-market: preIpo, ETF/Index: etf for the ETFs in EXTENDED_ETFS, else index.
+ * Any other category / subCategory is skipped with a warning (never guessed).
+ *
+ * Canonical (cross-venue key, canonical-symbols.ts): crypto and equity / ETF by ticker identity;
+ * index / commodity / fx / preIpo only through EXPLICIT_CANONICAL. An RWA ticker that is also a
+ * crypto ticker is NEVER matched (canonical null): EXTENDED_RWA_CRYPTO_COLLISIONS (PURR =
+ * Hyperliquid Strategies Inc. vs the PURR token; QNT = Quantinuum vs Quant; BB = BlackBerry vs
+ * BounceBit; ON = ON Semiconductor vs the ON token; ADI = Analog Devices vs the ADI token). An RWA
+ * ticker equal to one of Extended's own crypto symbols is never matched either: symbols are unique per
+ * listing (dedupeSymbols). The crypto SPX market (SPX6900) is ambiguous with the S&P 500 index
+ * canonical "SPX" and is never matched (EXTENDED_AMBIGUOUS_CRYPTO, as Hyperliquid's SPX). XIAOMI is
+ * not matched (EXTENDED_UNMATCHED_EQUITIES): ~7.8× the Lighter / Aster XIAOMI price on 2026-10-19,
+ * i.e. a different unit (HKD-per-share vs a USD-quoted product), not the same contract.
+ *
+ * Funding (docs "Get funding rates history" + docs.extended.exchange funding-payments):
+ *  - applied once per hour ("While the funding rate is calculated every minute, it is only applied
+ *    once per hour"); payment = position size × mark price × (−rate).
+ *  - marketStats.fundingRate is a FRACTION per hour (crypto interest component 0.01 % / 8 h =
+ *    0.0000125 / h, published as "0.000013"; RWA 0.0035 % / 8 h → "0.000004").
+ *  - it is the CURRENT hour's rate, recomputed every minute (accruing): it can differ from the last
+ *    applied print in /info/<market>/funding mid-hour, and becomes that print at the hour.
+ *  - marketStats.nextFundingRate is (despite its name) the timestamp (ms) of the next application.
+ *  - rates are published ROUNDED TO 6 DECIMALS (resolution 0.000001 / h ≈ 0.876 % APR): the
+ *    0.0000125 baseline reads "0.000013", and a rate below 0.0000005 / h reads "0.000000".
+ *    There is no more precise public source (checked live 2026-10-19): /info/markets (407
+ *    markets), /info/markets/<m>/stats and the applied history /info/<m>/funding (`f`, 48 h of
+ *    ETH / SOL) all carry at most 6 decimals, so the adapter keeps this one read.
+ *  - `_24_5` RWA equities print 0 while their underlying is closed (TSLA_24_5-USD: 34 of 43
+ *    weekend prints were 0), so an hourly rate × 8760 overstates them — the venue is
+ *    fundingVerified false (venues/extended.ts).
+ */
+import { type VenuePublicData } from "../venue.js";
+import type { AssetClass, FundingRateBasis, Network, VenueFundingRate, VenueMarket } from "../venue-types.js";
+import { ExtendedClient } from "./client.js";
+export declare const EXTENDED_FUNDING_BASIS: FundingRateBasis;
+/** RWA "ETF/Index" markets that are ETFs (the rest of that subCategory are indices). */
+export declare const EXTENDED_ETFS: ReadonlySet<string>;
+/**
+ * RWA tickers that are also crypto tickers on other venues (live 2026-10-19) — never matched.
+ * ADI: Analog Devices vs Lighter's ADI token. BOT: RoboStrategy (PRELISTED on 2026-10-19) vs the BOT
+ * token (Lighter LIGHTER_AMBIGUOUS). WEN (also Lighter-ambiguous) is not listed on Extended.
+ */
+export declare const EXTENDED_RWA_CRYPTO_COLLISIONS: ReadonlySet<string>;
+/** RWA markets whose product differs from the same ticker elsewhere (XIAOMI: ~7.8× Lighter / Aster). */
+export declare const EXTENDED_UNMATCHED_EQUITIES: ReadonlySet<string>;
+/** Crypto tickers that name an index elsewhere — never matched (SPX-USD = SPX6900, not the S&P 500). */
+export declare const EXTENDED_AMBIGUOUS_CRYPTO: ReadonlySet<string>;
+export interface ExtendedMarketMeta {
+    /** Wire id ("BTC-USD"). */
+    name: string;
+    symbol: string;
+    assetClass: AssetClass;
+    canonical: string | null;
+    status: "ACTIVE" | "REDUCE_ONLY";
+    isRfq: boolean;
+    isOffHours: boolean;
+    tradingHours: string;
+}
+export interface ExtendedMarketRow {
+    meta: ExtendedMarketMeta;
+    market: VenueMarket;
+    nextFundingTime: number | null;
+}
+/** "TSLA_24_5" → "TSLA"; "SPX500m" → "SPX500M". */
+export declare function extendedSymbolOf(assetName: string): string;
+/** Asset class from category / subCategory; null = unknown (the row is skipped with a warning). */
+export declare function extendedAssetClass(category: string, subCategory: string | null, symbol: string): AssetClass | null;
+/** Canonical key, or null when the market must not be matched across venues. */
+export declare function extendedCanonical(symbol: string, assetClass: AssetClass): string | null;
+/**
+ * Parse /info/markets `data` into listed perpetual markets. A row that does not match the
+ * documented shape is skipped with a warning naming it (one drifted row never hides the others);
+ * rows of an unknown category, without a mark price, or sharing a symbol (dedupeSymbols) are
+ * skipped with a warning too. EXCHANGE_ERROR only for envelope drift (`data` not a list) or when
+ * malformed rows leave no market at all.
+ */
+export declare function parseExtendedMarkets(data: unknown, warn: (msg: string) => void): ExtendedMarketRow[];
+export declare function extendedClient(net: Network): ExtendedClient;
+export interface ExtendedPublicDeps {
+    warn: (msg: string) => void;
+}
+export declare function fetchExtendedMarketRows(client: ExtendedClient, deps?: ExtendedPublicDeps): Promise<ExtendedMarketRow[]>;
+export declare function fetchExtendedMarkets(net: Network, deps?: ExtendedPublicDeps): Promise<VenueMarket[]>;
+/** Funding rows: the current hour's accruing rate (fraction per hour); a market without one has no row. */
+export declare function toExtendedFundingRates(rows: readonly ExtendedMarketRow[]): VenueFundingRate[];
+export declare function fetchExtendedFundingRates(net: Network, deps?: ExtendedPublicDeps): Promise<VenueFundingRate[]>;
+export declare const extendedPublicData: VenuePublicData;
+/**
+ * Resolve a CLI symbol against the listed markets: the wire name ("BTC-USD", "TSLA_24_5-USD")
+ * first, then the display symbol ("tsla", "BTC-PERP"), then "<symbol>-USD" ("TSLA-USD").
+ * Unlisted → SYMBOL_NOT_FOUND.
+ */
+export declare function resolveExtendedMarket(markets: readonly ExtendedMarketMeta[], input: string): ExtendedMarketMeta;
+/** Wire names a bare CLI symbol may be ("btc" → BTC-USD, BTC_24_5-USD): every name whose row maps to that symbol. */
+export declare function extendedWireCandidates(symbol: string): string[];
+/**
+ * Resolve a CLI symbol for a per-market read without the ~1 MB full listing, by the SAME rules as
+ * the listing (parseExtendedMarkets → dedupeSymbols, with its warning):
+ *  1. The symbol's wire names are read with `GET /info/markets?market=<name>` (2–3 KB each;
+ *     case-sensitive; unknown = HTTP 400 code 1001): for a bare symbol `<S>-USD` and
+ *     `<S>_24_5-USD`; for a wire name ("NOW-USD") that name first, then the other names of the
+ *     symbol its row maps to — so a ticker migration (NOW-USD + NOW_24_5-USD) is deduplicated here
+ *     exactly as in `market list`.
+ *  2. Every returned row goes through parseExtendedMarkets: not a listed perpetual, unpriced, or
+ *     losing the duplicate-symbol rule → not a market. resolveExtendedMarket then decides;
+ *     nothing left → SYMBOL_NOT_FOUND.
+ *  3. Only when EVERY name answered 1001 (no row at all — e.g. "spx500m" for SPX500m-USD) does the
+ *     full listing decide.
+ * A malformed row in a `?market=` reply is EXCHANGE_ERROR when it leaves no row to parse (the
+ * market asked for is unreadable — no fallback to the listing); next to a valid row it is skipped
+ * with a warning, as in the listing. Any error other than 1001 is thrown as is.
+ */
+export declare function resolveExtendedMarketRemote(client: ExtendedClient, input: string, deps?: ExtendedPublicDeps): Promise<ExtendedMarketMeta>;