perp-cli 0.14.1 → 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,8 +61,13 @@ type ResolvedSigner = {
     /** EVM address of the owner/master — used as `user` field in Aster requests */
     userAddress: string;
 };
-/** Max 1000-row pages of 7-day commission income read for symbol discovery (20 000 fills). */
-export declare const ASTER_INCOME_MAX_PAGES = 20;
+/**
+ * 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";
@@ -209,13 +214,19 @@ 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 (the venue's default window). Aster's userTrades /
-     * allOrders both require `symbol`, so this is the per-symbol fan-out set. Income is read in
-     * pages of 1000 (the endpoint max; startTime / endTime are inclusive) walking back from now;
-     * more than ASTER_INCOME_MAX_PAGES pages → EXCHANGE_ERROR, never a partial set. Orders on a
-     * symbol that never filled, is not open and has no position cannot be found (allOrders needs it).
+     * 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;
     /**
@@ -230,6 +241,7 @@ export declare class AsterAdapter implements ExchangeAdapter {
      * 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,8 +152,13 @@ export function requireAsterClientOrderId(id) {
     return id;
 }
 // ── AsterAdapter ──────────────────────────────────────────────────────────────
-/** Max 1000-row pages of 7-day commission income read for symbol discovery (20 000 fills). */
-export const ASTER_INCOME_MAX_PAGES = 20;
+/**
+ * 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";
@@ -717,17 +722,70 @@ export class AsterAdapter {
         this._ordersCache = { data: result, time: Date.now(), epoch: accountCacheEpoch() };
         return result;
     }
+    /**
+     * 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 (the venue's default window). Aster's userTrades /
-     * allOrders both require `symbol`, so this is the per-symbol fan-out set. Income is read in
-     * pages of 1000 (the endpoint max; startTime / endTime are inclusive) walking back from now;
-     * more than ASTER_INCOME_MAX_PAGES pages → EXCHANGE_ERROR, never a partial set. Orders on a
-     * symbol that never filled, is not open and has no position cannot be found (allOrders needs it).
+     * 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) {
-        const positions = await this.getPositions();
-        const apiSymbols = new Set(positions.map(p => this._toApi(p.symbol)));
+        // 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" });
@@ -736,33 +794,9 @@ export class AsterAdapter {
             if (typeof o.symbol === "string" && o.symbol !== "")
                 apiSymbols.add(o.symbol);
         }
-        const startTime = Date.now() - 7 * 86_400_000;
-        let endTime = Date.now();
-        for (let page = 0;; page++) {
-            if (page >= ASTER_INCOME_MAX_PAGES) {
-                throw new PerpError("EXCHANGE_ERROR", `Aster commission history exceeds ${ASTER_INCOME_MAX_PAGES * 1000} rows in 7 days — the symbol list would be incomplete`, {
-                    exchange: "aster", remediation: "Check fills per symbol in the Aster web app",
-                });
-            }
-            const income = await this._signedGetEip712("/fapi/v3/income", {
-                incomeType: "COMMISSION", startTime: String(startTime), endTime: String(endTime), limit: "1000",
-            }, r);
-            if (!Array.isArray(income)) {
-                throw new PerpError("EXCHANGE_ERROR", `Aster income history is not a list (${JSON.stringify(income).slice(0, 120)})`, { exchange: "aster" });
-            }
-            let oldest = Infinity;
-            for (const row of income) {
-                if (typeof row.symbol === "string" && row.symbol !== "")
-                    apiSymbols.add(row.symbol);
-                const t = Number(row.time);
-                if (!Number.isFinite(t)) {
-                    throw new PerpError("EXCHANGE_ERROR", `Aster income row without a numeric time: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "aster" });
-                }
-                oldest = Math.min(oldest, t);
-            }
-            if (income.length < 1000 || oldest <= startTime)
-                break;
-            endTime = oldest - 1;
+        for (const row of await this._incomeRows("COMMISSION", r)) {
+            if (typeof row.symbol === "string" && row.symbol !== "")
+                apiSymbols.add(row.symbol);
         }
         return apiSymbols;
     }
@@ -851,17 +885,16 @@ export class AsterAdapter {
         }
         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;

package/dist/exchanges/hyperliquid.js

@@ -1,7 +1,7 @@
 import { LocalEvmSigner } from "../signer/index.js";
 import { DEFINITE_ORDER_FAILURE_CODES, PerpError, classifyError, extractErrorMessage, orderNotSent, orderOutcomeUnknown, sendFailure } from "../errors.js";
 import { parseFiniteVenueNumber, venueRateField } from "../utils/numeric.js";
-import { alignProtectionPrice, floorSize, formatComputedPrice, slippagePrice } from "./precision.js";
+import { alignProtectionPrice, floorSize, formatComputedPrice, slippagePrice, subDecimal } from "./precision.js";
 import { unsupported } from "./trading-v2.js";
 import { buildHlUserSignedAction, hlUserSignedNonceField, signHlL1Action, signHlUserSignedAction } from "./hl-signing.js";
 import { HL_CLOID_RE } from "./venues/hyperliquid.js";
@@ -339,6 +339,29 @@ export function hlL1ActionRejection(type, e) {
         remediation: "The venue refused the whole request and executed nothing; fix the cause named in the venue message above before sending it again",
     });
 }
+/** POST /info userFunding page size (docs: at most 500 rows per response). */
+const HL_FUNDING_PAGE = 500;
+/** 7 days of hourly funding = 168 rows per coin; 20 pages = 10 000 rows (~60 coins). */
+const HL_FUNDING_MAX_PAGES = 20;
+/** A required field of an HL info row as a string; missing / empty → EXCHANGE_ERROR. */
+function hlField(row, key, endpoint) {
+    const v = row[key];
+    if ((typeof v === "string" && v !== "") || (typeof v === "number" && Number.isFinite(v)))
+        return String(v);
+    throw new PerpError("EXCHANGE_ERROR", `Hyperliquid ${endpoint} row without a readable ${key}: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "hyperliquid" });
+}
+/** historicalOrders status precedence on equal statusTimestamp: open < triggered < any terminal status. */
+function hlStatusRank(status) {
+    return status === "open" ? 0 : status === "triggered" ? 1 : 2;
+}
+/** HL side "B" (bid) → buy, "A" (ask) → sell; anything else → EXCHANGE_ERROR. */
+function hlSide(v, endpoint) {
+    if (v === "B")
+        return "buy";
+    if (v === "A")
+        return "sell";
+    throw new PerpError("EXCHANGE_ERROR", `Hyperliquid ${endpoint} row with unknown side ${JSON.stringify(v)}`, { exchange: "hyperliquid" });
+}
 export class HyperliquidAdapter {
     name = "hyperliquid";
     chain = "evm";
@@ -1774,48 +1797,150 @@ export class HyperliquidAdapter {
             trades: Number(c.n ?? 0),
         }));
     }
+    /**
+     * 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).
+     */
     async getOrderHistory(limit = 30) {
         this.ensureAddress();
-        const fills = await this._infoPost({ type: "userFills", user: this._address });
-        return (fills ?? []).slice(0, limit).map((f) => ({
-            orderId: String(f.oid ?? ""),
-            symbol: this._displaySymbol(String(f.coin ?? "")),
-            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : String(f.side).toLowerCase(),
-            price: String(f.px ?? "0"),
-            size: String(f.sz ?? ""),
-            filled: String(f.sz ?? ""),
-            status: "filled",
-            type: String(f.dir ?? ""),
-            triggerPrice: null, // fills carry no trigger price
-        }));
+        const rows = await this._infoPost({ type: "historicalOrders", user: this._address });
+        if (!Array.isArray(rows)) {
+            throw new PerpError("EXCHANGE_ERROR", `Hyperliquid historicalOrders returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "hyperliquid" });
+        }
+        await this._historyScopeReady();
+        const latest = new Map();
+        for (const row of rows) {
+            const o = row.order;
+            const at = Number(row.statusTimestamp);
+            if (o === undefined || o === null || typeof row.status !== "string" || !Number.isFinite(at) || (typeof o.oid !== "number" && typeof o.oid !== "string")) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid historicalOrders row without order / oid / status / statusTimestamp: ${JSON.stringify(row).slice(0, 160)}`, { exchange: "hyperliquid" });
+            }
+            if (!this._inHistoryScope(hlField(o, "coin", "historicalOrders")))
+                continue;
+            const key = String(o.oid);
+            const prev = latest.get(key);
+            if (prev === undefined || at > prev.at || (at === prev.at && hlStatusRank(row.status) > hlStatusRank(prev.status))) {
+                latest.set(key, { at, status: row.status, o });
+            }
+        }
+        return [...latest.values()].sort((x, y) => y.at - x.at).slice(0, limit).map(({ status, o }) => {
+            const origSz = hlField(o, "origSz", "historicalOrders");
+            const remaining = hlField(o, "sz", "historicalOrders");
+            const triggerPx = Number(o.triggerPx);
+            return {
+                orderId: String(o.oid),
+                symbol: this._displaySymbol(hlField(o, "coin", "historicalOrders")),
+                side: hlSide(o.side, "historicalOrders"),
+                price: hlField(o, "limitPx", "historicalOrders"),
+                size: origSz,
+                filled: subDecimal(origSz, remaining),
+                status,
+                type: hlField(o, "orderType", "historicalOrders"),
+                triggerPrice: o.isTrigger === true && Number.isFinite(triggerPx) && triggerPx > 0 ? String(o.triggerPx) : null,
+            };
+        });
     }
+    /** Fills: POST /info {type:"userFills"} (at most 2000 most recent, newest first — live 2026-10-13). */
     async getTradeHistory(limit = 30) {
         this.ensureAddress();
         const fills = await this._infoPost({ type: "userFills", user: this._address });
-        return (fills ?? []).slice(0, limit).map((f) => ({
-            time: Number(f.time ?? 0),
-            symbol: this._displaySymbol(String(f.coin ?? "")),
-            side: String(f.side) === "B" ? "buy" : String(f.side) === "A" ? "sell" : String(f.side).toLowerCase(),
-            price: String(f.px ?? "0"),
-            size: String(f.sz ?? ""),
-            fee: String(f.fee ?? "0"),
-        }));
+        if (!Array.isArray(fills)) {
+            throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFills returned no list (${JSON.stringify(fills).slice(0, 120)})`, { exchange: "hyperliquid" });
+        }
+        await this._historyScopeReady();
+        return fills.filter((f) => this._inHistoryScope(hlField(f, "coin", "userFills"))).slice(0, limit).map((f) => {
+            const time = Number(hlField(f, "time", "userFills"));
+            if (!Number.isFinite(time))
+                throw new PerpError("EXCHANGE_ERROR", "Hyperliquid userFills row with a non-numeric time", { exchange: "hyperliquid" });
+            return {
+                time,
+                symbol: this._displaySymbol(hlField(f, "coin", "userFills")),
+                side: hlSide(f.side, "userFills"),
+                price: hlField(f, "px", "userFills"),
+                size: hlField(f, "sz", "userFills"),
+                fee: hlField(f, "fee", "userFills"),
+            };
+        });
     }
