@johannc-dev/zyrk 0.2.0 → 0.2.2

package/dist/sdk.d.ts

@@ -278,7 +278,12 @@ export declare const MarketEvent: {
 export declare const MarketFlag: {
     /** `tokenReserve` and `quoteReserve` are set. */
     readonly reserves: 1;
-    /** `virtualTokenReserve` and `virtualQuoteReserve` are set. */
+    /**
+     * `virtualTokenReserve` and `virtualQuoteReserve` are both set (always
+     * with {@link MarketFlag.virtualTokenReserve} and
+     * {@link MarketFlag.virtualQuoteReserve}). PumpSwap trades usually carry
+     * one side only: test the side you need instead.
+     */
     readonly virtualReserves: 2;
     /**
      * The provider row holds several operations on this pool (e.g. a buy and
@@ -315,6 +320,14 @@ export declare const MarketFlag: {
      * trader receives 0.30 % less than `tokenRaw`. `chainBreak` accounts for it.
      */
     readonly invertedPool: 512;
+    /** `virtualTokenReserve` is set. */
+    readonly virtualTokenReserve: 1024;
+    /**
+     * `virtualQuoteReserve` is set. On PumpSwap (pools created by pump.fun)
+     * it is added to the real reserve: the effective quote reserve is
+     * `quoteReserve + virtualQuoteReserve`.
+     */
+    readonly virtualQuoteReserve: 2048;
 };
 /**
  * Pool state and fees of each trade (`withMarket: true`), entry `i` for
@@ -328,9 +341,12 @@ export interface MarketColumns {
     readonly tokenReserve: BigUint64Array;
     readonly quoteReserve: BigUint64Array;
     /**
-     * Pumpfun: the virtual reserves of the bonding curve, the ones its
-     * constant product uses. Pumpswap: the provider's virtual reserves, when
-     * it gives them.
+     * Pumpfun: the total virtual reserves of the bonding curve, the ones its
+     * constant product uses. Pumpswap: a virtual amount added to the real
+     * reserve (effective quote reserve = `quoteReserve + virtualQuoteReserve`),
+     * usually on one side only. Each side is set when its flag is
+     * ({@link MarketFlag.virtualTokenReserve},
+     * {@link MarketFlag.virtualQuoteReserve}), `0` otherwise.
      */
     readonly virtualTokenReserve: BigUint64Array;
     readonly virtualQuoteReserve: BigUint64Array;
@@ -352,11 +368,11 @@ export interface MarketColumns {
     readonly event: Uint8Array;
 }
 /**
- * Latest known token metadata (`/v1/tokens/{mint}/info`, also `metadata` of
+ * Latest known token metadata (`ctx.data.tokenInfo`, also `metadata` of
  * `tokenTotals`): provider values copied verbatim from the newest row of the
  * mint that is cheap to reach, `null` when the row lacks them. `name`,
- * `symbol` and `uri` of stored hours come from the hour's `tokens.t2` (the
- * newest hour that has them), cut at 128, 64 and 512 UTF-8 bytes.
+ * `symbol` and `uri` of sealed hours come from the token index of the newest
+ * sealed hour that has them, cut at 128, 64 and 512 UTF-8 bytes.
  */
 export type TokenMetadata = {
     readonly name: string | null;
@@ -372,6 +388,12 @@ export type TokenMetadata = {
     readonly quoteName: string | null;
     readonly quoteSymbol: string | null;
     readonly quoteUri: string | null;
+    /**
+     * Decimals of `quoteMint`: the row's, else 9 for SOL and 6 for USDC, else
+     * those of the quote table (rows sent before 2026-10-29 18:15 UTC lack
+     * them), else `null` (absent from metadata saved by older exports).
+     */
+    readonly quoteDecimals?: number | null;
     /** Time, slot and signature of the row the values come from. */
     readonly asOfMs: number | null;
     readonly slot: number | null;
@@ -393,8 +415,8 @@ export type TokenInfo = {
     readonly metadata: TokenMetadata | null;
 };
 /**
- * Parameters of `/v1/volume/search`, with the same names and units
- * (`since`/`until` in **seconds**, multiples of 60). Paging is handled by
+ * Parameters of `ctx.data.volumeSearch` (`since`/`until` in **seconds**,
+ * multiples of 60, `[since, until)`, at most 31 days). Paging is handled by
  * `ctx.data.volumeSearch`: there is no `cursor`.
  */
 export interface VolumeSearchParams {
@@ -501,9 +523,9 @@ export interface Subscription {
     readonly maxReplayEvents?: number;
 }
 /**
- * A trade as published by the live feed, in the JSON shape of the public API
- * (`/v1/tokens/{mint}/operations`). Only the fields most programs read are
- * typed; the others are kept as they come.
+ * A trade as published by the live feed (the `operation` of a `trade` or
+ * `volume` event), with `id` the trade id `"hour:line:op"`. Only the fields
+ * most programs read are typed; the others are kept as they come.
  */
 export interface MarketOperation {
     readonly id: string;
@@ -795,7 +817,7 @@ export interface ExecutionInfo {
     /** 1 for the first attempt. */
     readonly attempt: number;
 }
-/** Lakebed's `StoragePutOptions` (every field optional here). */
+/** Options of `put` (every field optional). */
 export interface StoragePutOptions {
     /** `type/subtype`; parameters are dropped. Default: `text/plain` for a string, else `application/octet-stream`. */
     readonly contentType?: string;
@@ -809,7 +831,7 @@ export interface StoragePutOptions {
      */
     readonly ifMatch?: string;
 }
-/** Lakebed's `StorageObjectHead`, plus where the object stands in time. */
+/** The head of a stored object, with where it stands in time. */
 export interface StorageObjectHead {
     readonly key: string;
     readonly size: number;
@@ -824,11 +846,11 @@ export interface StorageObjectHead {
     /** Changes at every write (HTTP `ETag`). */
     readonly etag: string;
 }
-/** Lakebed's `StorageReadResult`. With a range, `body` is that range and `size` the whole object's. */
+/** What `get` answers. With a range, `body` is that range and `size` the whole object's. */
 export interface StorageReadResult extends StorageObjectHead {
     readonly body: Uint8Array;
 }
-/** Lakebed's `StorageObjectSummary` (what `list` answers), plus expiry. */
+/** One object of a `list` answer, with its expiry. */
 export interface StorageObjectSummary {
     readonly key: string;
     readonly size: number;
@@ -837,14 +859,14 @@ export interface StorageObjectSummary {
     readonly expiresAt: number | null;
 }
 /**
- * What `list` answers: Lakebed's array of summaries, plus `cursor` (pass it
+ * What `list` answers: an array of summaries, plus `cursor` (pass it
  * as `after` for the next page, `null` at the end) and `truncated`.
  */
 export type StorageListPage = StorageObjectSummary[] & {
     readonly cursor: string | null;
     readonly truncated: boolean;
 };
-/** Lakebed's `StorageLedgerUsage` for one area of the account, with its limits. */
+/** Usage of one storage area of the account, with its limits. */
 export interface StorageUsage {
     readonly area: "short" | "long" | "durable";
     readonly initialized: boolean;
@@ -886,9 +908,9 @@ export interface StorageWriter {
  * execution fails afterwards.
  */
 export interface StorageArea {
-    /** Lakebed's `put`. Answers the new head. */
+    /** Writes an object. Answers the new head. */
     put(key: string, body: StorageBody, options?: StoragePutOptions): Promise<StorageObjectHead>;
-    /** Lakebed's `get`; `range` reads part of a large object. `null` when absent or expired. */
+    /** Reads an object; `range` reads part of a large object. `null` when absent or expired. */
     get(key: string, range?: {
         offset?: number;
         length?: number;
@@ -899,7 +921,7 @@ export interface StorageArea {
         ifMatch?: string;
     }): Promise<void>;
     /**
-     * Lakebed's `list`: keys starting with `prefix`, in byte order, at most
+     * Lists keys starting with `prefix`, in byte order, at most
      * `maxObjects` (1000). For the next page, pass the last key as `after`.
      */
     list(prefix?: string, options?: {
@@ -914,6 +936,189 @@ export interface StorageArea {
     putJSON(key: string, value: JsonInput, options?: Omit<StoragePutOptions, "contentType">): Promise<StorageObjectHead>;
     writer(key: string, options?: StoragePutOptions): Promise<StorageWriter>;
 }
+/** Milliseconds, or text such as `"500ms"`, `"30s"`, `"15m"`, `"6h"`, `"30d"`. */
+export type ComputeDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d"}`;
+/** `[since, until)` in ms; `until` defaults to the call's time. */
+export type ComputeWindow = {
+    readonly since: number;
+    readonly until?: number;
+} | {
+    readonly last: ComputeDuration;
+    readonly until?: number;
+};
+/** Fields of a trade a filter or a measure reads. */
+export type ComputeField = "side" | "protocol" | "token" | "trader" | "quoteMint" | "timeMs" | "ageMs" | "quoteRaw" | "tokenRaw" | "quoteAmount" | "tokenAmount" | "execPrice" | "isCreator" | "marketFlags" | "orderFlags";
+/** Fields measured by `sum`, `min`, `max`, `avg`, `first`, `last`, `anchor`, `asOf`. */
+export type ComputeNumericField = "timeMs" | "ageMs" | "quoteRaw" | "tokenRaw" | "quoteAmount" | "tokenAmount" | "execPrice";
+type ComputeValue = string | number | boolean;
+/** A comparison of one field: a value (equality), or operators (all must hold). */
+export type ComputeCondition = ComputeValue | {
+    readonly eq?: ComputeValue;
+    readonly ne?: ComputeValue;
+    readonly gt?: number | string;
+    readonly gte?: number | string;
+    readonly lt?: number | string;
+    readonly lte?: number | string;
+    readonly in?: readonly ComputeValue[];
+    readonly notIn?: readonly ComputeValue[];
+    /** Flag fields (`marketFlags`, `orderFlags`): bits of the mask set. */
+    readonly hasAll?: number;
+    readonly hasAny?: number;
+    readonly hasNone?: number;
+};
+/**
+ * A filter: every field listed must pass (`and`), with `and`, `or`, `not`
+ * to combine. In `where`, the fields of a trade (and `"<stage>.<measure>"`);
+ * in `having`, the measures and keys of a group. A comparison with an
+ * unknown value (no trader, a creation not seen, a missing stage value) is
+ * false, `ne` and `notIn` included.
+ */
+export interface ComputeFilter {
+    readonly and?: readonly ComputeFilter[];
+    readonly or?: readonly ComputeFilter[];
+    readonly not?: ComputeFilter;
+    readonly [field: string]: ComputeCondition | ComputeFilter | readonly ComputeFilter[] | undefined;
+}
+export type ComputeKey = "token" | "trader" | "quoteMint" | "side" | "protocol"
+/** `floor(timeMs / width) * width`. */
+ | {
+    readonly time: ComputeDuration;
+}
+/** `floor(ageMs / width) * width` (tokens whose creation is known). */
+ | {
+    readonly age: ComputeDuration;
+};
+type MeasureOptions = {
+    /** Only the trades that pass it. */
+    readonly where?: ComputeFilter;
+    /** Plans with `anchors`: the token's trades in `[anchor + from, anchor + to)` ms. */
+    readonly window?: readonly [number, number];
+};
+export type ComputeMeasure = ({
+    readonly count: true;
+} & MeasureOptions) | ({
+    readonly countDistinct: "token" | "trader" | "quoteMint";
+} & MeasureOptions) | ({
+    readonly sum: ComputeNumericField;
+} & MeasureOptions) | ({
+    readonly min: ComputeNumericField;
+} & MeasureOptions) | ({
+    readonly max: ComputeNumericField;
+} & MeasureOptions) | ({
+    readonly avg: ComputeNumericField;
+} & MeasureOptions)
+/** In the token's trade sequence (see the docs). */
+ | ({
+    readonly first: ComputeNumericField;
+} & MeasureOptions) | ({
+    readonly last: ComputeNumericField;
+} & MeasureOptions)
+/** `Number(a) / Number(b)` of two other measures. */
+ | {
+    readonly ratio: readonly [string, string];
+}
+/** Plans with `anchors`: a field of the anchor trade. */
+ | {
+    readonly anchor: ComputeNumericField;
+}
+/**
+ * Plans with `anchors`: `field` of the token's trade as of `anchor +
+ * offsetMs` (the last at or before it; with `direction: "after"`, the
+ * first at or after it), within `withinMs` (default and at most 1 h). An
+ * array of offsets gives one column each, `"<name>@<offset>"`.
+ */
+ | ({
+    readonly asOf: ComputeNumericField;
+    readonly offsetMs: number | readonly number[];
+    readonly direction?: "before" | "after";
+    readonly withinMs?: number;
+} & Omit<MeasureOptions, "window">);
+export interface ComputePlan {
+    readonly range: ComputeWindow;
+    /** Only these mints (1 to 10 000). */
+    readonly tokens?: readonly Address[];
+    /** Only the tokens created in this window (creations seen in its hours). */
+    readonly created?: ComputeWindow;
+    /** `"SOL"` (default), a quote mint, `"auto"` (per token, as `tokenTotals`) or `"any"`. */
+    readonly quote?: "SOL" | "auto" | "any" | Address;
+    readonly where?: ComputeFilter;
+    readonly groupBy?: readonly ComputeKey[];
+    /** 1 to 16 named measures; results list them in name order. */
+    readonly measures: Readonly<Record<string, ComputeMeasure>>;
+    readonly having?: ComputeFilter;
+    /** The `n` groups with the largest `by`, per partition of the `per` keys. */
+    readonly top?: {
+        readonly by: string;
+        readonly n: number;
+        readonly per?: readonly string[];
+    };
+    readonly orderBy?: readonly (string | {
+        readonly by: string;
+        readonly desc?: boolean;
+    })[];
+    readonly limit?: number;
+    /** Accept a window not fully covered, or rejected operations. */
+    readonly allowPartial?: boolean;
+    /** Stages: measures per token, read in `where` as `"<stage>.<measure>"`. */
+    readonly with?: Readonly<Record<string, {
+        readonly where?: ComputeFilter;
+        readonly measures: Readonly<Record<string, ComputeMeasure>>;
+        readonly having?: ComputeFilter;
+    }>>;
+    /**
+     * One row per anchor: the first trade, in its token's sequence, of each
+     * group of `by` (with `token`) that passes `where`. Measures then read it
+     * (`anchor`) and its token's trades around it (`asOf`, `window`).
+     */
+    readonly anchors?: {
+        readonly by: readonly ComputeKey[];
+        readonly where?: ComputeFilter;
+        readonly pick?: "first";
+    };
+}
+/** A column of a result: addresses and names, numbers, or exact integers. */
+export type ComputeColumn = readonly (string | null)[] | Float64Array | readonly (bigint | null)[];
+export interface ComputeStats {
+    readonly hours: number;
+    readonly derivedHours: number;
+    readonly sealedHours: number;
+    readonly openHours: number;
+    readonly passes: number;
+    readonly trades: number;
+    readonly groups: number;
+    /** Server time of the call, every thread (the history reading; not your CPU). */
+    readonly cpuMs: number;
+    readonly wallMs: number;
+}
+interface ComputeSummary {
+    readonly length: number;
+    /** Key columns, in `groupBy` order. */
+    readonly keys: readonly string[];
+    /** Measure columns, in name order. */
+    readonly measures: readonly string[];
+    readonly coverage: Json;
+    /** Covered, and no rejected operation counted. */
+    readonly complete: boolean;
+    /** Operations of the tokens read that normalization rejects, in the range. */
+    readonly skipped: number;
+    readonly stats: ComputeStats;
+}
+export interface ComputeResult extends ComputeSummary {
+    /** One column per key and measure, `length` values each. */
+    readonly columns: Readonly<Record<string, ComputeColumn>>;
+}
+/** A result written to storage (`output`): JSON lines, one object per row. */
+export interface ComputeOutput extends ComputeSummary {
+    readonly output: {
+        readonly area: "short" | "long" | "durable";
+        readonly key: string;
+        readonly rows: number;
+        readonly bytes: number;
+        readonly etag: string;
+    };
+}
+/** The rows of a result as objects (keys and measures by name). */
+export declare function computeRows(r: ComputeResult): Record<string, string | number | bigint | null>[];
 export interface Context {
     readonly execution: ExecutionInfo;
     readonly data: {
@@ -924,16 +1129,26 @@ export interface Context {
         walletTrades(wallet: Address, query: TradeQuery): AsyncIterable<HourBatch>;
         /** Trades of a token, one hour per batch, oldest first. */
         tokenTrades(mint: Address, query: TradeQuery): AsyncIterable<HourBatch>;
-        /** Same JSON as `/v1/tokens/{mint}/totals` (with `metadata`). */
+        /**
+         * Volume of a token since its creation (`cumulativeRaw`, `buyRaw`,
+         * `sellRaw`, `buys`, `sells`, `sinceCreation.complete`, `coverage`), its
+         * `creation` and `metadata`, as JSON. Amounts are in `quoteMint` at
+         * `quoteDecimals`; without `quote`: SOL; `quote: "auto"`: SOL unless the
+         * token trades in other quotes only (then its most traded one; `quotes`
+         * lists them all).
+         */
         tokenTotals(mint: Address, options?: {
-            quote?: Address;
+            quote?: Address | "auto";
         }): Promise<Json>;
         /**
-         * Same JSON as `/v1/tokens/{mint}/info`: latest known metadata and the
-         * creation, at most two blocks read (no volumes).
+         * Latest known metadata and the creation, at most two blocks read (no
+         * volumes).
          */
         tokenInfo(mint: Address): Promise<TokenInfo>;
-        /** Pages of `/v1/volume/search`, in its JSON shape. */
+        /**
+         * Tokens ranked by volume over a window, page by page (`items` of
+         * `{mint, volume, buyVolume, sellVolume, buys, sells, volumeRaw}`).
+         */
         volumeSearch(params: VolumeSearchParams): AsyncIterable<Json>;
     };
     /** Private JSON state of the program, kept between executions. */
@@ -967,6 +1182,22 @@ export interface Context {
      * after the last write), `long` (500 MiB, 7 days after the last write) and
      * `durable` (50 MiB, never expires).
      */
+    /**
+     * Runs a plan (or up to 8 plans over one read) natively over the
+     * history: answers columns, or with `output` writes the rows to storage
+     * as JSON lines and answers a summary. Errors: `invalid_plan`,
+     * `invalid_window`, `partial_coverage`, `compute_result_limit`,
+     * `compute_memory_limit`, `compute_limit`, `compute_overflow`, and those of
+     * history reads.
+     */
+    compute(plan: ComputePlan): Promise<ComputeResult>;
+    compute(plans: readonly ComputePlan[]): Promise<ComputeResult[]>;
+    compute(plan: ComputePlan, options: {
+        readonly output: {
+            readonly area: "short" | "long" | "durable";
+            readonly key: string;
+        };
+    }): Promise<ComputeOutput>;
     readonly storage: {
         readonly short: StorageArea;
         readonly long: StorageArea;
@@ -1047,7 +1278,7 @@ export declare function parseTradeId(id: string): TradeKey;
 export declare function compareTradeIds(a: string, b: string): number;
 /**
  * Id of a live-feed operation, in the {@link tradeId} format (`operation.id`
- * as delivered by funrun, else `order.ord`); `null` without order.
+ * as delivered to subscriptions, else `order.ord`); `null` without order.
  */
 export declare function operationTradeId(operation: MarketOperation): string | null;
 /**
@@ -1115,9 +1346,9 @@ export declare function tradeAt(batch: HourBatch, i: number): Trade;
  * `error.code`; `message` is for humans and may change.
  */
 export type SdkErrorCode = "invalid_window" | "partial_coverage" | "history_preparing" | "storage_busy" | "history_unavailable" | "read_limit" | "read_time_limit" | "invalid_argument" | "unknown_function" | "execution_not_found" | "state_value_too_large" | "state_limit" | "children_limit" | "subscription_limit" | "price_subscription_limit" | "output_limit" | StorageErrorCode | (string & {});
-/** Lakebed's `StorageErrorCode`, plus `already_exists`, `value_changed`, `io_limit`, `upload_limit`, `precondition_failed`. */
+/** Error codes of user storage (`ctx.storage` and the HTTP storage routes). */
 export type StorageErrorCode = "quota_exceeded" | "too_large" | "not_found" | "invalid_request" | "forbidden" | "unavailable" | "blocked_type" | "already_exists" | "value_changed" | "io_limit" | "upload_limit" | "precondition_failed";
-/** HTTP status of each storage code (Lakebed's for its seven). */
+/** HTTP status of each storage code. */
 export declare const STORAGE_STATUS_BY_CODE: Readonly<Record<StorageErrorCode, number>>;
 /** Error thrown by a `ctx` call. `retryAfterMs` comes with `storage_busy`/`history_preparing`. */
 export interface SdkError extends Error {

package/dist/sdk.js

@@ -47,6 +47,8 @@ export const MarketFlag = {
     mayhem: 128,
     feeWithoutToken: 256,
     invertedPool: 512,
+    virtualTokenReserve: 1024,
+    virtualQuoteReserve: 2048,
 };
 export function isFinal(result) {
     return result.status !== "queued" && result.status !== "running";
@@ -71,6 +73,18 @@ export function isCompletion(args) {
         args.kind === "completion" &&
         typeof args.executionId === "string");
 }
+export function computeRows(r) {
+    const names = [...r.keys, ...r.measures];
+    const out = [];
+    for (let i = 0; i < r.length; i++) {
+        const row = {};
+        for (const n of names)
+            row[n] =
+                r.columns[n][i] ?? null;
+        out.push(row);
+    }
+    return out;
+}
 export const SDK_MARKER = "__zyrkSdk";
 export const SDK_VERSION = "0.2";
 export function defineProgram(program) {

package/dist/stream.d.ts

@@ -15,18 +15,66 @@ export interface StreamOptions {
     readonly apiKey: string;
     /** Resume after this sequence number. */
     readonly afterSeq?: number;
+    /**
+     * How long the server must keep refusing the key, with no successful join
+     * in between, before the stream ends with `invalid_key` (or `unauthorized`).
+     * Default 360 000 ms (6 min). See {@link executionEvents}: below the
+     * server's longest key sync delay, a key created just before the stream
+     * started could end it.
+     */
+    readonly keyRefusalWindowMs?: number;
 }
 /**
- * Live execution events of the account. Gaps are emitted as values; the
- * stream fails on undecodable payloads or when the server refuses the join.
- * The socket is closed when the stream is interrupted or ends.
+ * Live execution events of the account. Gaps are emitted as values.
+ *
+ * The stream reconnects by itself after a dropped or closed connection (no
+ * network, a server restart or deploy, a connection the server closed) and
+ * resumes after the last event. It fails, once, with:
+ * - a {@link DecodeError} on an undecodable payload;
+ * - a {@link NetworkError} when the server refuses the join, with the
+ *   server's `reason` (`functions_disabled`, `functions_unavailable`);
+ * - a {@link NetworkError} whose `reason` is `functions_disabled` (Functions
+ *   access removed) or `channel_closed` (the server closed the channel:
+ *   subscribe again with `afterSeq`);
+ * - a {@link NetworkError} whose `reason` is `invalid_key` (the key was
+ *   revoked, replaced or is unknown, or its account is not active) or
+ *   `unauthorized` (the same, seen at the join): the server kept refusing
+ *   the key for {@link StreamOptions.keyRefusalWindowMs} (default 6 min)
+ *   with no successful join in between. A single refusal never ends the
+ *   stream: a key created or changed less than a key sync ago, or a server
+ *   whose key data is briefly behind, is refused too; the stream retries
+ *   (every 5 s at most) and goes on as soon as a join succeeds. A refusal
+ *   that the server does not name (a server starting, a network failure,
+ *   the connection limit) is retried with no time limit;
+ * - a {@link NetworkError} whose `reason` is `account_changed`: a
+ *   reconnection joined another account than the first join (the key was
+ *   moved to another account). No event of the other account is delivered.
+ *   This check needs a server that names the account in its join reply: a
+ *   join answered without `account` (an older server, e.g. during a rollout
+ *   or rollback) is accepted unchecked.
+ *
+ * A transient `status` `{available: false}` does not end it. An older
+ * server that does not say why it refused a connection gives no
+ * `invalid_key`: the stream then keeps reconnecting, as before. The socket
+ * is closed and no reconnection happens once the stream is interrupted or
+ * has failed.
  */
 export declare const executionEvents: (options: StreamOptions) => Stream.Stream<FunctionsMessage, StreamError>;
-/** Callback API kept for existing users; errors are tagged `StreamError`s or raw socket errors. */
+/**
+ * Callback API kept for existing users; errors are tagged `StreamError`s or
+ * raw socket errors (transient: it reconnects by itself). While the server
+ * refuses the key (see {@link executionEvents}) nothing is reported: it
+ * retries silently, and reports once if the refusal lasts the whole window.
+ * After a `NetworkError` (`functions_disabled`, `functions_unavailable`,
+ * `channel_closed`, `invalid_key`, `unauthorized`, `account_changed`) the
+ * socket is closed and nothing more arrives.
+ */
 export declare function subscribeFunctions(options: {
     url: string;
     apiKey: string;
     afterSeq?: number;
+    /** See {@link StreamOptions.keyRefusalWindowMs}. */
+    keyRefusalWindowMs?: number;
     onEvent: (event: ExecutionEvent) => void;
     onGap?: (gap: Gap) => void;
     onError?: (error: unknown) => void;