@johannc-dev/zyrk 0.2.0 → 0.2.1

package/dist/export.d.ts

@@ -7,14 +7,17 @@ export interface ExportConnection {
     readonly apiKey: string;
     /** At most this many requests per minute (default: as fast as the server allows). */
     readonly rpm?: number;
-    /** Network or 5xx failures tolerated in a row before giving up (default 8). */
+    /** Network failures, 502, 503 and 504 tolerated in a row before giving up (default 8); another 5xx is retried once. */
     readonly maxRetries?: number;
-    /** Longest wait accepted on a 429 before stopping (default 5 minutes): a daily quota stops the export. */
+    /** Longest wait accepted on 429s in a row before stopping (default 5 minutes): a daily quota stops the export. */
     readonly maxWaitMs?: number;
     readonly fetch?: typeof fetch;
     readonly signal?: AbortSignal;
     readonly onProgress?: (progress: ExportProgress) => void;
-    /** Hours that may still change (open, not sealed), files downloaded again. */
+    /**
+     * Hours that may still change (open, not sealed), files downloaded again,
+     * errors saved as the answer of a call.
+     */
     readonly onWarning?: (message: string) => void;
 }
 export interface ExportProgress {
@@ -52,7 +55,7 @@ export interface ExportSummary {
 }
 /** `[since, until)` in parts of at most 30 days, ending on UTC day boundaries. */
 export declare function parts(sinceMs: number, untilMs: number): [number, number][];
-/** Meta of an export answer (`history_columns::export::hour_response`). */
+/** Meta of an export answer. */
 interface HourMeta {
     readonly format?: string;
     readonly coverage?: ReadMeta["coverage"];
@@ -76,12 +79,18 @@ export declare function parseFrame(bytes: Uint8Array): {
 export declare function staleFrom(meta: ReadMeta, dir: string): number | null;
 /** Exports one read (cut into parts of at most 30 days). Resumes an interrupted export. */
 export declare function exportHistory(connection: ExportConnection, out: string, read: ExportRead): Promise<ExportSummary>;
-/** Saves `/v1/tokens/{mint}/totals` for `ctx.data.tokenTotals`. */
+/**
+ * Saves the totals of a mint for `ctx.data.tokenTotals`, and its info for
+ * `ctx.data.tokenInfo`, as hosted programs receive them. Returns the totals,
+ * or the error answer saved for them (`{ error: { kind, code, message } }`).
+ */
 export declare function exportTotals(connection: ExportConnection, out: string, mint: string, quote?: string | null): Promise<Json>;
 /**
- * Saves every page of `/v1/volume/search` for `params`, following the
+ * Saves every page of a volume search for `params`, following the
  * cursor exactly as `ctx.data.volumeSearch` does, so that the same call in
- * a local run finds each page.
+ * a local run finds each page. A page answered by an error (an invalid
+ * parameter...) is saved as that error, and ends the search, as it does in a
+ * hosted call.
  */
 export declare function exportVolumeSearch(connection: ExportConnection, out: string, params: VolumeSearchParams): Promise<number>;
 export {};

package/dist/export.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { decompressHour } from "./hourfile.js";
-import { HOUR_MS, READ_FORMAT, sha256, readId, spec as readSpec, totalsName, volumeName, } from "./local-data.js";
+import { HOUR_MS, READ_FORMAT, infoName, sha256, readId, spec as readSpec, totalsName, volumeName, } from "./local-data.js";
 import { MAX_WINDOW_MS } from "./limits.js";
 const DAY_MS = 86_400_000;
 const PART_MS = 30 * DAY_MS;
@@ -40,6 +40,8 @@ const writeAtomic = (file, data) => {
     writeFileSync(tmp, data);
     renameSync(tmp, file);
 };
+const MAX_BUSY_ATTEMPTS = 12;
+const MAX_SERVER_ERRORS = 1;
 class Http {
     c;
     requests = 0;
@@ -47,12 +49,15 @@ class Http {
     constructor(c) {
         this.c = c;
     }
-    async raw(path, query) {
+    async raw(path, query, keep) {
         const f = this.c.fetch ?? fetch;
         const url = new URL(this.c.url.replace(/\/+$/, "") + path);
         for (const [k, v] of Object.entries(query))
             url.searchParams.set(k, v);
         let failures = 0;
+        let serverErrors = 0;
+        let busy = 0;
+        let waited = 0;
         for (;;) {
             if (this.c.rpm) {
                 const gap = 60_000 / this.c.rpm - (Date.now() - this.#last);
@@ -88,6 +93,8 @@ class Http {
             catch {
                 body = null;
             }
+            if (keep?.(response.status, body))
+                return { status: response.status, contentType, bytes };
             const err = body?.error;
             const code = typeof err === "string"
                 ? err
@@ -105,12 +112,26 @@ class Http {
                     ? header * 1000
                     : undefined;
             if (response.status === 429) {
-                const wait = retryMs ?? 60_000;
-                if (wait > (this.c.maxWaitMs ?? 300_000))
-                    throw new ExportError(`${code}: ${message} Retry after ${Math.round(wait / 1000)} s: run the same command again then, the export resumes where it stopped.`, code, 429);
+                const maxWait = this.c.maxWaitMs ?? 300_000;
+                const asked = retryMs ?? 60_000;
+                if (asked > maxWait)
+                    throw new ExportError(`${code}: ${message} Retry after ${Math.round(asked / 1000)} s: run the same command again then, the export resumes where it stopped.`, code, 429);
+                const wait = Math.max(asked, Math.min(30_000, 1000 * 2 ** busy));
+                if (++busy >= MAX_BUSY_ATTEMPTS || waited + wait > maxWait)
+                    throw new ExportError(`${code}: ${message} The server answered 429 ${busy} times in a row (${Math.round(waited / 1000)} s): run the same command again later, the export resumes where it stopped.`, code, 429);
+                waited += wait;
                 await sleep(wait, this.c.signal);
                 continue;
             }
+            if (response.status >= 500 &&
+                response.status !== 502 &&
+                response.status !== 503 &&
+                response.status !== 504) {
+                if (++serverErrors > MAX_SERVER_ERRORS)
+                    throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
+                await sleep(Math.min(30_000, 500 * 2 ** serverErrors), this.c.signal);
+                continue;
+            }
             if (response.status >= 500 && code !== "history_timeout") {
                 if (++failures > (this.c.maxRetries ?? 8))
                     throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
@@ -120,11 +141,14 @@ class Http {
             throw new ExportError(`${response.status} ${code}: ${message}`, code, response.status);
         }
     }
-    async get(path, query) {
-        const answer = await this.raw(path, query);
+    async get(path, query, keep) {
+        const answer = await this.raw(path, query, keep);
         const text = new TextDecoder().decode(answer.bytes);
         try {
-            return text ? JSON.parse(text) : null;
+            return {
+                status: answer.status,
+                body: text ? JSON.parse(text) : null,
+            };
         }
         catch {
             throw new ExportError(`${path}: the answer is not JSON`, "decode");
@@ -171,9 +195,9 @@ export function staleFrom(meta, dir) {
             break;
         let live = false;
         try {
+            const { header } = decompressHour(readFileSync(join(dir, `${hour}.zhb`)));
             live =
-                decompressHour(readFileSync(join(dir, `${hour}.zhb`))).header.source ===
-                    "live";
+                header.source === "live" || (header.market && !header.virtualSides);
         }
         catch {
             live = true;
@@ -207,7 +231,7 @@ async function exportPart(http, out, s, sinceMs, untilMs, progress, refresh, onP
     if (meta.done) {
         const from = staleFrom(meta, dir);
         if (from !== null) {
-            onWarning?.(`${id}: hours from ${new Date(from * HOUR_MS).toISOString()} were open or not sealed when exported; downloading them again`);
+            onWarning?.(`${id}: hours from ${new Date(from * HOUR_MS).toISOString()} were open or not sealed when exported, or exported by an older version; downloading them again`);
             const hours = meta.hours.filter((h) => h < from);
             meta = {
                 ...meta,
@@ -307,12 +331,67 @@ export async function exportHistory(connection, out, read) {
     }
     return { reads, requests: http.requests, bytes: progress.bytes };
 }
+const RECORDED = new Set([
+    "invalid_window",
+    "invalid_parameter",
+    "invalid_limit",
+    "invalid_amount",
+    "invalid_cursor",
+    "usd_volume_unavailable",
+    "partial_coverage",
+    "query_work_limit",
+]);
+const recordable = (status, body) => {
+    const e = body?.error;
+    return (status === 400 &&
+        typeof e === "object" &&
+        e !== null &&
+        typeof e.kind === "string" &&
+        typeof e.code === "string" &&
+        typeof e.message === "string" &&
+        RECORDED.has(e.code));
+};
+async function getNew(http, path, query, what) {
+    try {
+        const { status, body } = await http.get(path, query, recordable);
+        if (status !== 400)
+            return { ok: body };
+        const e = body.error;
+        const retry = body.retryAfterMs;
+        return {
+            code: e.code,
+            error: {
+                error: { kind: e.kind, code: e.code, message: e.message },
+                ...(typeof retry === "number" ? { retryAfterMs: retry } : {}),
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof ExportError && error.status === 404)
+            throw new ExportError(`This server does not export ${what} yet (it answered 404): it must be upgraded first. Trades (--token, --wallet) export as before.`, "unsupported_server", 404);
+        throw error;
+    }
+}
+function save(connection, out, [dir, name], answer, content, call) {
+    const ok = join(out, dir, name);
+    const failed = join(out, "errors", dir, name);
+    const [file, other] = "ok" in answer ? [ok, failed] : [failed, ok];
+    mkdirSync(dirname(file), { recursive: true });
+    writeAtomic(file, JSON.stringify(content));
+    rmSync(other, { force: true });
+    if (!("ok" in answer))
+        connection.onWarning?.(`${call} answered ${answer.code}: saved as its answer; the same call in a local run throws this error, as a hosted call does now`);
+}
 export async function exportTotals(connection, out, mint, quote = null) {
     const http = new Http(connection);
-    const body = await http.get(`/v1/tokens/${encodeURIComponent(mint)}/totals`, quote ? { quote } : {});
-    mkdirSync(join(out, "totals"), { recursive: true });
-    writeAtomic(join(out, "totals", totalsName(mint, quote)), JSON.stringify(body));
-    return body;
+    const key = encodeURIComponent(mint);
+    const body = await getNew(http, `/v1/functions/totals/${key}`, quote ? { quote } : {}, "totals (--totals)");
+    const info = await getNew(http, `/v1/functions/info/${key}`, {}, "totals (--totals)");
+    const content = (a) => ("ok" in a ? a.ok : a.error);
+    const totals = content(body);
+    save(connection, out, ["totals", totalsName(mint, quote)], body, totals, "tokenTotals");
+    save(connection, out, ["info", infoName(mint)], info, content(info), "tokenInfo");
+    return totals;
 }
 export async function exportVolumeSearch(connection, out, params) {
     const http = new Http(connection);
@@ -322,8 +401,13 @@ export async function exportVolumeSearch(connection, out, params) {
         const flat = Object.entries(p)
             .filter(([, v]) => v !== undefined && v !== null)
             .map(([k, v]) => [k, String(v)]);
-        const page = await http.get("/v1/volume/search", Object.fromEntries(flat));
-        writeAtomic(join(out, "volume", `${volumeName(flat)}.json`), JSON.stringify({ params: flat, page }));
+        const answer = await getNew(http, "/v1/functions/volume/search", Object.fromEntries(flat), "volume searches (--volume-search)");
+        save(connection, out, ["volume", `${volumeName(flat)}.json`], answer, "ok" in answer
+            ? { params: flat, page: answer.ok }
+            : { params: flat, ...answer.error }, `volumeSearch (page ${pages})`);
+        if (!("ok" in answer))
+            return pages;
+        const page = answer.ok;
         const next = page?.nextCursor;
         if (next === null || next === undefined)
             return pages;

package/dist/hourfile.d.ts

@@ -1,4 +1,4 @@
-import type { HourBatch } from "./sdk.js";
+import { type HourBatch } from "./sdk.js";
 export declare const HOUR_MAGIC = "ZHB1";
 export type ColumnType = "u8" | "u16" | "u32" | "i32" | "u64" | "f64";
 export interface HourHeader {
@@ -12,6 +12,8 @@ export interface HourHeader {
     /** Exports: timestamp of each operation counted in `skipped` (`null`: unknown). */
     readonly skippedTimes?: readonly (number | null)[];
     readonly market: boolean;
+    /** Market flags with one bit per virtual side; absent from older files. */
+    readonly virtualSides?: boolean;
     readonly order: boolean;
     /** Absent from files written before transaction ids. */
     readonly tx?: boolean;

package/dist/hourfile.js

@@ -1,4 +1,5 @@
 import { constants, zstdCompressSync, zstdDecompressSync } from "node:zlib";
+import { MarketFlag } from "./sdk.js";
 export const HOUR_MAGIC = "ZHB1";
 export const nodeRealm = {
     Uint8Array,
@@ -237,6 +238,12 @@ export function batchOf(raw, realm = nodeRealm) {
         const m = new realm.Object();
         for (const [name, type] of MARKET_COLUMNS)
             m[name] = column(`market.${name}`, type);
+        const flags = m.flags;
+        if (!header.virtualSides)
+            for (let i = 0; i < flags.length; i++)
+                if ((flags[i] & MarketFlag.virtualReserves) !== 0)
+                    flags[i] |=
+                        MarketFlag.virtualTokenReserve | MarketFlag.virtualQuoteReserve;
         batch.market = m;
     }
     if (header.order) {

package/dist/limits.d.ts

@@ -1,5 +1,5 @@
 /**
- * Limits of funrun v2, mirrored from the server defaults. The server is the
+ * Limits of hosted functions, mirrored from the server defaults. The server is the
  * authority; these constants let tools and programs plan around them.
  *
  * No dependency: safe to import from guest code.

package/dist/local-data.d.ts

@@ -69,7 +69,7 @@ export declare class ReadFailed extends Error {
 export declare const sha256: (bytes: Uint8Array) => string;
 export declare function windowComplete(c: Coverage, since: number, until: number): boolean;
 export declare function hourComplete(c: Coverage, hour: number, since: number, until: number): boolean;
-/** `funrun_sandbox::natives::batch_bytes`: what a batch costs against `readBytes`. */
+/** What a batch costs against `readBytes`, as the service counts it. */
 export declare function batchBytes(h: HourHeader): number;
 export interface HourRead {
     readonly batch: HourBatch;
@@ -93,14 +93,23 @@ export declare class LocalData {
     find(s: ReadSpec, since: number, until: number): ReadMeta | undefined;
     /**
      * The next batch of a read after `afterHour` (`null`: none left), as
-     * `ColumnsReader::read_hour` answers it. Throws {@link ReadFailed}.
+     * the service's reader answers it. Throws {@link ReadFailed}.
      */
     readHour(s: ReadSpec, since: number, until: number, allowPartial: boolean, afterHour: number | null, realm?: Realm): HourRead | null;
-    /** `/v1/tokens/{mint}/totals` saved by the export, or `undefined`. */
+    /** Totals of a mint saved by the export, or `undefined`. */
     totals(mint: string, quote: string | null): Json | undefined;
-    /** A `/v1/volume/search` page saved by the export for exactly these parameters. */
+    /** Info of a mint saved by the export (`--totals`), or `undefined`. */
+    info(mint: string): Json | undefined;
+    /** The error `tokenTotals` answered at export, or `undefined`. */
+    totalsFailure(mint: string, quote: string | null): ReadFailure | undefined;
+    /** The error `tokenInfo` answered at export, or `undefined`. */
+    infoFailure(mint: string): ReadFailure | undefined;
+    /** The error a volume search page answered at export, or `undefined`. */
+    volumeFailure(params: readonly (readonly [string, string])[]): ReadFailure | undefined;
+    /** A volume search page saved by the export for exactly these parameters. */
     volumePage(params: readonly (readonly [string, string])[]): Json | undefined;
 }
 export declare const totalsName: (mint: string, quote: string | null) => string;
+export declare const infoName: (mint: string) => string;
 /** Parameters as the sandbox passes them (`[key, string value]`), sorted. */
 export declare function volumeName(params: readonly (readonly [string, string])[]): string;

package/dist/local-data.js

@@ -315,7 +315,8 @@ export class LocalData {
                 batch: batchOf(raw, realm),
                 bytes: batchBytes(raw.header),
                 recut: recuts,
-                stale: stale(raw.header.source, hour),
+                stale: stale(raw.header.source, hour) ||
+                    (raw.header.market && !raw.header.virtualSides),
             };
         }
         return null;
@@ -330,15 +331,42 @@ export class LocalData {
             throw corrupt(file, e, again);
         }
     }
+    #failure(file, again) {
+        const saved = this.#json(join(this.dir, "errors", file), again);
+        if (saved === undefined)
+            return undefined;
+        const { code, message } = saved?.error ?? {};
+        if (typeof code !== "string" || typeof message !== "string")
+            throw corrupt(join(this.dir, "errors", file), new Error("not an error answer"), again);
+        const retry = saved.retryAfterMs;
+        return {
+            code,
+            message,
+            ...(typeof retry === "number" ? { retryAfterMs: retry } : {}),
+        };
+    }
     totals(mint, quote) {
         return this.#json(join(this.dir, "totals", totalsName(mint, quote)), `zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
     }
+    info(mint) {
+        return this.#json(join(this.dir, "info", infoName(mint)), `zyrk export --totals ${mint}`);
+    }
+    totalsFailure(mint, quote) {
+        return this.#failure(join("totals", totalsName(mint, quote)), `zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
+    }
+    infoFailure(mint) {
+        return this.#failure(join("info", infoName(mint)), `zyrk export --totals ${mint}`);
+    }
+    volumeFailure(params) {
+        return this.#failure(join("volume", `${volumeName(params)}.json`), "zyrk export --volume-search '<params>'");
+    }
     volumePage(params) {
         const saved = this.#json(join(this.dir, "volume", `${volumeName(params)}.json`), "zyrk export --volume-search '<params>'");
         return saved?.page;
     }
 }
 export const totalsName = (mint, quote) => quote ? `${mint}~${quote}.json` : `${mint}.json`;
+export const infoName = (mint) => `${mint}.json`;
 export function volumeName(params) {
     const canonical = JSON.stringify([...params].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)));
     return createHash("sha256").update(canonical).digest("hex").slice(0, 32);

package/dist/local-replay.d.ts

@@ -1,15 +1,15 @@
 import { type LocalData, type ReadMeta } from "./local-data.js";
 import { type HourBatch, type Subscription } from "./sdk.js";
-/** `windows::LAG_MS`: the first 30 s after coverage starts are not trusted. */
+/** The first 30 s after coverage starts are not trusted (as the service). */
 export declare const LAG_MS = 30000;
 /** Events per delivery, as `delivery_batch` of the service. */
 export declare const DELIVERY_BATCH = 32;
-/** Largest `batchSize` of a replay (`replay::MAX_BATCH` of the service). */
+/** Largest `batchSize` of a replay of the service. */
 export declare const REPLAY_MAX_BATCH = 1000;
-/** History items per source page of the service (`ReplayLimits::page`). */
+/** History items per source page of the service's replays. */
 export declare const SOURCE_PAGE = 500;
 /**
- * Fields of the live operation JSON (`query::operation`) that exported
+ * Fields of the live operation JSON that exported
  * columns do not hold: absent from replayed operations.
  */
 export declare const MISSING_OPERATION_FIELDS: readonly ["prices (provider strings: read batch.price… instead)", "usdValue", "finality", "provenance", "market (the provider's raw object)"];
@@ -26,7 +26,7 @@ export interface ReplayProgress {
     gaps: number;
     orderFallbacks: number;
 }
-/** Decimal string of a raw amount (`query::dec_text`). */
+/** Decimal string of a raw amount, as the live JSON writes it. */
 export declare function formatRaw(raw: bigint, decimals: number): string;
 /** Row `i` as the live publication shapes it (without {@link MISSING_OPERATION_FIELDS}). */
 export declare function operationOf(b: HourBatch, i: number): Record<string, unknown>;

package/dist/local-replay.js

@@ -82,7 +82,8 @@ function poolEventOf(b, i, kind) {
     const m = b.market;
     const flags = m.flags[i];
     const reserves = (flags & MarketFlag.reserves) !== 0;
-    const virtual = (flags & MarketFlag.virtualReserves) !== 0;
+    const vToken = (flags & MarketFlag.virtualTokenReserve) !== 0;
+    const vQuote = (flags & MarketFlag.virtualQuoteReserve) !== 0;
     const op = operationOf(b, i);
     return {
         ...op,
@@ -93,10 +94,10 @@ function poolEventOf(b, i, kind) {
         market: {
             tokenReserveRaw: reserves ? m.tokenReserve[i].toString() : null,
             quoteReserveRaw: reserves ? m.quoteReserve[i].toString() : null,
-            virtualTokenReserveRaw: virtual
+            virtualTokenReserveRaw: vToken
                 ? m.virtualTokenReserve[i].toString()
                 : null,
-            virtualQuoteReserveRaw: virtual
+            virtualQuoteReserveRaw: vQuote
                 ? m.virtualQuoteReserve[i].toString()
                 : null,
             signer: addressAt(b, m.signer[i]),

package/dist/local-storage.d.ts

@@ -9,9 +9,9 @@ export declare const localStorageLimits: {
     readonly maxUploads: 4;
     /** Bytes read plus written by one execution (`io_limit`). */
     readonly ioBytes: number;
-    /** Quota cost floor of one object (`StorageOptions::min_object_bytes`). */
+    /** Quota cost floor of one object. */
     readonly minObjectBytes: 4096;
-    /** Objects per area (`AreaOptions::max_objects`). */
+    /** Objects per area. */
     readonly maxObjects: 100000;
 };
 export interface AreaConfig {

package/dist/local.d.ts

@@ -199,9 +199,9 @@ export interface KeepStorage {
     readonly from?: "short" | "long" | "durable";
     readonly keys?: readonly string[];
 }
-/** The service's `ReplayLimits::max_duration_ms` (30 min). */
+/** Longest replay of the service (30 min). */
 export declare const REPLAY_MAX_DURATION_MS: number;
-/** The service's `FeedLimits::replay_bytes` (16 MiB). */
+/** Unread feed of one replay on the service (16 MiB). */
 export declare const REPLAY_FEED_BYTES: number;
 /** What {@link LocalRunner.replay} answers (the service's replay record, locally). */
 export interface LocalReplay {

package/dist/local.js

@@ -6,10 +6,21 @@ import { getHeapStatistics } from "node:v8";
 import vm from "node:vm";
 import { buildProgram } from "./build.js";
 import { DELIVERY_BATCH, REPLAY_MAX_BATCH, MISSING_OPERATION_FIELDS, intervalEvents, replayEvents, } from "./local-replay.js";
-import { LocalData, ReadFailed, spec as readSpec } from "./local-data.js";
+import { LocalData, ReadFailed, spec as readSpec, } from "./local-data.js";
 import { LocalStorage, StorageOpError, } from "./local-storage.js";
 import { accountLimits, execLimits, subscriptionLimits } from "./limits.js";
 const here = dirname(fileURLToPath(import.meta.url));
+let batchReadsSaid = false;
+function batchReadsFromEnv() {
+    const raw = process.env.FUNRUN_BATCH_READS;
+    const v = (raw ?? "").trim();
+    const on = v === "on" || v === "1" || v === "true";
+    if (raw !== undefined && !batchReadsSaid) {
+        batchReadsSaid = true;
+        process.stderr.write(`zyrk local runner: FUNRUN_BATCH_READS=${JSON.stringify(raw)}: batched history reads ${on ? "on" : "off"} (hosted functions batch only when the service has the same setting; off there by default)\n`);
+    }
+    return on;
+}
 let bootstrapText;
 export function sandboxBootstrap() {
     return (bootstrapText ??= readFileSync(join(here, "sandbox-bootstrap.js"), "utf8"));
@@ -60,6 +71,13 @@ const WEBHOOK_PAYLOAD_BYTES = 16 * 1024;
 const WEBHOOK_OVERHEAD_BYTES = 256;
 const WEBHOOK_QUEUE_LIMIT = 1000;
 const MAX_MESSAGE_BYTES = 2048;
+const openWhenExported = (v) => {
+    const c = v?.coverage;
+    return (typeof c === "object" &&
+        c !== null &&
+        (c.unsealed === true ||
+            (c.liveUntilMs !== null && c.liveUntilMs !== undefined)));
+};
 const jsonBytes = (v) => Buffer.byteLength(JSON.stringify(v) ?? "null");
 const truncate = (m) => Buffer.byteLength(m) <= MAX_MESSAGE_BYTES
     ? m
@@ -459,8 +477,31 @@ export class LocalRunner {
                 throw sdkError(program("local_data_missing", "No data directory: export history with zyrk export, then pass --data (or { data })."));
             return this.data;
         };
+        const saved = (answer, failure, missing) => {
+            let value;
+            let failed;
+            try {
+                value = answer();
+                failed = value === undefined ? failure() : undefined;
+            }
+            catch (error) {
+                if (error instanceof ReadFailed)
+                    throw sdkError(fromRead(error.failure));
+                throw error;
+            }
+            if (failed)
+                throw sdkError(fromRead(failed));
+            if (value === undefined)
+                throw sdkError(program("local_data_missing", missing));
+            if (openWhenExported(value))
+                this.#warn("Totals or volume search pages were exported while an hour was still open: the service may now answer otherwise. Run zyrk export again (--totals, --volume-search) to download them again.");
+            charge(jsonBytes(value));
+            return guestJson(value);
+        };
         return {
             maxDepth: this.limits.account.maxDepth,
+            batchReads: batchReadsFromEnv(),
+            hint: () => undefined,
             fail: (code, message) => sdkError(new HostError(kindOfSdkCode(String(code)), String(code), String(message))),
             op: (text, awaited) => this.#op(e, text, !!awaited, realm, mode, sdkError, guestJson, sample),
             read: (kind, key, since, until, side, allowPartial, withSignatures, after, withMarket, withEvents, withOrder, withTx) => {
@@ -505,7 +546,7 @@ export class LocalRunner {
                 if (hour === null)
                     return null;
                 if (hour.stale)
-                    this.#warn("Some hours were open or not sealed when they were exported: the service may now answer otherwise. Run zyrk export again to download them again.");
+                    this.#warn("Some hours were open or not sealed when they were exported, or were exported by an older version: the service may now answer otherwise. Run zyrk export again to download them again.");
                 if (hour.recut)
                     this.#warn("A read used a narrower window than its export: its edge hours were cut locally. Values are the service's; the address indexes and market.flags (chainBreak, chainUnchecked) of a cut hour may differ. Export the exact window for byte-identical batches.");
                 charge(hour.bytes);
@@ -517,47 +558,20 @@ export class LocalRunner {
                 if (typeof mint !== "string" ||
                     (quote !== null && typeof quote !== "string"))
                     throw sdkError(program("invalid_argument", "Expected a mint address"));
-                const value = data().totals(mint, quote);
-                if (value === undefined)
-                    throw sdkError(program("local_data_missing", `No exported totals for ${mint}: zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`));
-                charge(jsonBytes(value));
-                return guestJson(value);
+                return saved(() => data().totals(mint, quote), () => data().totalsFailure(mint, quote), `No exported totals for ${mint}: zyrk export --totals ${mint}${quote ? ` --quote ${quote}` : ""}`);
             },
             info: (mint) => {
                 readAllowed();
                 e.usage.readCalls++;
                 if (typeof mint !== "string")
                     throw sdkError(program("invalid_argument", "Expected a mint address"));
-                const t = data().totals(mint, null);
-                if (t === undefined)
-                    throw sdkError(program("local_data_missing", `No exported totals for ${mint}: zyrk export --totals ${mint}`));
-                const creation = (t.creation ?? null);
-                const metadata = (t.metadata ?? null);
-                const created = creation !== null &&
-                    typeof creation === "object" &&
-                    !Array.isArray(creation) &&
-                    typeof creation.timestamp === "number"
-                    ? creation.timestamp
-                    : (t.createdMs ?? null);
-                const value = {
-                    mint,
-                    known: creation !== null || metadata !== null || created !== null,
-                    createdMs: created,
-                    creation,
-                    metadata,
-                };
-                charge(jsonBytes(value));
-                return guestJson(value);
+                return saved(() => data().info(mint), () => data().infoFailure(mint), `No exported info for ${mint} (exports by older versions saved only its totals): zyrk export --totals ${mint}`);
             },
             volume: (text) => {
                 readAllowed();
                 e.usage.readCalls++;
                 const params = JSON.parse(String(text));
-                const page = data().volumePage(params);
-                if (page === undefined)
-                    throw sdkError(program("local_data_missing", `No exported volume page for these parameters: zyrk export --volume-search '${JSON.stringify(Object.fromEntries(params.filter(([k]) => k !== "cursor")))}'`));
-                charge(jsonBytes(page));
-                return guestJson(page);
+                return saved(() => data().volumePage(params), () => data().volumeFailure(params), `No exported volume page for these parameters: zyrk export --volume-search '${JSON.stringify(Object.fromEntries(params.filter(([k]) => k !== "cursor")))}'`);
             },
             encode: (text) => {
                 const bytes = Buffer.from(String(text), "utf8");