perp-cli 0.14.1 → 0.14.3

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";
@@ -191,6 +196,11 @@ export declare class AsterAdapter implements ExchangeAdapter {
         rate: string;
         price: string | null;
     }[]>;
+    /**
+     * Candles over [startTime, endTime]. GET /fapi/v3/klines returns at most 1500 bars per request
+     * (1501 → -1130), so the range is read in pages that start after the last bar returned — a long
+     * range is never cut to the first page. More than ASTER_KLINE_MAX_PAGES pages → INVALID_PARAMS.
+     */
     getKlines(symbol: string, interval: string, startTime: number, endTime: number): Promise<ExchangeKline[]>;
     getBalance(): Promise<ExchangeBalance>;
     /**
@@ -209,13 +219,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 +246,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,17 @@ 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;
+/** GET /fapi/v3/klines maximum rows per request (docs: limit max 1500). */
+const ASTER_KLINE_PAGE = 1500;
+/** Page cap for one range (150 000 bars). */
+const ASTER_KLINE_MAX_PAGES = 100;
 export class AsterAdapter {
     name = "aster";
     chain = "bnb";
@@ -370,41 +379,54 @@ export class AsterAdapter {
             // math depends on.
             this._loadFundingInfo(),
         ]);
+        if (!Array.isArray(info?.symbols)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster exchangeInfo has no symbol list (${JSON.stringify(info).slice(0, 120)})`, { exchange: "aster" });
+        }
+        if (!Array.isArray(tickers)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster 24h ticker is not a list (${JSON.stringify(tickers).slice(0, 120)})`, { exchange: "aster" });
+        }
         const tickerMap = new Map();
-        for (const t of tickers ?? []) {
+        for (const t of tickers) {
             tickerMap.set(String(t.symbol), t);
         }
-        let premiumMap = new Map();
-        try {
-            const premiums = await this._publicGet("/fapi/v3/premiumIndex");
-            premiumMap = new Map(premiums.map(p => [String(p.symbol), p]));
-        }
-        catch { /* non-critical */ }
-        this._ingestPriceFilters(info?.symbols ?? []);
-        const tradingSymbols = (info?.symbols ?? [])
-            .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING");
-        const result = tradingSymbols.map((s) => {
+        // The mark price comes from premiumIndex only: a failed read throws (never a "0" / last-trade
+        // stand-in), and a symbol missing from it is left out of the list below.
+        const premiums = await this._publicGet("/fapi/v3/premiumIndex");
+        if (!Array.isArray(premiums)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster premiumIndex is not a list (${JSON.stringify(premiums).slice(0, 120)})`, { exchange: "aster" });
+        }
+        const premiumMap = new Map(premiums.map(p => [String(p.symbol), p]));
+        this._ingestPriceFilters(info.symbols);
+        // USDT-quoted perps only: the CLI symbol mapping (ETH ↔ ETHUSDT) cannot address the USD1 / U
+        // quoted markets (live 2026-10-13: 22 USD1 + 2 U), so listing them would offer untradeable rows.
+        const tradingSymbols = info.symbols
+            .filter((s) => String(s.contractType) === "PERPETUAL" && String(s.status) === "TRADING" && String(s.quoteAsset) === "USDT");
+        const result = tradingSymbols.flatMap((s) => {
             const sym = String(s.symbol);
             const ticker = tickerMap.get(sym);
             const premium = premiumMap.get(sym);
-            const maxLev = Number(s.maxLeverage ?? 50);
+            const mark = Number(premium?.markPrice);
+            if (premium === undefined || !(mark > 0))
+                return []; // no published mark price → not listed at 0
+            // Public exchangeInfo carries no leverage (the bracket endpoint is signed) → unknown.
+            const maxLev = null;
             const lotFilter = s.filters
                 ?.find(f => f.filterType === "LOT_SIZE");
             const fundingHours = this._fundingHoursCache.get(this._fromApi(sym));
-            return {
-                symbol: this._fromApi(sym),
-                markPrice: String(premium?.markPrice ?? ticker?.lastPrice ?? "0"),
-                indexPrice: premium?.indexPrice != null ? String(premium.indexPrice) : null,
-                fundingRate: premium?.lastFundingRate != null ? String(premium.lastFundingRate) : null,
-                volume24h: ticker?.quoteVolume != null ? String(ticker.quoteVolume) : null,
-                // /fapi/v3/exchangeInfo and ticker/24hr carry no open interest.
-                openInterest: null,
-                maxLeverage: maxLev,
-                sizeDecimals: s.quantityPrecision != null ? Number(s.quantityPrecision) : null,
-                stepSize: lotFilter?.stepSize != null ? String(lotFilter.stepSize) : null,
-                fundingHours: fundingHours ?? null,
-                marginTiers: null,
-            };
+            return [{
+                    symbol: this._fromApi(sym),
+                    markPrice: String(premium.markPrice),
+                    indexPrice: premium?.indexPrice != null ? String(premium.indexPrice) : null,
+                    fundingRate: premium?.lastFundingRate != null ? String(premium.lastFundingRate) : null,
+                    volume24h: ticker?.quoteVolume != null ? String(ticker.quoteVolume) : null,
+                    // /fapi/v3/exchangeInfo and ticker/24hr carry no open interest.
+                    openInterest: null,
+                    maxLeverage: maxLev,
+                    sizeDecimals: s.quantityPrecision != null ? Number(s.quantityPrecision) : null,
+                    stepSize: lotFilter?.stepSize != null ? String(lotFilter.stepSize) : null,
+                    fundingHours: fundingHours ?? null,
+                    marginTiers: null,
+                }];
         });
         this._marketsCache = result;
         this._marketsCacheTime = Date.now();
@@ -541,29 +563,64 @@ export class AsterAdapter {
             symbol: this._toApi(symbol),
             limit: String(limit),
         });
-        return (data ?? []).map((d) => ({
-            time: Number(d.fundingTime ?? 0),
-            rate: venueRateField(d.fundingRate, "fundingRate fundingRate", "aster"),
-            price: d.markPrice ? String(d.markPrice) : null,
-        }));
+        if (!Array.isArray(data)) {
+            throw new PerpError("EXCHANGE_ERROR", `Aster fundingRate history is not a list (${JSON.stringify(data).slice(0, 120)})`, { exchange: "aster" });
+        }
+        return data.map((d) => {
+            const time = Number(d.fundingTime);
+            if (d.fundingTime === undefined || d.fundingTime === null || !Number.isFinite(time) || time <= 0) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster fundingRate row without a numeric fundingTime: ${JSON.stringify(d).slice(0, 160)}`, { exchange: "aster" });
+            }
+            return {
+                time,
+                rate: venueRateField(d.fundingRate, "fundingRate fundingRate", "aster"),
+                price: d.markPrice ? String(d.markPrice) : null,
+            };
+        });
     }
