perp-cli 0.14.0 → 0.14.2

package/dist/exchanges/arcus/adapter.js

@@ -30,7 +30,7 @@ import { networkConfig, requireCapabilities } from "../venue.js";
 import { parseOrderRef, toLegacyMarketInfo, } from "../venue-types.js";
 import { ArcusClient, arcusLeverageRejectError, arcusRejectionError } from "./client.js";
 import { ed25519PubHexFromBase58 } from "./agent.js";
-import { fetchArcusRawMarkets, toArcusVenueMarket } from "./public.js";
+import { fetchArcusRawMarkets, onlineArcusMarkets, toArcusVenueMarket } from "./public.js";
 import { QUOTE_QUANTUM, assertArcusClientId, canonicalJson, cancelPayload, modifyPayload, nowNs, placePayload, signUtf8Hex, splitEvmSignature, withdrawTypedData, } from "./signing.js";
 /**
  * goodTilTime horizon. Arcus rejects anything nearer than one month at
@@ -49,6 +49,18 @@ const CLIENT_ID_HISTORY_SCAN = 200;
 /** GET /v1/openOrders page cap (default = max = 1000). */
 const OPEN_ORDERS_PAGE = 1000;
 const CANDLE_TIMEFRAMES = new Set(["1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "8h", "12h", "1d", "3d", "1w"]);
+/** Bar length (ms) per timeframe — sizes the GET /v1/candles windows. */
+const CANDLE_MS = {
+    "1m": 60_000, "3m": 180_000, "5m": 300_000, "15m": 900_000, "30m": 1_800_000, "1h": 3_600_000, "2h": 7_200_000,
+    "4h": 14_400_000, "8h": 28_800_000, "12h": 43_200_000, "1d": 86_400_000, "3d": 259_200_000, "1w": 604_800_000,
+};
+/**
+ * GET /v1/candles returns at most 1500 candles (newest first; live 2026-10-13: a 48 h 1m request
+ * answers `total: 1500` covering the newest ~25 h). Ranges are read in windows of this many bars.
+ */
+const CANDLE_WINDOW_BARS = 1450;
+/** Window cap per call (≈ 72 500 bars); a wider range is refused rather than truncated. */
+const CANDLE_MAX_WINDOWS = 50;
 // ── Helpers ──
 const STATUS_MAP = {
     ACK: "accepted",
@@ -447,7 +459,7 @@ export class ArcusAdapter {
     // ── TradingV2 ──
     async getVenueMarkets() {
         const raw = await fetchArcusRawMarkets(this.client);
-        return raw.map(toArcusVenueMarket);
+        return onlineArcusMarkets(raw).map(toArcusVenueMarket);
     }
     async placeOrder(input) {
         // §13.3: GTC is the uniform default for a limit order without a TIF.
@@ -888,10 +900,25 @@ export class ArcusAdapter {
             });
         }
         const m = await this.market(symbol);
-        const res = await this.client.get("/v1/candles", "candles", { market: m.marketDisplayName, timeframe: interval, from: startTime * 1000, to: endTime * 1000 });
-        return res.candles
-            .map(c => ({ time: usToMs(c.openTime), open: c.open, high: c.high, low: c.low, close: c.close, volume: c.volume, trades: c.tradeCount }))
-            .sort((x, y) => x.time - y.time);
+        const span = CANDLE_WINDOW_BARS * CANDLE_MS[interval];
+        const windows = Math.max(1, Math.ceil((endTime - startTime) / span));
+        if (windows > CANDLE_MAX_WINDOWS) {
+            throw new PerpError("INVALID_PARAMS", `Arcus: ${interval} candles over this range need ${windows} requests (max ${CANDLE_MAX_WINDOWS})`, {
+                remediation: "Narrow --start / --end or use a longer interval",
+            });
+        }
+        // Disjoint windows [from, to) — the venue caps one response at 1500 candles, so one wide
+        // request would silently drop the oldest bars. Merged and deduped by open time.
+        const byTime = new Map();
+        for (let from = startTime; from < endTime; from += span) {
+            const to = Math.min(from + span, endTime);
+            const res = await this.client.get("/v1/candles", "candles", { market: m.marketDisplayName, timeframe: interval, from: from * 1000, to: to * 1000 });
+            for (const c of res.candles) {
+                const time = usToMs(c.openTime);
+                byTime.set(time, { time, open: c.open, high: c.high, low: c.low, close: c.close, volume: c.volume, trades: c.tradeCount });
+            }
+        }
+        return [...byTime.values()].sort((x, y) => x.time - y.time);
     }
     // ── Legacy: account ──
     async rawPositions() {

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

@@ -62,4 +62,10 @@ export interface ArcusRawMarket {
 export declare function fetchArcusRawMarkets(client: ArcusClient): Promise<ArcusRawMarket[]>;
 export declare function arcusAssetClass(m: ArcusRawMarket): AssetClass;
 export declare function toArcusVenueMarket(m: ArcusRawMarket): VenueMarket;
+/**
+ * Markets that are not ONLINE carry placeholder values (live 2026-10-13: the OFFLINE markets
+ * F, BAC, CCL, VT, SGOV, RVI report markPrice "0" and fundingRate "0") — they are left out of
+ * market / funding lists rather than listed at a $0 price and 0 % funding.
+ */
+export declare function onlineArcusMarkets(raw: ArcusRawMarket[]): ArcusRawMarket[];
 export declare const arcusPublicData: VenuePublicData;

package/dist/exchanges/arcus/public.js

@@ -76,8 +76,8 @@ function sessionOf(m) {
 export function toArcusVenueMarket(m) {
     const assetClass = arcusAssetClass(m);
     const mark = numOrNull(m.markPrice);
-    if (mark === null) {
-        throw new PerpError("EXCHANGE_ERROR", `Arcus market ${m.marketDisplayName}: missing markPrice`);
+    if (mark === null || !(Number(mark) > 0)) {
+        throw new PerpError("EXCHANGE_ERROR", `Arcus market ${m.marketDisplayName}: missing / non-positive markPrice (${JSON.stringify(m.markPrice)})`);
     }
     return {
         venue: "arcus",
@@ -104,15 +104,23 @@ export function toArcusVenueMarket(m) {
         tradable: m.status === "ONLINE",
     };
 }
+/**
+ * Markets that are not ONLINE carry placeholder values (live 2026-10-13: the OFFLINE markets
+ * F, BAC, CCL, VT, SGOV, RVI report markPrice "0" and fundingRate "0") — they are left out of
+ * market / funding lists rather than listed at a $0 price and 0 % funding.
+ */
+export function onlineArcusMarkets(raw) {
+    return raw.filter(m => m.status === "ONLINE");
+}
 async function fetchMarkets(net) {
     const raw = await fetchArcusRawMarkets(new ArcusClient(net, null));
-    return raw.map(toArcusVenueMarket);
+    return onlineArcusMarkets(raw).map(toArcusVenueMarket);
 }
 async function fetchFundingRates(net) {
     const raw = await fetchArcusRawMarkets(new ArcusClient(net, null));
     const out = [];
     const missing = [];
-    for (const m of raw) {
+    for (const m of onlineArcusMarkets(raw)) {
         const rate = numOrNull(m.fundingRate);
         if (rate === null) {
             missing.push(m.marketDisplayName);

package/dist/exchanges/aster.d.ts

@@ -61,6 +61,13 @@ type ResolvedSigner = {
     /** EVM address of the owner/master — used as `user` field in Aster requests */
     userAddress: string;
 };
+/**
+ * Max GET /fapi/v3/income requests for one 7-day read (7 daily slices + splits of full slices).
+ * The endpoint weighs 30 against Aster's 2400/min request weight, so 60 requests = 1800 — inside
+ * one minute's budget with room for the per-symbol fan-out. Enough for ~2000 fills/day; beyond
+ * that the read refuses (EXCHANGE_ERROR) rather than returning a partial history.
+ */
+export declare const ASTER_INCOME_MAX_PAGES = 60;
 export declare class AsterAdapter implements ExchangeAdapter {
     readonly name = "aster";
     readonly chain = "bnb";
@@ -207,8 +214,34 @@ export declare class AsterAdapter implements ExchangeAdapter {
      */
     invalidateOpenOrdersCache(): void;
     getOpenOrders(): Promise<ExchangeOrder[]>;
+    /**
+     * Every income row of `incomeType` in the last 7 days. The response order of GET /fapi/v3/income
+     * is not documented, so nothing assumes it: the window is read as disjoint [start, end] slices
+     * (startTime / endTime inclusive; one day each) and a slice that comes back full (1000 rows, the
+     * endpoint max) is split in half and re-read. More than ASTER_INCOME_MAX_PAGES requests, or a
+     * full slice of one millisecond → EXCHANGE_ERROR, never a partial list.
+     */
+    private _incomeRows;
+    /**
+     * Symbols with account activity: open positions, open orders, and every symbol with a
+     * COMMISSION income row in the last 7 days (see _incomeRows). Aster's userTrades / allOrders
+     * both require `symbol`, so this is the per-symbol fan-out set. Orders on a symbol that never
+     * filled, is not open and has no position cannot be found (allOrders needs it).
+     */
+    private _tradedApiSymbols;
+    /**
+     * Recent orders across the symbols with account activity (see _tradedApiSymbols), newest first.
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /**
+     * Recent fills. `GET /fapi/v3/userTrades` requires a symbol (asterdex/api-docs V3), so the
+     * symbols come from the open positions plus every symbol with a COMMISSION income row in the
+     * venue's default window (`GET /fapi/v3/income`: "the recent 7-day data" when no time is sent).
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    /** FUNDING_FEE income of the last 7 days (see _incomeRows), newest first, at most `limit` rows. */
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
     /**
      * Per-market leverage / margin mode: every row of GET /fapi/v3/positionRisk ("Position

package/dist/exchanges/aster.js

@@ -152,6 +152,13 @@ export function requireAsterClientOrderId(id) {
     return id;
 }
 // ── AsterAdapter ──────────────────────────────────────────────────────────────
+/**
+ * Max GET /fapi/v3/income requests for one 7-day read (7 daily slices + splits of full slices).
+ * The endpoint weighs 30 against Aster's 2400/min request weight, so 60 requests = 1800 — inside
+ * one minute's budget with room for the per-symbol fan-out. Enough for ~2000 fills/day; beyond
+ * that the read refuses (EXCHANGE_ERROR) rather than returning a partial history.
+ */
+export const ASTER_INCOME_MAX_PAGES = 60;
 export class AsterAdapter {
     name = "aster";
     chain = "bnb";
@@ -715,79 +722,179 @@ export class AsterAdapter {
         this._ordersCache = { data: result, time: Date.now(), epoch: accountCacheEpoch() };
         return result;
     }
-    async getOrderHistory(limit = 30) {
-        const positions = await this.getPositions();
-        const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
-        if (apiSymbols.size === 0) {
-            for (const s of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "XRPUSDT"]) {
-                apiSymbols.add(s);
+    /**
+     * Every income row of `incomeType` in the last 7 days. The response order of GET /fapi/v3/income
+     * is not documented, so nothing assumes it: the window is read as disjoint [start, end] slices
+     * (startTime / endTime inclusive; one day each) and a slice that comes back full (1000 rows, the
+     * endpoint max) is split in half and re-read. More than ASTER_INCOME_MAX_PAGES requests, or a
+     * full slice of one millisecond → EXCHANGE_ERROR, never a partial list.
+     */
+    async _incomeRows(incomeType, r) {
+        const end = Date.now();
+        const start = end - 7 * 86_400_000;
+        const slices = [];
+        for (let s = start; s < end; s += 86_400_000)
+            slices.push([s, Math.min(s + 86_400_000 - 1, end)]);
+        slices[slices.length - 1][1] = end; // last slice ends exactly at `end` (inclusive), no extra 1-ms request
+        const rows = [];
+        let requests = 0;
+        while (slices.length > 0) {
+            const [s, e] = slices.shift();
+            if (++requests > ASTER_INCOME_MAX_PAGES) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster ${incomeType} history needs more than ${ASTER_INCOME_MAX_PAGES} requests for 7 days — the result would be incomplete`, {
+                    exchange: "aster", remediation: "Check the history per symbol in the Aster web app",
+                });
+            }
+            const page = await this._signedGetEip712("/fapi/v3/income", { incomeType, startTime: String(s), endTime: String(e), limit: "1000" }, r);
+            if (!Array.isArray(page)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster income history is not a list (${JSON.stringify(page).slice(0, 120)})`, { exchange: "aster" });
+            }
+            if (page.length >= 1000) {
+                if (e <= s) {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster returned 1000+ ${incomeType} rows at one millisecond (${s}) — the list cannot be read completely`, {
+                        exchange: "aster", remediation: "Check the history per symbol in the Aster web app",
+                    });
+                }
+                const mid = Math.floor((s + e) / 2);
+                slices.unshift([s, mid], [mid + 1, e]);
+                continue;
+            }
+            for (const row of page) {
+                if (!Number.isFinite(Number(row.time))) {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster income row without a numeric time: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "aster" });
+                }
+                rows.push(row);
             }
         }
+        return rows;
+    }
+    /**
+     * Symbols with account activity: open positions, open orders, and every symbol with a
+     * COMMISSION income row in the last 7 days (see _incomeRows). Aster's userTrades / allOrders
+     * both require `symbol`, so this is the per-symbol fan-out set. Orders on a symbol that never
+     * filled, is not open and has no position cannot be found (allOrders needs it).
+     */
+    async _tradedApiSymbols(r) {
+        // Raw venue symbols (no _fromApi → _toApi round trip, which would invent a USDT suffix for a
+        // non-USDT market): open positions of GET /fapi/v3/accountWithJoinMargin.
+        const account = await this._signedGetEip712("/fapi/v3/accountWithJoinMargin", {}, r);
+        if (!Array.isArray(account?.positions)) {
+            throw new PerpError("EXCHANGE_ERROR", "Aster accountWithJoinMargin has no positions list", { exchange: "aster" });
+        }
+        const apiSymbols = new Set();
+        for (const p of account.positions) {
+            if (typeof p.symbol === "string" && p.symbol !== "" && parseFiniteVenueNumber(p.positionAmt, "position.positionAmt", "aster") !== 0)
+                apiSymbols.add(p.symbol);
+        }
+        const open = await this._signedGetEip712("/fapi/v3/openOrders", {}, r);
+        if (!Array.isArray(open)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster open orders is not a list (${JSON.stringify(open).slice(0, 120)})`, { exchange: "aster" });
+        }
+        for (const o of open) {
+            if (typeof o.symbol === "string" && o.symbol !== "")
+                apiSymbols.add(o.symbol);
+        }
+        for (const row of await this._incomeRows("COMMISSION", r)) {
+            if (typeof row.symbol === "string" && row.symbol !== "")
+                apiSymbols.add(row.symbol);
+        }
+        return apiSymbols;
+    }
+    /**
+     * Recent orders across the symbols with account activity (see _tradedApiSymbols), newest first.
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
+    async getOrderHistory(limit = 30) {
         const r = this._resolveSigner();
-        const allOrders = [];
+        const apiSymbols = await this._tradedApiSymbols(r);
+        const field = (o, k) => {
+            const v = o[k];
+            if ((typeof v === "string" && v !== "") || typeof v === "number")
+                return String(v);
+            throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row without a readable ${k}: ${JSON.stringify(o).slice(0, 160)}`, { exchange: "aster" });
+        };
+        const rows = [];
         for (const sym of apiSymbols) {
-            try {
-                const orders = await this._signedGetEip712("/fapi/v3/allOrders", {
-                    symbol: sym,
-                    limit: String(limit),
-                }, r);
-                for (const o of orders ?? []) {
-                    allOrders.push({
-                        orderId: String(o.orderId ?? ""),
-                        symbol: this._fromApi(String(o.symbol ?? "")),
-                        side: String(o.side).toLowerCase(),
-                        price: String(o.price ?? "0"),
-                        size: String(o.origQty ?? "0"),
-                        filled: String(o.executedQty ?? "0"),
-                        status: String(o.status ?? ""),
-                        type: String(o.type ?? ""),
-                        triggerPrice: Number(o.stopPrice) > 0 ? String(o.stopPrice) : null,
-                    });
+            const orders = await this._signedGetEip712("/fapi/v3/allOrders", { symbol: sym, limit: String(limit) }, r);
+            if (!Array.isArray(orders)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster allOrders for ${sym} is not a list (${JSON.stringify(orders).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const o of orders) {
+                const side = field(o, "side").toLowerCase();
+                if (side !== "buy" && side !== "sell") {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row with unknown side "${side}"`, { exchange: "aster" });
                 }
+                const time = Number(field(o, "time"));
+                if (!Number.isFinite(time))
+                    throw new PerpError("EXCHANGE_ERROR", `Aster allOrders row with a non-numeric time`, { exchange: "aster" });
+                rows.push({
+                    time,
+                    order: {
+                        orderId: field(o, "orderId"),
+                        symbol: this._fromApi(field(o, "symbol")),
+                        side,
+                        price: field(o, "price"),
+                        size: field(o, "origQty"),
+                        filled: field(o, "executedQty"),
+                        status: field(o, "status"),
+                        type: field(o, "type"),
+                        triggerPrice: Number(o.stopPrice) > 0 ? String(o.stopPrice) : null,
+                    },
+                });
             }
-            catch { /* skip */ }
         }
-        return allOrders.slice(0, limit);
+        return rows.sort((x, y) => y.time - x.time).slice(0, limit).map(x => x.order);
     }
+    /**
+     * Recent fills. `GET /fapi/v3/userTrades` requires a symbol (asterdex/api-docs V3), so the
+     * symbols come from the open positions plus every symbol with a COMMISSION income row in the
+     * venue's default window (`GET /fapi/v3/income`: "the recent 7-day data" when no time is sent).
+     * A failed read throws (never an empty list); a row without a readable field → EXCHANGE_ERROR.
+     */
     async getTradeHistory(limit = 30) {
-        const positions = await this.getPositions();
-        const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
-        if (apiSymbols.size === 0)
-            apiSymbols.add("BTCUSDT");
         const r = this._resolveSigner();
+        const apiSymbols = await this._tradedApiSymbols(r);
+        const field = (t, k) => {
+            const v = t[k];
+            if ((typeof v === "string" && v !== "") || typeof v === "number")
+                return String(v);
+            throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row without a readable ${k}: ${JSON.stringify(t).slice(0, 160)}`, { exchange: "aster" });
+        };
         const allTrades = [];
         for (const sym of apiSymbols) {
-            try {
-                const trades = await this._signedGetEip712("/fapi/v3/userTrades", {
-                    symbol: sym,
-                    limit: String(limit),
-                }, r);
-                for (const t of trades ?? []) {
-                    allTrades.push({
-                        time: Number(t.time ?? 0),
-                        symbol: this._fromApi(String(t.symbol ?? "")),
-                        side: t.buyer ? "buy" : "sell",
-                        price: String(t.price ?? "0"),
-                        size: String(t.qty ?? "0"),
-                        fee: String(t.commission ?? "0"),
-                    });
+            const trades = await this._signedGetEip712("/fapi/v3/userTrades", { symbol: sym, limit: String(limit) }, r);
+            if (!Array.isArray(trades)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster userTrades for ${sym} is not a list (${JSON.stringify(trades).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const t of trades) {
+                if (typeof t.buyer !== "boolean") {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row without a boolean buyer: ${JSON.stringify(t).slice(0, 160)}`, { exchange: "aster" });
                 }
+                const time = Number(field(t, "time"));
+                if (!Number.isFinite(time))
+                    throw new PerpError("EXCHANGE_ERROR", `Aster userTrades row with a non-numeric time`, { exchange: "aster" });
+                allTrades.push({
+                    time,
+                    symbol: this._fromApi(field(t, "symbol")),
+                    side: t.buyer ? "buy" : "sell",
+                    price: field(t, "price"),
+                    size: field(t, "qty"),
+                    fee: field(t, "commission"),
+                });
             }
-            catch { /* skip */ }
         }
         return allTrades.sort((a, b) => b.time - a.time).slice(0, limit);
     }
+    /** FUNDING_FEE income of the last 7 days (see _incomeRows), newest first, at most `limit` rows. */
     async getFundingPayments(limit = 200) {
-        const r = this._resolveSigner();
-        const data = await this._signedGetEip712("/fapi/v3/income", {
-            incomeType: "FUNDING_FEE",
-            limit: String(limit),
-        }, r);
-        return (data ?? []).map((f) => ({
-            time: Number(f.time ?? 0),
-            symbol: this._fromApi(String(f.symbol ?? "")),
-            payment: String(f.income ?? "0"),
-        }));
+        const rows = await this._incomeRows("FUNDING_FEE", this._resolveSigner());
+        return rows.map((f) => {
+            const time = Number(f.time);
+            if (typeof f.symbol !== "string" || f.symbol === "" || (typeof f.income !== "string" && typeof f.income !== "number") || f.income === "") {
+                throw new PerpError("EXCHANGE_ERROR", `Aster funding income row without symbol / income: ${JSON.stringify(f).slice(0, 160)}`, { exchange: "aster" });
+            }
+            return { time, symbol: this._fromApi(f.symbol), payment: String(f.income) };
+        }).sort((x, y) => y.time - x.time).slice(0, limit);
     }
     /**
      * Per-market leverage / margin mode: every row of GET /fapi/v3/positionRisk ("Position

package/dist/exchanges/hyperliquid.d.ts

@@ -496,9 +496,39 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
     }): Promise<unknown>;
     getRecentTrades(symbol: string, limit?: number): Promise<ExchangeTrade[]>;
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
+    /**
+     * Order history: POST /info {type:"historicalOrders"} ("Retrieve a user's historical orders",
+     * at most 2000 most recent; live 2026-10-13: newest first, each order listed once per status —
+     * e.g. "open" then "filled" — with equal statusTimestamp possible). One row per oid with its
+     * final status (latest statusTimestamp; on a tie a non-"open" status wins). Includes canceled /
+     * rejected orders (the previous userFills read showed fills only). Unreadable rows → EXCHANGE_ERROR.
+     * The info endpoint is account-wide; rows are scoped to this adapter (see _inHistoryScope).
+     */
     getOrderHistory(limit?: number): Promise<ExchangeOrder[]>;
+    /** Fills: POST /info {type:"userFills"} (at most 2000 most recent, newest first — live 2026-10-13). */
     getTradeHistory(limit?: number): Promise<ExchangeTrade[]>;
+    /**
+     * Funding payments in this adapter's scope (see _inHistoryScope), newest first, at most `limit`.
+     * Reads the last 24 h first and widens to 7 days only when that holds fewer than `limit` rows
+     * (POST /info userFunding weighs per row returned; bots poll it).
+     */
     getFundingPayments(limit?: number): Promise<ExchangeFundingPayment[]>;
+    /**
+     * Every userFunding row since `startTime`. The endpoint returns rows OLDEST first, at most 500
+     * per response (live 2026-10-13), and every coin of a funding hour shares one millisecond — so
+     * pages continue from the last row's time INCLUSIVE and rows are deduped by time + coin (funding
+     * rows carry a zero hash). A full page that adds nothing new, or more than HL_FUNDING_MAX_PAGES
+     * pages → EXCHANGE_ERROR (never a list with payments silently missing).
+     */
+    private _fundingSince;
+    /** The asset map backs _displaySymbol / _inHistoryScope; load it before mapping history rows. */
+    private _historyScopeReady;
+    /**
+     * Whether an account-wide history row (historicalOrders / userFills / userFunding carry every
+     * dex, spot "@n" / "PAIR/USDC" and outcome "#n" coins) belongs to this adapter: a HIP-3 dex
+     * adapter keeps "<dex>:…" coins, the native adapter keeps native perp coins only.
+     */
+    private _inHistoryScope;
     getFundingHistory(symbol: string, limit?: number): Promise<{
         time: number;
         rate: string;