perp-cli 0.15.0 → 0.16.0

package/dist/exchanges/extended/adapter.js

@@ -30,9 +30,23 @@ export const EXTENDED_KLINE_INTERVALS = {
     "12h": { wire: "PT12H", ms: 43_200_000 },
     "1d": { wire: "PT24H", ms: 86_400_000 },
     "1w": { wire: "P7D", ms: 604_800_000 },
+    // P30D answers calendar-month candles (live 2026-10-19: opens on the 1st, 00:00 UTC); ms is
+    // the nominal 30 d used only to size requests.
+    "1M": { wire: "P30D", ms: 2_592_000_000 },
 };
-/** Documented per-request maximum of the candles and funding-history endpoints. */
+/** Documented per-request maximum of the candles and funding-history endpoints (accepted `limit`). */
 export const EXTENDED_MAX_RECORDS = 10_000;
+/**
+ * Real server caps, measured live 2026-10-19 (BTC-USD; no pagination field, no error): candles
+ * return at most 2800 rows on every interval with that much history (PT1M … PT4H: 2800; PT8H 2445,
+ * PT12H 1631, PT24H 816, P7D 118, P30D 28 = the whole history since 2024-07), funding history at
+ * most 1000 (the newest). Both page backwards with `endTime` = before the oldest row and stop only
+ * on an empty page or at the window start — a short page is never taken as the end.
+ */
+export const EXTENDED_CANDLES_PAGE_CAP = 2800;
+export const EXTENDED_FUNDING_PAGE_CAP = 1000;
+const EXTENDED_MAX_PAGES = 50;
+export const EXTENDED_TRADES_CAP = 50;
 const DEC = /^-?\d+(\.\d+)?$/;
 function dec(v, what) {
     if (typeof v !== "string" || !DEC.test(v))
@@ -92,6 +106,10 @@ export class ExtendedPublicAdapter {
         return { bids: side(data.bid, "orderbook bid"), asks: side(data.ask, "orderbook ask") };
     }
     async getRecentTrades(symbol, limit = 50) {
+        // The endpoint takes no limit and answers the last 50 trades (live 2026-10-19, `limit=500` → 50).
+        if (!Number.isInteger(limit) || limit < 1 || limit > EXTENDED_TRADES_CAP) {
+            throw new PerpError("INVALID_PARAMS", `Extended: trades limit must be 1..${EXTENDED_TRADES_CAP} (got ${limit})`, { remediation: `Extended publishes only the last ${EXTENDED_TRADES_CAP} trades` });
+        }
         const m = await this.market(symbol);
         const body = await this.client.get(`/info/markets/${encodeURIComponent(m.name)}/trades`);
         if (!Array.isArray(body.data))
@@ -106,7 +124,10 @@ export class ExtendedPublicAdapter {
         // Newest first, like every other venue's tape.
         return trades.sort((a, b) => b.time - a.time).slice(0, limit);
     }
-    /** Applied (settled) hourly rates, newest first — fraction per hour; no oracle price published. */
+    /**
+     * Applied (settled) hourly rates, newest first — fraction per hour; no oracle price published.
+     * Paged backwards in pages of EXTENDED_FUNDING_PAGE_CAP until `limit` rows or the window start.
+     */
     async getFundingHistory(symbol, limit = 10) {
         if (!Number.isInteger(limit) || limit < 1 || limit > EXTENDED_MAX_RECORDS) {
             throw new PerpError("INVALID_PARAMS", `Extended: funding history limit must be 1..${EXTENDED_MAX_RECORDS} (got ${limit})`);
@@ -115,20 +136,37 @@ export class ExtendedPublicAdapter {
         const end = Date.now();
         // One record per hour; two spare hours cover the in-progress hour and clock skew.
         const start = end - (limit + 2) * 3_600_000;
-        const body = await this.client.get(`/info/${encodeURIComponent(m.name)}/funding`, [
-            ["startTime", String(start)], ["endTime", String(end)], ["limit", String(limit)],
-        ]);
-        if (!Array.isArray(body.data))
-            throw extendedShapeError(`funding history of ${m.name} is not a list`);
-        return body.data
-            .map(r => {
-            const x = r;
-            const rate = dec(x.f, "funding f");
-            return { time: ms(x.T, "funding T"), rate, price: null, rateKind: "lastSettled", intervalHours: 1, annualizedPct: annualizeHourlyRate(Number(rate)) };
-        })
-            .sort((a, b) => b.time - a.time)
-            .slice(0, limit);
+        const byTime = new Map();
+        let cursor = end;
+        for (let page = 0; byTime.size < limit; page++) {
+            if (page >= EXTENDED_MAX_PAGES)
+                throw new PerpError("EXCHANGE_ERROR", `Extended: funding history of ${m.name} did not end after ${EXTENDED_MAX_PAGES} pages`);
+            const want = Math.min(EXTENDED_FUNDING_PAGE_CAP, limit - byTime.size);
+            const body = await this.client.get(`/info/${encodeURIComponent(m.name)}/funding`, [
+                ["startTime", String(start)], ["endTime", String(cursor)], ["limit", String(want)],
+            ]);
+            if (!Array.isArray(body.data))
+                throw extendedShapeError(`funding history of ${m.name} is not a list`);
+            const rows = body.data.map(r => {
+                const x = r;
+                const rate = dec(x.f, "funding f");
+                return { time: ms(x.T, "funding T"), rate, price: null, rateKind: "lastSettled", intervalHours: 1, annualizedPct: annualizeHourlyRate(Number(rate)) };
+            });
+            for (const r of rows)
+                byTime.set(r.time, r);
+            // Only an empty page ends the window (a short page is not trusted as the end).
+            if (rows.length === 0)
+                break;
+            const oldest = Math.min(...rows.map(r => r.time));
+            if (oldest <= start)
+                break;
+            if (oldest >= cursor)
+                throw extendedShapeError(`funding history of ${m.name} did not move back past ${new Date(cursor).toISOString()}`);
+            cursor = oldest - 1;
+        }
+        return [...byTime.values()].sort((a, b) => b.time - a.time).slice(0, limit);
     }
+    /** Candles paged backwards from `endTime` in pages of EXTENDED_CANDLES_PAGE_CAP (newest first on the wire). */
     async getKlines(symbol, interval, startTime, endTime) {
         const iv = Object.prototype.hasOwnProperty.call(EXTENDED_KLINE_INTERVALS, interval) ? EXTENDED_KLINE_INTERVALS[interval] : undefined;
         if (iv === undefined) {
@@ -138,26 +176,50 @@ export class ExtendedPublicAdapter {
         }
         if (!(endTime > startTime))
             throw new PerpError("INVALID_PARAMS", "Extended: candle end time must be after the start time");
+        const bars = Math.ceil((endTime - startTime) / iv.ms) + 1;
+        const pages = Math.ceil(bars / EXTENDED_CANDLES_PAGE_CAP);
+        if (pages > EXTENDED_MAX_PAGES) {
+            throw new PerpError("INVALID_PARAMS", `Extended: ${interval} candles over this range need ${pages} requests (max ${EXTENDED_MAX_PAGES})`, {
+                remediation: "Narrow --start / --end or use a longer interval",
+            });
+        }
         const m = await this.market(symbol);
-        const limit = Math.min(EXTENDED_MAX_RECORDS, Math.ceil((endTime - startTime) / iv.ms) + 1);
-        const body = await this.client.get(`/info/candles/${encodeURIComponent(m.name)}/trades`, [
-            ["interval", iv.wire], ["limit", String(limit)], ["endTime", String(endTime)],
-        ]);
-        if (!Array.isArray(body.data))
-            throw extendedShapeError(`candles of ${m.name} is not a list`);
-        return body.data
-            .map(c => {
-            const x = c;
-            return {
-                time: ms(x.T, "candle T"),
-                open: dec(x.o, "candle o"), high: dec(x.h, "candle h"), low: dec(x.l, "candle l"), close: dec(x.c, "candle c"),
-                volume: dec(x.v, "candle v"),
-                quoteVolume: null,
-                trades: null,
-            };
-        })
-            .filter(k => k.time >= startTime && k.time <= endTime)
-            .sort((a, b) => a.time - b.time);
+        const byTime = new Map();
+        // `endTime` is exclusive on the wire (a bar opening exactly at it is not returned): +1 ms makes
+        // `--end` inclusive like every other venue.
+        let cursor = endTime + 1;
+        for (let page = 0; page < EXTENDED_MAX_PAGES + 1; page++) {
+            const want = Math.min(EXTENDED_CANDLES_PAGE_CAP, Math.ceil((cursor - startTime) / iv.ms) + 1);
+            const body = await this.client.get(`/info/candles/${encodeURIComponent(m.name)}/trades`, [
+                ["interval", iv.wire], ["limit", String(want)], ["endTime", String(cursor)],
+            ]);
+            if (!Array.isArray(body.data))
+                throw extendedShapeError(`candles of ${m.name} is not a list`);
+            const rows = body.data.map(c => {
+                const x = c;
+                return {
+                    time: ms(x.T, "candle T"),
+                    open: dec(x.o, "candle o"), high: dec(x.h, "candle h"), low: dec(x.l, "candle l"), close: dec(x.c, "candle c"),
+                    volume: dec(x.v, "candle v"),
+                    quoteVolume: null,
+                    trades: null,
+                };
+            });
+            for (const k of rows)
+                if (k.time >= startTime && k.time <= endTime)
+                    byTime.set(k.time, k);
+            // Only an EMPTY page ends the history: a short page is not trusted as the end (the cap is
+            // per interval and was measured, not documented), it just costs one more request.
+            if (rows.length === 0)
+                break;
+            const oldest = Math.min(...rows.map(k => k.time));
+            if (oldest <= startTime)
+                break;
+            if (oldest >= cursor)
+                throw extendedShapeError(`candles of ${m.name} did not move back past ${new Date(cursor).toISOString()}`);
+            cursor = oldest - 1;
+        }
+        return [...byTime.values()].sort((a, b) => a.time - b.time);
     }
     // ── Account / trading: refused (market data only in this version) ──
     refuse(feature) {

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

@@ -42,6 +42,9 @@
  *  - marketStats.nextFundingRate is (despite its name) the timestamp (ms) of the next application.
  *  - rates are published ROUNDED TO 6 DECIMALS (resolution 0.000001 / h ≈ 0.876 % APR): the
  *    0.0000125 baseline reads "0.000013", and a rate below 0.0000005 / h reads "0.000000".
+ *    There is no more precise public source (checked live 2026-10-19): /info/markets (407
+ *    markets), /info/markets/<m>/stats and the applied history /info/<m>/funding (`f`, 48 h of
+ *    ETH / SOL) all carry at most 6 decimals, so the adapter keeps this one read.
  *  - `_24_5` RWA equities print 0 while their underlying is closed (TSLA_24_5-USD: 34 of 43
  *    weekend prints were 0), so an hourly rate × 8760 overstates them — the venue is
  *    fundingVerified false (venues/extended.ts).

package/dist/exchanges/extended/public.js

@@ -42,6 +42,9 @@
  *  - marketStats.nextFundingRate is (despite its name) the timestamp (ms) of the next application.
  *  - rates are published ROUNDED TO 6 DECIMALS (resolution 0.000001 / h ≈ 0.876 % APR): the
  *    0.0000125 baseline reads "0.000013", and a rate below 0.0000005 / h reads "0.000000".
+ *    There is no more precise public source (checked live 2026-10-19): /info/markets (407
+ *    markets), /info/markets/<m>/stats and the applied history /info/<m>/funding (`f`, 48 h of
+ *    ETH / SOL) all carry at most 6 decimals, so the adapter keeps this one read.
  *  - `_24_5` RWA equities print 0 while their underlying is closed (TSLA_24_5-USD: 34 of 43
  *    weekend prints were 0), so an hourly rate × 8760 overstates them — the venue is
  *    fundingVerified false (venues/extended.ts).
@@ -301,7 +304,7 @@ export async function fetchExtendedMarketRows(client, deps = DEFAULT_DEPS) {
     return parseExtendedMarkets(body.data, deps.warn);
 }
 export async function fetchExtendedMarkets(net, deps = DEFAULT_DEPS) {
-    return (await fetchExtendedMarketRows(extendedClient(net), deps)).map(r => r.market);
+    return (await fetchExtendedMarketRows(extendedClient(net), deps)).map(r => ({ ...r.market, status: r.meta.status }));
 }
 /** Funding rows: the current hour's accruing rate (fraction per hour); a market without one has no row. */
 export function toExtendedFundingRates(rows) {
@@ -418,7 +421,11 @@ export async function resolveExtendedMarketRemote(client, input, deps = DEFAULT_
         names = symbols.flatMap(extendedWireCandidates);
     }
     else {
-        names = extendedWireCandidates(up);
+        // Wire names are case-sensitive (`kNOT-USD`): a mixed-case input's own casing first, then the
+        // upper-cased guess, then the venue's lower-case "k" (×1000) prefix — before the ~1 MB listing.
+        const kPrefixed = /^K[A-Z0-9]/.test(up) ? extendedWireCandidates(up).map(n => `k${n.slice(1)}`) : [];
+        const mixedCase = raw !== up && raw !== raw.toLowerCase();
+        names = [...new Set([...(mixedCase ? [`${raw}-USD`, `${raw}_24_5-USD`] : []), ...extendedWireCandidates(up), ...kPrefixed])];
     }
     for (const name of names)
         await read(name);

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

@@ -12,9 +12,23 @@ import type { Network } from "../venue-types.js";
 import { type GrvtVenueMarket } from "./public.js";
 /** perp-cli interval → GRVT CandlestickInterval (api-docs.grvt.io/schemas/candlestick_interval). */
 export declare const GRVT_KLINE_INTERVALS: Readonly<Record<string, string>>;
-/** Bars per kline page (the documented max) and pages read before stopping with a warning. */
+/**
+ * Bars per kline page (the documented max) and the most pages one read may take. The `next`
+ * cursor runs dry after ~1000 bars (live 2026-10-19: page 2 had 2 rows and `next` ""), so pages
+ * walk `end_time` back to just before the oldest bar returned instead.
+ */
 export declare const GRVT_KLINE_PAGE = 1000;
-export declare const GRVT_KLINE_MAX_PAGES = 10;
+/**
+ * Pages actually read before giving up. Real pages hold fewer than 1000 bars (minutes without a
+ * bar: 40 d of 1m took 58 pages for 57,583 bars), so the read budget is 25 % above the nominal
+ * GRVT_KLINE_MAX_PAGES. 75 requests stay well inside GRVT's 500 market-data requests / minute.
+ */
+export declare const GRVT_KLINE_READ_PAGES = 75;
+/** Measured live 2026-10-19: /trade answers at most 1000 rows (limit 1500 → 1000, no cursor). */
+export declare const GRVT_TRADES_CAP = 1000;
+/** Measured live 2026-10-19: /funding honours limit 10,000 in one answer (BTC). */
+export declare const GRVT_FUNDING_CAP = 10000;
+export declare const GRVT_KLINE_MAX_PAGES = 60;
 /** Order book depths GRVT serves (api_orderbook_levels_request). */
 export declare const GRVT_BOOK_DEPTHS: readonly [10, 50, 100, 500];
 /**

package/dist/exchanges/grvt/adapter.js

@@ -17,9 +17,31 @@ export const GRVT_KLINE_INTERVALS = {
     "1h": "CI_1_H", "2h": "CI_2_H", "4h": "CI_4_H", "6h": "CI_6_H", "8h": "CI_8_H", "12h": "CI_12_H",
     "1d": "CI_1_D", "3d": "CI_3_D", "5d": "CI_5_D", "1w": "CI_1_W", "2w": "CI_2_W", "3w": "CI_3_W", "4w": "CI_4_W",
 };
-/** Bars per kline page (the documented max) and pages read before stopping with a warning. */
+/** Fixed-length intervals (ms): `start_time` is floored to their boundary (epoch-aligned, UTC). */
+const GRVT_KLINE_FIXED_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, "6h": 21_600_000, "8h": 28_800_000, "12h": 43_200_000, "1d": 86_400_000,
+};
+const GRVT_KLINE_NOMINAL_MS = {
+    ...GRVT_KLINE_FIXED_MS, "3d": 259_200_000, "5d": 432_000_000, "1w": 604_800_000, "2w": 1_209_600_000, "3w": 1_814_400_000, "4w": 2_419_200_000,
+};
+/**
+ * Bars per kline page (the documented max) and the most pages one read may take. The `next`
+ * cursor runs dry after ~1000 bars (live 2026-10-19: page 2 had 2 rows and `next` ""), so pages
+ * walk `end_time` back to just before the oldest bar returned instead.
+ */
 export const GRVT_KLINE_PAGE = 1000;
-export const GRVT_KLINE_MAX_PAGES = 10;
+/**
+ * Pages actually read before giving up. Real pages hold fewer than 1000 bars (minutes without a
+ * bar: 40 d of 1m took 58 pages for 57,583 bars), so the read budget is 25 % above the nominal
+ * GRVT_KLINE_MAX_PAGES. 75 requests stay well inside GRVT's 500 market-data requests / minute.
+ */
+export const GRVT_KLINE_READ_PAGES = 75;
+/** Measured live 2026-10-19: /trade answers at most 1000 rows (limit 1500 → 1000, no cursor). */
+export const GRVT_TRADES_CAP = 1000;
+/** Measured live 2026-10-19: /funding honours limit 10,000 in one answer (BTC). */
+export const GRVT_FUNDING_CAP = 10_000;
+export const GRVT_KLINE_MAX_PAGES = 60;
 const WARN = (msg) => { process.stderr.write(`${msg}\n`); };
 /** Order book depths GRVT serves (api_orderbook_levels_request). */
 export const GRVT_BOOK_DEPTHS = [10, 50, 100, 500];
@@ -91,8 +113,11 @@ export class GrvtPublicAdapter {
     }
     async getOrderbook(symbol, depth = 50) {
         const m = await this.market(symbol);
-        // The smallest served depth that covers the request; above 500 levels, the deepest one (500).
-        const d = GRVT_BOOK_DEPTHS.find(x => x >= depth) ?? 500;
+        // The smallest served depth that covers the request; above 500 → INVALID_PARAMS (never clamped).
+        const d = GRVT_BOOK_DEPTHS.find(x => x >= depth);
+        if (d === undefined || !Number.isInteger(depth) || depth < 1) {
+            throw new PerpError("INVALID_PARAMS", `GRVT: book depth must be 1..500 (got ${depth})`, { exchange: "grvt", remediation: "Pass --depth 1..500" });
+        }
         const res = await this.client.result("book", { instrument: m.instrument, depth: d });
         if (res === null || typeof res !== "object" || !Array.isArray(res.bids) || !Array.isArray(res.asks)) {
             throw grvtShapeError("book has no bids / asks arrays");
@@ -105,10 +130,16 @@ export class GrvtPublicAdapter {
         return { bids: side(res.bids.slice(0, depth), "bid"), asks: side(res.asks.slice(0, depth), "ask") };
     }
     async getRecentTrades(symbol, limit = 50) {
+        if (!Number.isInteger(limit) || limit < 1 || limit > GRVT_TRADES_CAP) {
+            throw new PerpError("INVALID_PARAMS", `GRVT: trades limit must be 1..${GRVT_TRADES_CAP} (got ${limit})`, {
+                remediation: `GRVT serves at most ${GRVT_TRADES_CAP} recent trades per request and no cursor for older ones`,
+            });
+        }
         const m = await this.market(symbol);
-        const res = await this.client.result("trade", { instrument: m.instrument, limit: Math.min(Math.max(1, limit), 1000) });
+        const res = await this.client.result("trade", { instrument: m.instrument, limit });
         if (!Array.isArray(res))
             throw grvtShapeError("trade result is not an array");
+        // The venue answers oldest first; every venue's tape is newest first.
         return res.map(t => {
             const x = t;
             if (typeof x.is_taker_buyer !== "boolean")
@@ -121,15 +152,19 @@ export class GrvtPublicAdapter {
                 size: dec(x.size, "trade size"),
                 fee: null,
             };
-        });
+        }).sort((a, b) => b.time - a.time);
     }
     /**
      * Settled funding (/full/v1/funding, one record per funding interval, newest first). `rate` is a
      * fraction per the record's `intervalHours` (published in percentage points, converted exactly).
      */
     async getFundingHistory(symbol, limit = 100) {
+        if (!Number.isInteger(limit) || limit < 1 || limit > GRVT_FUNDING_CAP) {
+            throw new PerpError("INVALID_PARAMS", `GRVT: funding history limit must be 1..${GRVT_FUNDING_CAP} (got ${limit})`);
+        }
         const m = await this.market(symbol);
-        const res = await this.client.result("funding", { instrument: m.instrument, limit: Math.min(Math.max(1, limit), 1000) });
+        // Sent as asked (it was silently clamped to 1000; the venue serves 10,000 in one answer).
+        const res = await this.client.result("funding", { instrument: m.instrument, limit });
         if (!Array.isArray(res))
             throw grvtShapeError("funding result is not an array");
         return res.map(r => {
@@ -154,28 +189,63 @@ export class GrvtPublicAdapter {
                 remediation: `Use one of: ${Object.keys(GRVT_KLINE_INTERVALS).join(", ")}`,
             });
         }
+        if (!(endTime > startTime))
+            throw new PerpError("INVALID_PARAMS", "GRVT: candle end time must be after the start time");
+        const fixed = GRVT_KLINE_FIXED_MS[interval];
+        // An off-grid start_time makes GRVT answer a truncated first bar labelled off the grid
+        // (live: 4h from 05:07 → a 06:00–08:00 bar), so the start is floored to the boundary.
+        const start = fixed === undefined ? startTime : Math.floor(startTime / fixed) * fixed;
+        const pagesNeeded = Math.ceil((endTime - start) / GRVT_KLINE_NOMINAL_MS[interval] / GRVT_KLINE_PAGE);
+        if (pagesNeeded > GRVT_KLINE_MAX_PAGES) {
+            throw new PerpError("INVALID_PARAMS", `GRVT: ${interval} candles over this range need ${pagesNeeded} requests (max ${GRVT_KLINE_MAX_PAGES})`, {
+                remediation: "Narrow --start / --end or use a longer interval",
+            });
+        }
         const m = await this.market(symbol);
-        // Reverse-chronological pages of up to 1000 bars, followed by `next` until start_time is reached.
-        const rows = [];
-        let cursor = "";
-        for (let page = 0;; page++) {
+        // Reverse-chronological pages of up to 1000 bars; the next page ends just before the oldest
+        // bar returned. Done when a page is empty or reaches `start` — never on the cursor alone.
+        const byOpen = new Map();
+        let end = endTime;
+        let oldestSeen = Infinity;
+        let exhausted = false;
+        for (let page = 0; page < GRVT_KLINE_READ_PAGES; page++) {
             const res = await this.client.post("kline", {
-                instrument: m.instrument, interval: ci, type: "TRADE", start_time: msToNs(startTime), end_time: msToNs(endTime), limit: GRVT_KLINE_PAGE,
-                ...(cursor !== "" ? { cursor } : {}),
+                instrument: m.instrument, interval: ci, type: "TRADE", start_time: msToNs(start), end_time: msToNs(end), limit: GRVT_KLINE_PAGE,
             });
             if (res === null || typeof res !== "object" || !Array.isArray(res.result))
                 throw grvtShapeError("kline result is not an array");
-            rows.push(...res.result);
-            const next = typeof res.next === "string" ? res.next : "";
-            if (res.result.length < GRVT_KLINE_PAGE || next === "")
-                break;
-            if (page + 1 >= GRVT_KLINE_MAX_PAGES) {
-                WARN(`[grvt] kline ${m.instrument} ${interval}: stopped after ${GRVT_KLINE_MAX_PAGES * GRVT_KLINE_PAGE} bars — older bars in the window are not shown (narrow the range)`);
+            // A fixed-interval bar whose first minute had no trade is labelled at its first trade (live
+            // 2026-10-19: the 09:30–10:00 30m bar opened "09:31"); its open is the bucket boundary, and a
+            // page asked to end before that label answers the same bar again — it is not an older bar.
+            const inPage = res.result
+                .map(c => ({ c, t: fixed === undefined ? nsToMs(c.open_time, "kline open_time") : Math.floor(nsToMs(c.open_time, "kline open_time") / fixed) * fixed }))
+                .filter(x => page === 0 || x.t < oldestSeen);
+            // No bar older than the last page (an empty page, or only bars already read): history starts here.
+            if (inPage.length === 0) {
+                exhausted = true;
                 break;
             }
-            cursor = next;
+            let oldest = Infinity;
+            for (const { c, t } of inPage) {
+                byOpen.set(String(t), { ...c, open_time: `${t}000000` });
+                if (t < oldest)
+                    oldest = t;
+            }
+            oldestSeen = oldest;
+            if (oldest <= start)
+                break;
+            end = oldest - 1;
+        }
+        // Ran out of the read budget before reaching `start`: the oldest bars would be missing — never
+        // returned as the whole range.
+        if (!exhausted && oldestSeen > start) {
+            throw new PerpError("EXCHANGE_ERROR", `GRVT: ${interval} candles reached only ${new Date(oldestSeen).toISOString()} after ${GRVT_KLINE_READ_PAGES} pages (requested from ${new Date(start).toISOString()})`, {
+                exchange: "grvt", reachedMs: oldestSeen, requestedFromMs: start,
+                remediation: `Narrow --start / --end (or use a longer interval); fetch older bars with --end ${oldestSeen - 1}`,
+            });
         }
-        return rows.map(c => {
+        const rows = [...byOpen.values()];
+        const bars = rows.map(c => {
             const x = c;
             return {
                 time: nsToMs(x.open_time, "kline open_time"),
@@ -183,8 +253,15 @@ export class GrvtPublicAdapter {
                 volume: dec(x.volume_b, "kline volume_b"),
                 quoteVolume: typeof x.volume_q === "string" && DEC.test(x.volume_q) ? x.volume_q : null,
                 trades: typeof x.trades === "number" ? x.trades : null,
+                closeMs: nsToMs(x.close_time, "kline close_time"),
             };
         }).sort((a, b) => a.time - b.time);
+        // Calendar intervals (3d … 4w) are not floored: a first bar shorter than the interval is a
+        // truncated bar (live: the first 1w bar covered 4 days) and is left out. The newest bar may be
+        // in progress and is kept.
+        const nominal = GRVT_KLINE_NOMINAL_MS[interval];
+        const full = fixed === undefined && bars.length > 1 && bars[0].closeMs - bars[0].time + 1 < nominal * 0.99 ? bars.slice(1) : bars;
+        return full.map(({ closeMs: _c, ...k }) => k);
     }
     // ── Account / trading: refused (read-only in this version) ──
     refuse(feature) {

package/dist/exchanges/hyperliquid-outcome.d.ts

@@ -15,6 +15,8 @@
  */
 import type { OutcomeAdapter, OutcomeMarketInfo, OutcomeOrderbook, OutcomePosition, OutcomeView, OutcomeViewUnderlying } from "./outcome-interface.js";
 import type { HyperliquidAdapter } from "./hyperliquid.js";
+/** Bid–ask width (probability points) above which a side's mid-implied probability is flagged. */
+export declare const OUTCOME_WIDE_SPREAD = 0.2;
 export declare class HyperliquidOutcomeAdapter implements OutcomeAdapter {
     readonly name = "hyperliquid";
     private _hl;

package/dist/exchanges/hyperliquid-outcome.js

@@ -22,6 +22,16 @@ const MIN_ORDER_QUOTE = 10;
 const MAX_SIDE = 9;
 /** Asset id offset spans `[100_000_000, 200_000_000)`, so encoding < 100M. */
 const MAX_ENCODING = 99_999_999;
+/** A numeric description field; a malformed one is left unset (unknown) with a warning, never NaN. */
+function finiteOrWarn(val, key, description) {
+    const n = val.trim() === "" ? NaN : Number(val);
+    if (Number.isFinite(n))
+        return n;
+    process.stderr.write(`[hyperliquid] outcome description ${key} "${val}" is not a number — target price unknown (${description.slice(0, 120)})\n`);
+    return undefined;
+}
+/** Bid–ask width (probability points) above which a side's mid-implied probability is flagged. */
+export const OUTCOME_WIDE_SPREAD = 0.2;
 export class HyperliquidOutcomeAdapter {
     name = "hyperliquid";
     _hl;
@@ -76,9 +86,17 @@ export class HyperliquidOutcomeAdapter {
             else if (key === "expiry")
                 out.expiryMs = HyperliquidOutcomeAdapter._parseExpiry(val);
             else if (key === "targetPrice")
-                out.targetPrice = Number(val);
+                out.targetPrice = finiteOrWarn(val, key, description);
             else if (key === "period")
                 out.period = val;
+            // Template outcomes (name "template:binaryPrice", live 2026-10-19):
+            // "perp:ZEC|priceDescription:…|seconds:90|threshold:1057|time:20261023-0800".
+            else if (key === "perp" && out.underlying === undefined)
+                out.underlying = val;
+            else if (key === "threshold" && out.targetPrice === undefined)
+                out.targetPrice = finiteOrWarn(val, key, description);
+            else if (key === "time" && out.expiryMs === undefined)
+                out.expiryMs = HyperliquidOutcomeAdapter._parseExpiry(val);
         }
         return out;
     }
@@ -315,6 +333,9 @@ export class HyperliquidOutcomeAdapter {
             });
         }
         const parsed = HyperliquidOutcomeAdapter.parseDescription(meta.description);
+        // A template binary-price outcome is a price binary (Yes = underlying ≥ threshold at `time`).
+        if (parsed.class === undefined && meta.name === "template:binaryPrice")
+            parsed.class = "priceBinary";
         // Fetch books for every side in parallel + allMids once for mids and
         // the underlying symbol's mark price.
         const allMidsPromise = this._infoPost({ type: "allMids" });
@@ -336,6 +357,13 @@ export class HyperliquidOutcomeAdapter {
                 bestBid: trimmed.bestBid,
                 bestAsk: trimmed.bestAsk,
                 impliedProb: mid !== undefined ? Number(mid) : undefined,
+                // Template side names ("template:Yes") without the prefix; `name` stays as published.
+                label: spec.name.replace(/^template:/, ""),
+                // The mid of a book wider than OUTCOME_WIDE_SPREAD (e.g. 0.0257 / 0.9899) says little
+                // about the probability: flagged, never dropped.
+                wideSpread: trimmed.bestBid !== undefined && trimmed.bestAsk !== undefined
+                    ? Number(trimmed.bestAsk) - Number(trimmed.bestBid) > OUTCOME_WIDE_SPREAD
+                    : null,
             };
         });
         const midSum = HyperliquidOutcomeAdapter._computeMidSum(sides);

package/dist/exchanges/hyperliquid-spot.d.ts

@@ -9,6 +9,14 @@
 import type { SpotAdapter, SpotMarketInfo, SpotBalance, SpotHoldingPrice, SpotHoldingPricesCapable } from "./spot-interface.js";
 import type { ResolvedSlippage } from "./slippage.js";
 import type { HyperliquidAdapter } from "./hyperliquid.js";
+import { type HlAbstractionMode } from "./hyperliquid.js";
+/**
+ * Spot balances from info `spotClearinghouseState` — the one mapper behind the keyed spot adapter
+ * and the keyless `account balance --address`. `shared` (already counted in the perp equity) follows
+ * the account mode: unified → the USDC row; portfolio margin → USDC and every eligible collateral row
+ * (the venue marks those with `ltv`); any other mode, or `null` (a HIP-3 dex scope / mode unknown) → none.
+ */
+export declare function hlSpotBalanceRows(state: Record<string, unknown>, mode: HlAbstractionMode | null): SpotBalance[];
 export declare class HyperliquidSpotAdapter implements SpotAdapter, SpotHoldingPricesCapable {
     readonly name = "hyperliquid";
     private _hl;

package/dist/exchanges/hyperliquid-spot.js

@@ -16,6 +16,24 @@ import { invalidateCache } from "../cache.js";
 function hlRoundSize(size, szDecimals) {
     return floorSize(size, hlSizeStep(szDecimals));
 }
+/**
+ * Spot balances from info `spotClearinghouseState` — the one mapper behind the keyed spot adapter
+ * and the keyless `account balance --address`. `shared` (already counted in the perp equity) follows
+ * the account mode: unified → the USDC row; portfolio margin → USDC and every eligible collateral row
+ * (the venue marks those with `ltv`); any other mode, or `null` (a HIP-3 dex scope / mode unknown) → none.
+ */
+export function hlSpotBalanceRows(state, mode) {
+    const balances = (state?.balances ?? []);
+    return balances.map((b) => ({
+        token: String(b.coin ?? ""),
+        total: String(b.total ?? "0"),
+        available: String(Number(b.total ?? 0) - Number(b.hold ?? 0)),
+        held: String(b.hold ?? "0"),
+        entryNtl: b.entryNtl !== undefined ? String(b.entryNtl) : undefined,
+        shared: (mode === "unified" || mode === "portfolio") && String(b.coin ?? "") === "USDC"
+            || mode === "portfolio" && Object.prototype.hasOwnProperty.call(b, "ltv"),
+    }));
+}
 export class HyperliquidSpotAdapter {
     name = "hyperliquid";
     _hl;
@@ -181,18 +199,8 @@ export class HyperliquidSpotAdapter {
         // in the funding-arb bot (and a misleading empty holdings table).
         // Reuse cached spot clearinghouse state (shared with getBalance() — saves 1 API call).
         const state = await this._hl._getSpotClearinghouseState({ fresh });
-        const balances = (state?.balances ?? []);
-        // Unified HL accounts: spot USDC IS the perp margin — mark it shared.
-        // HIP-3 dex-scoped adapters report dex equity, which never contains spot USDC.
-        const unified = this._hl.isUnifiedAccount === true && this._hl.dex === "";
-        return balances.map((b) => ({
-            token: String(b.coin ?? ""),
-            total: String(b.total ?? "0"),
-            available: String(Number(b.total ?? 0) - Number(b.hold ?? 0)),
-            held: String(b.hold ?? "0"),
-            entryNtl: b.entryNtl !== undefined ? String(b.entryNtl) : undefined,
-            shared: unified && String(b.coin ?? "") === "USDC",
-        }));
+        // HIP-3 dex-scoped adapters report dex equity, which never contains spot balances.
+        return hlSpotBalanceRows(state, this._hl.dex === "" ? this._hl.accountMode : null);
     }
     async spotMarketOrder(symbol, side, size, opts) {
         const what = `spot ${side} ${size} ${symbol}`;