+    /**
+     * Candles over [startTime, endTime]. GET /fapi/v3/klines returns at most 1500 bars per request
+     * (1501 → -1130), so the range is read in pages that start after the last bar returned — a long
+     * range is never cut to the first page. More than ASTER_KLINE_MAX_PAGES pages → INVALID_PARAMS.
+     */
     async getKlines(symbol, interval, startTime, endTime) {
-        const data = await this._publicGet("/fapi/v3/klines", {
-            symbol: this._toApi(symbol),
-            interval,
-            startTime: String(startTime),
-            endTime: String(endTime),
-            limit: "500",
-        });
-        return (data ?? []).map((k) => ({
-            time: Number(k[0]),
-            open: String(k[1]),
-            high: String(k[2]),
-            low: String(k[3]),
-            close: String(k[4]),
-            volume: String(k[5]),
-            trades: Number(k[8] ?? 0),
-        }));
+        if (!(startTime <= endTime)) {
+            throw new PerpError("INVALID_PARAMS", `Aster klines: start ${startTime} is after end ${endTime}`, {
+                remediation: "Pass a --start that is before --end",
+            });
+        }
+        const out = [];
+        let from = startTime;
+        for (let page = 0; from <= endTime; page++) {
+            if (page >= ASTER_KLINE_MAX_PAGES) {
+                throw new PerpError("INVALID_PARAMS", `Aster: ${interval} candles over this range need more than ${ASTER_KLINE_MAX_PAGES} requests`, {
+                    remediation: "Narrow --start / --end or use a longer interval",
+                });
+            }
+            const data = await this._publicGet("/fapi/v3/klines", {
+                symbol: this._toApi(symbol), interval,
+                startTime: String(from), endTime: String(endTime), limit: String(ASTER_KLINE_PAGE),
+            });
+            if (!Array.isArray(data)) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster klines is not a list (${JSON.stringify(data).slice(0, 120)})`, { exchange: "aster" });
+            }
+            for (const k of data) {
+                const time = Number(k[0]);
+                const trades = Number(k[8]);
+                if (!Number.isFinite(time) || !Number.isFinite(trades)) {
+                    throw new PerpError("EXCHANGE_ERROR", `Aster kline row without open time / trade count: ${JSON.stringify(k).slice(0, 120)}`, { exchange: "aster" });
+                }
+                out.push({ time, open: String(k[1]), high: String(k[2]), low: String(k[3]), close: String(k[4]), volume: String(k[5]), trades });
+            }
+            if (data.length < ASTER_KLINE_PAGE)
+                break;
+            const next = Number(data[data.length - 1][0]) + 1;
+            if (next <= from) {
+                throw new PerpError("EXCHANGE_ERROR", `Aster klines page did not advance past ${from}`, { exchange: "aster" });
+            }
+            from = next;
+        }
+        return out;
     }
     // ── Account ──
     async getBalance() {
@@ -717,17 +774,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 +846,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 +937,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;
@@ -635,10 +665,6 @@ export declare class HyperliquidAdapter implements ExchangeAdapter {
      * adapter creation. Throws on a venue rejection (SSOT Rule #2).
      */
     setReferrer(code: string): Promise<unknown>;
-    /**
-     * Get funding history for a symbol.
-     */
-    getFundingHistoryRaw(symbol: string, startTime: number, endTime?: number): Promise<any>;
     /**
      * Get user trade fills.
      */