+    /**
+     * 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).
+     */
     async getFundingPayments(limit = 200) {
         this.ensureAddress();
-        // Direct API call — SDK's getUserFunding silently truncates results
-        const apiUrl = this._testnet ? "https://api.hyperliquid-testnet.xyz/info" : "https://api.hyperliquid.xyz/info";
-        const res = await fetch(apiUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ type: "userFunding", user: this._address, startTime: Date.now() - 7 * 24 * 60 * 60 * 1000 }),
-        });
-        const data = await res.json();
-        return (data ?? []).slice(0, limit).map((h) => ({
-            time: h.time,
-            symbol: h.delta.coin + "-PERP",
-            payment: h.delta.usdc,
-        }));
+        await this._historyScopeReady();
+        const now = Date.now();
+        let rows = await this._fundingSince(now - 24 * 60 * 60 * 1000);
+        if (rows.length < limit)
+            rows = await this._fundingSince(now - 7 * 24 * 60 * 60 * 1000);
+        return rows.sort((a, b) => b.time - a.time).slice(0, limit);
+    }
+    /**
+     * 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).
+     */
+    async _fundingSince(startTime) {
+        const out = [];
+        const seen = new Set();
+        let from = startTime;
+        for (let page = 0;; page++) {
+            if (page >= HL_FUNDING_MAX_PAGES) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid funding history needs more than ${HL_FUNDING_MAX_PAGES} pages — the result would be incomplete`, { exchange: "hyperliquid" });
+            }
+            const rows = await this._infoPost({ type: "userFunding", user: this._address, startTime: from });
+            if (!Array.isArray(rows)) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFunding returned no list (${JSON.stringify(rows).slice(0, 120)})`, { exchange: "hyperliquid" });
+            }
+            let last = -Infinity;
+            let fresh = 0;
+            for (const h of rows) {
+                const time = Number(h.time);
+                const delta = h.delta;
+                if (!Number.isFinite(time) || delta === undefined || delta === null || typeof delta.coin !== "string" || delta.coin === "" || typeof delta.usdc !== "string" || delta.usdc === "") {
+                    throw new PerpError("EXCHANGE_ERROR", `Hyperliquid userFunding row without time / delta.coin / delta.usdc: ${JSON.stringify(h).slice(0, 160)}`, { exchange: "hyperliquid" });
+                }
+                last = Math.max(last, time);
+                const key = `${time}|${delta.coin}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                fresh++;
+                if (this._inHistoryScope(delta.coin))
+                    out.push({ time, symbol: this._displaySymbol(delta.coin), payment: delta.usdc });
+            }
+            if (rows.length < HL_FUNDING_PAGE)
+                break;
+            if (fresh === 0) {
+                throw new PerpError("EXCHANGE_ERROR", `Hyperliquid returned ${HL_FUNDING_PAGE}+ funding rows at one millisecond (${last}) — paging cannot advance`, { exchange: "hyperliquid" });
+            }
+            from = last;
+        }
+        return out;
+    }
+    /** The asset map backs _displaySymbol / _inHistoryScope; load it before mapping history rows. */
+    async _historyScopeReady() {
+        if (this._assetMap.size === 0)
+            await this._loadAssetMap();
+        if (this._assetMapError)
+            throw this._assetMapError;
+    }
+    /**
+     * 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.
+     */
+    _inHistoryScope(coin) {
+        if (this._dex)
+            return coin.startsWith(`${this._dex}:`);
+        return !/[:@#/]/.test(coin);
     }
     async getFundingHistory(symbol, limit = 10) {
         const now = Date.now();

package/dist/exchanges/lighter.d.ts

@@ -154,7 +154,7 @@ export declare function lighterTakerFilledBase(eventInfo: unknown, sentBaseAmoun
  * A required open-order row field as a string (Rule #2): missing / empty / non-finite numeric →
  * EXCHANGE_ERROR, never listed as price / size "0" or status "open".
  */
-export declare function lighterRowField(o: Record<string, unknown>, key: string, venue: string): string;
+export declare function lighterRowField(o: Record<string, unknown>, key: string, venue: string, what?: "open order" | "order history"): string;
 /** What identifies OUR accountOrders row besides the client order index: the market sent to and the send time. */
 export interface LighterRowMatch {
     marketIndex: number;