@canister-software/consensus-cli 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/socket-client.js

@@ -0,0 +1,440 @@
+const DEFAULT_SERVER_URL = process.env.CONSENSUS_SERVER_URL || "https://consensus.canister.software";
+const USD_SCALE = 1_000_000;
+const PRICING_PRESETS = {
+    TIME: {
+        model: "time",
+        pricePerMinute: 0.001,
+        pricePerMB: 0,
+    },
+    DATA: {
+        model: "data",
+        pricePerMinute: 0,
+        pricePerMB: 0.00012,
+    },
+    HYBRID: {
+        model: "hybrid",
+        pricePerMinute: 0.0005,
+        pricePerMB: 0.0001,
+    },
+};
+class SocketClientError extends Error {
+    /** HTTP status from token endpoint when available. */
+    status;
+    /** Parsed server error payload when available. */
+    data;
+}
+/** Thrown when requested token cost exceeds remaining websocket budget. */
+class SocketBudgetLimitError extends SocketClientError {
+}
+function trimTrailingSlash(value) {
+    return String(value || "").replace(/\/+$/, "");
+}
+function parseMaybeJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function parseUsdToMicros(value, fieldName) {
+    if (typeof value === "undefined" || value === null)
+        return null;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${fieldName} must be a non-negative number`);
+    }
+    const micros = Math.round(value * USD_SCALE);
+    const normalized = micros / USD_SCALE;
+    if (Math.abs(normalized - value) > 1e-9) {
+        throw new TypeError(`${fieldName} supports at most 6 decimal places`);
+    }
+    return micros;
+}
+function microsToUsd(micros) {
+    return Number((micros / USD_SCALE).toFixed(6));
+}
+function calculateSessionCost(pricing, minutes, megabytes) {
+    let cost = 0;
+    if (pricing.model === "time" || pricing.model === "hybrid") {
+        cost += (minutes || 0) * pricing.pricePerMinute;
+    }
+    if (pricing.model === "data" || pricing.model === "hybrid") {
+        cost += (megabytes || 0) * pricing.pricePerMB;
+    }
+    return cost;
+}
+function normalizeTokenParams(defaults, params) {
+    const merged = {
+        model: params?.model ?? defaults?.model ?? "hybrid",
+        minutes: params?.minutes ?? defaults?.minutes ?? 5,
+        megabytes: params?.megabytes ?? defaults?.megabytes ?? 50,
+        nodeRegion: params?.nodeRegion ?? defaults?.nodeRegion,
+        nodeDomain: params?.nodeDomain ?? defaults?.nodeDomain,
+        nodeExclude: params?.nodeExclude ?? defaults?.nodeExclude,
+    };
+    if (!["hybrid", "time", "data"].includes(merged.model)) {
+        throw new SocketClientError(`Invalid model '${String(merged.model)}'`);
+    }
+    if (!Number.isInteger(merged.minutes) || merged.minutes < 0) {
+        throw new SocketClientError("minutes must be a non-negative integer");
+    }
+    if (!Number.isInteger(merged.megabytes) || merged.megabytes < 0) {
+        throw new SocketClientError("megabytes must be a non-negative integer");
+    }
+    return merged;
+}
+function toTokenHeaders(params) {
+    const headers = {};
+    if (params?.nodeRegion)
+        headers["x-node-region"] = params.nodeRegion;
+    if (params?.nodeDomain)
+        headers["x-node-domain"] = params.nodeDomain;
+    if (params?.nodeExclude)
+        headers["x-node-exclude"] = params.nodeExclude;
+    return headers;
+}
+async function resolveWebSocketFactory(factory) {
+    if (factory)
+        return factory;
+    if (typeof WebSocket !== "undefined")
+        return WebSocket;
+    const wsModule = await import("ws");
+    const maybeCtor = wsModule.default ||
+        wsModule.WebSocket;
+    if (typeof maybeCtor !== "function") {
+        throw new SocketClientError("Unable to resolve a WebSocket constructor");
+    }
+    return maybeCtor;
+}
+function addListener(socket, event, handler) {
+    if (typeof socket.addEventListener === "function") {
+        socket.addEventListener(event, handler);
+        return;
+    }
+    if (typeof socket.on === "function") {
+        socket.on(event, handler);
+    }
+}
+function removeListener(socket, event, handler) {
+    if (typeof socket.removeEventListener === "function") {
+        socket.removeEventListener(event, handler);
+        return;
+    }
+    if (typeof socket.off === "function") {
+        socket.off(event, handler);
+        return;
+    }
+    if (typeof socket.removeListener === "function") {
+        socket.removeListener(event, handler);
+    }
+}
+function getOpenStateValue(socket) {
+    const maybeCtor = socket;
+    const open = maybeCtor.constructor?.OPEN;
+    return typeof open === "number" ? open : 1;
+}
+function getMessagePayload(value) {
+    if (value && typeof value === "object" && "data" in value) {
+        return value.data;
+    }
+    return value;
+}
+function toSafeResult(promise) {
+    return promise
+        .then((data) => ({ ok: true, data }))
+        .catch((error) => ({ ok: false, error }));
+}
+export function SocketClient(fetchWithPayment, options = {}) {
+    if (typeof fetchWithPayment !== "function") {
+        throw new TypeError("SocketClient requires fetchWithPayment as the first argument");
+    }
+    const baseUrl = trimTrailingSlash(DEFAULT_SERVER_URL);
+    const openTimeoutMs = options.openTimeoutMs ?? 12_000;
+    const reconnectIntervalMs = options.reconnectIntervalMs ?? 2_000;
+    const limitMicros = parseUsdToMicros(options.limit_usd, "limit_usd");
+    let lastTokenParams;
+    let spentMicros = 0;
+    let limitCallbackFired = false;
+    let lastQuoteMicros = 0;
+    function computeStandDownState(nextCostMicros = 0) {
+        if (limitMicros === null)
+            return false;
+        if (spentMicros >= limitMicros)
+            return true;
+        return spentMicros + nextCostMicros > limitMicros;
+    }
+    function getBudget() {
+        const remainingMicros = limitMicros === null ? null : Math.max(0, limitMicros - spentMicros);
+        return {
+            limit_usd: limitMicros === null ? null : microsToUsd(limitMicros),
+            spent_usd: microsToUsd(spentMicros),
+            remaining_usd: remainingMicros === null ? null : microsToUsd(remainingMicros),
+            exhausted: computeStandDownState(),
+            last_quote_usd: microsToUsd(lastQuoteMicros),
+        };
+    }
+    function isStandDown() {
+        const exhausted = computeStandDownState();
+        if (exhausted &&
+            !limitCallbackFired &&
+            typeof options.on_limit_reached === "function") {
+            limitCallbackFired = true;
+            options.on_limit_reached(getBudget());
+        }
+        return exhausted;
+    }
+    function ensureBudgetFor(quotedCostMicros) {
+        if (!computeStandDownState(quotedCostMicros))
+            return;
+        isStandDown();
+        throw new SocketBudgetLimitError("WebSocket budget limit reached; token request blocked");
+    }
+    function incrementSpend(quotedCostMicros) {
+        if (quotedCostMicros <= 0)
+            return;
+        spentMicros += quotedCostMicros;
+        if (limitMicros !== null && spentMicros > limitMicros)
+            spentMicros = limitMicros;
+        isStandDown();
+    }
+    function resetBudget() {
+        spentMicros = 0;
+        limitCallbackFired = false;
+        lastQuoteMicros = 0;
+    }
+    function quoteTokenCostMicros(params) {
+        const pricingKey = params.model === "time" ? "TIME" : params.model === "data" ? "DATA" : "HYBRID";
+        const pricing = PRICING_PRESETS[pricingKey];
+        const usd = calculateSessionCost(pricing, params.minutes, params.megabytes);
+        return parseUsdToMicros(usd, "session_cost_usd") ?? 0;
+    }
+    async function requestTokenInternal(params) {
+        const normalized = normalizeTokenParams(options.defaults, params);
+        lastTokenParams = normalized;
+        const quotedCostMicros = quoteTokenCostMicros({
+            model: normalized.model,
+            minutes: normalized.minutes,
+            megabytes: normalized.megabytes,
+        });
+        lastQuoteMicros = quotedCostMicros;
+        ensureBudgetFor(quotedCostMicros);
+        const query = new URLSearchParams({
+            model: normalized.model,
+            minutes: String(normalized.minutes),
+            megabytes: String(normalized.megabytes),
+        });
+        const response = await fetchWithPayment(`${baseUrl}/ws?${query.toString()}`, {
+            method: "GET",
+            headers: toTokenHeaders(normalized),
+        });
+        const raw = await response.text();
+        const parsed = parseMaybeJson(raw);
+        if (!response.ok) {
+            const message = parsed?.message ||
+                parsed?.error ||
+                `WebSocket token request failed (${response.status})`;
+            const error = new SocketClientError(message);
+            error.status = response.status;
+            error.data = parsed;
+            throw error;
+        }
+        const auth = parsed;
+        if (!auth?.connect_url || !auth?.token) {
+            throw new SocketClientError("Invalid token response: missing token/connect_url");
+        }
+        incrementSpend(quotedCostMicros);
+        return {
+            token: String(auth.token),
+            connect_url: String(auth.connect_url),
+            expires_in: Number(auth.expires_in ?? 0),
+        };
+    }
+    async function requestToken(params, safeOptions) {
+        const task = requestTokenInternal(params);
+        if (safeOptions?.safe)
+            return toSafeResult(task);
+        return task;
+    }
+    async function connectInternal(connectUrlOrAuth, callbacks) {
+        const initialConnectUrl = typeof connectUrlOrAuth === "string"
+            ? connectUrlOrAuth
+            : connectUrlOrAuth?.connect_url;
+        if (!initialConnectUrl) {
+            throw new SocketClientError("connect requires connect_url");
+        }
+        const listeners = {
+            open: new Set(),
+            message: new Set(),
+            close: new Set(),
+            error: new Set(),
+        };
+        const state = {
+            connected: false,
+            reconnecting: false,
+            closedByCaller: false,
+        };
+        let currentConnectUrl = initialConnectUrl;
+        let reconnectTimer = null;
+        let activeSocket = null;
+        const socketFactory = await resolveWebSocketFactory(options.webSocketFactory);
+        const connectHeaders = toTokenHeaders(lastTokenParams ?? options.defaults);
+        const emit = (event, ...args) => {
+            for (const handler of listeners[event]) {
+                handler(...args);
+            }
+        };
+        const clearReconnectTimer = () => {
+            if (!reconnectTimer)
+                return;
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        };
+        const waitForOpen = (socket) => new Promise((resolve, reject) => {
+            let timeout = null;
+            const cleanup = () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                removeListener(socket, "open", onOpen);
+                removeListener(socket, "error", onError);
+                removeListener(socket, "close", onClose);
+            };
+            const onOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new SocketClientError("Socket closed before opening"));
+            };
+            addListener(socket, "open", onOpen);
+            addListener(socket, "error", onError);
+            addListener(socket, "close", onClose);
+            timeout = setTimeout(() => {
+                cleanup();
+                reject(new SocketClientError("Socket open timeout"));
+            }, openTimeoutMs);
+        });
+        const openSocket = async () => {
+            let socketInstance;
+            try {
+                socketInstance = new socketFactory(currentConnectUrl, { headers: connectHeaders });
+            }
+            catch {
+                socketInstance = new socketFactory(currentConnectUrl);
+            }
+            addListener(socketInstance, "open", () => {
+                state.connected = true;
+                state.reconnecting = false;
+                callbacks?.onOpen?.();
+                emit("open");
+            });
+            addListener(socketInstance, "message", (event) => {
+                const payload = getMessagePayload(event);
+                callbacks?.onMessage?.(payload);
+                emit("message", payload);
+            });
+            addListener(socketInstance, "error", (error) => {
+                callbacks?.onError?.(error);
+                emit("error", error);
+            });
+            addListener(socketInstance, "close", (event) => {
+                state.connected = false;
+                callbacks?.onClose?.(event);
+                emit("close", event);
+                if (state.closedByCaller)
+                    return;
+                clearReconnectTimer();
+                reconnectTimer = setTimeout(async () => {
+                    if (state.closedByCaller)
+                        return;
+                    state.reconnecting = true;
+                    try {
+                        if (lastTokenParams) {
+                            const auth = await requestTokenInternal(lastTokenParams);
+                            currentConnectUrl = auth.connect_url;
+                        }
+                        await openSocket();
+                    }
+                    catch (error) {
+                        callbacks?.onError?.(error);
+                        emit("error", error);
+                        if (error instanceof SocketBudgetLimitError) {
+                            state.reconnecting = false;
+                            return;
+                        }
+                        if (!state.closedByCaller) {
+                            reconnectTimer = setTimeout(async () => {
+                                if (!state.closedByCaller) {
+                                    state.reconnecting = true;
+                                    try {
+                                        if (lastTokenParams) {
+                                            const auth = await requestTokenInternal(lastTokenParams);
+                                            currentConnectUrl = auth.connect_url;
+                                        }
+                                        await openSocket();
+                                    }
+                                    catch (retryError) {
+                                        callbacks?.onError?.(retryError);
+                                        emit("error", retryError);
+                                        if (retryError instanceof SocketBudgetLimitError) {
+                                            state.reconnecting = false;
+                                        }
+                                    }
+                                }
+                            }, reconnectIntervalMs);
+                        }
+                    }
+                }, reconnectIntervalMs);
+            });
+            activeSocket = socketInstance;
+            await waitForOpen(socketInstance);
+        };
+        await openSocket();
+        return {
+            send(data) {
+                if (!activeSocket) {
+                    throw new SocketClientError("No active socket session");
+                }
+                const openState = getOpenStateValue(activeSocket);
+                if (activeSocket.readyState !== openState) {
+                    throw new SocketClientError("Socket is not open");
+                }
+                activeSocket.send(data);
+            },
+            close(code, reason) {
+                state.closedByCaller = true;
+                state.reconnecting = false;
+                clearReconnectTimer();
+                activeSocket?.close(code, reason);
+            },
+            on(event, handler) {
+                listeners[event].add(handler);
+            },
+            off(event, handler) {
+                listeners[event].delete(handler);
+            },
+            getState() {
+                return { ...state };
+            },
+        };
+    }
+    async function connect(connectUrlOrAuth, callbacks, safeOptions) {
+        const task = connectInternal(connectUrlOrAuth, callbacks);
+        if (safeOptions?.safe)
+            return toSafeResult(task);
+        return task;
+    }
+    return {
+        requestToken,
+        connect,
+        getBudget,
+        resetBudget,
+        isStandDown,
+    };
+}

package/index.d.ts

@@ -0,0 +1,271 @@
+export interface ProxyClientOptions {
+  /**
+   * Route filtering behavior for inbound server paths.
+   * - "inclusive": proxy everything except `routes`
+   * - "exclusive": proxy only `routes`
+   */
+  mode?: "inclusive" | "exclusive";
+  /**
+   * Path rules used with `mode`, for example `["/health", "/metrics"]`.
+   * Query params are ignored; matching is based on path only.
+   */
+  routes?: string[];
+  /**
+   * Path matcher behavior for `routes`.
+   * - false (default): exact path only (`/route` does not match `/route/subroute`)
+   * - true: include subroutes (`/route` matches `/route/*`)
+   */
+  matchSubroutes?: boolean;
+  /**
+   * Interception strategy.
+   * - "auto": globally intercepts `fetch` for route-matched request scope
+   * - "manual": does not intercept global `fetch`; use `req.consensus.fetch` / `request`
+   */
+  strategy?: "auto" | "manual";
+  /**
+   * Cache time-to-live in seconds for proxy responses.
+   * Sent as `x-cache-ttl`; controls how long deduped responses can be reused.
+   */
+  cache_ttl?: number;
+  /**
+   * Enables verbose proxy response payload.
+   * When true, proxy responses include `meta` with fields like:
+   * `cached`, `dedupe_key`, `processing_ms`, and `timestamp`.
+   */
+  verbose?: boolean;
+  /**
+   * Preferred proxy region, for example `"us-east"`.
+   * Sent as `x-node-region`.
+   */
+  node_region?: string;
+  /**
+   * Force routing through a specific node domain, for example:
+   * `"nodexyz.consensus.canister.software"`.
+   * Sent as `x-node-domain`.
+   */
+  node_domain?: string;
+  /**
+   * Exclude a specific node/domain from routing.
+   * Sent as `x-node-exclude`.
+   */
+  node_exclude?: string;
+  /**
+   * Max proxy spend in USD (up to 6 decimals).
+   * Once exhausted, ProxyClient stands down and uses direct fetch.
+   */
+  limit_usd?: number;
+  /** Called once when proxy budget is exhausted and stand-down activates. */
+  on_limit_reached?: (budget: ProxyBudgetSnapshot) => void;
+}
+
+export interface ProxyBudgetSnapshot {
+  /** Configured max spend in USD, or null when no limit is configured. */
+  limit_usd: number | null;
+  /** Fixed server proxy charge per paid request. */
+  request_cost_usd: number;
+  /** Total spent so far in USD. */
+  spent_usd: number;
+  /** Remaining budget in USD, or null when unlimited. */
+  remaining_usd: number | null;
+  /** True when budget guard has disabled further proxying. */
+  exhausted: boolean;
+}
+
+export interface ProxyResponseShape {
+  /** HTTP status code returned by proxy response. */
+  status: number;
+  /** HTTP reason phrase from proxy response. */
+  statusText: string;
+  /** Response headers from the target/proxy response. */
+  headers: Record<string, string>;
+  /** Parsed payload body (JSON/object/string) returned by proxy. */
+  data: unknown;
+  /**
+   * Verbose metadata returned when `verbose` is enabled.
+   * Common fields:
+   * - `cached`: whether response came from proxy cache
+   * - `dedupe_key`: deduplication key used by proxy
+   * - `processing_ms`: end-to-end proxy processing duration
+   * - `timestamp`: ISO timestamp generated by proxy
+   */
+  meta: {
+    cached?: boolean;
+    dedupe_key?: string;
+    processing_ms?: number;
+    timestamp?: string;
+    [key: string]: unknown;
+  } | null;
+}
+
+export interface ProxyClientRequestContext {
+  consensus?: {
+    strategy?: "auto" | "manual";
+    shouldProxy?: boolean;
+    fetch?: (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+      perRequestOptions?: Partial<ProxyClientOptions>
+    ) => Promise<Response>;
+    request?: (
+      payload: {
+        target_url?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: unknown;
+      },
+      perRequestOptions?: Partial<ProxyClientOptions>
+    ) => Promise<ProxyResponseShape>;
+    passthroughFetch?: ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) | null;
+    createFetch?: (pathname?: string) => (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    getBudget?: () => ProxyBudgetSnapshot;
+    isStandDown?: () => boolean;
+  };
+  [key: string]: unknown;
+}
+
+export interface ProxyClientRuntime {
+  fetch(
+    input: RequestInfo | URL,
+    init?: RequestInit,
+    perRequestOptions?: Partial<ProxyClientOptions>
+  ): Promise<Response>;
+  request(
+    payload: {
+      target_url?: string;
+      method?: string;
+      headers?: Record<string, string>;
+      body?: unknown;
+    },
+    perRequestOptions?: Partial<ProxyClientOptions>
+  ): Promise<ProxyResponseShape>;
+  runWithPath<T>(pathname: string, run: () => T | Promise<T>): Promise<T>;
+  createFetch(pathname?: string): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  getBudget(): ProxyBudgetSnapshot;
+  resetBudget(): void;
+  isStandDown(): boolean;
+}
+
+export type ProxyClientMiddleware = ((
+  req: ProxyClientRequestContext,
+  res: unknown,
+  next: (err?: unknown) => void
+) => void) &
+  ProxyClientRuntime;
+
+export declare function ProxyClient(
+  fetchWithPayment: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>,
+  options?: ProxyClientOptions
+): ProxyClientMiddleware;
+
+export type ConsensusSocketModel = "hybrid" | "time" | "data";
+
+export interface ConsensusSocketTokenParams {
+  /** Billing model for session pricing. */
+  model?: ConsensusSocketModel;
+  /** Session duration to purchase (integer minutes, >= 0). */
+  minutes?: number;
+  /** Session data amount to purchase (integer MB, >= 0). */
+  megabytes?: number;
+  /** Optional preferred node region for token/session routing (e.g. `"us-east"`). */
+  nodeRegion?: string;
+  /** Optional hard route to a specific node domain (e.g. `"nodexyz.consensus.canister.software"`). */
+  nodeDomain?: string;
+  /** Optional node/domain to exclude from routing. */
+  nodeExclude?: string;
+}
+
+export interface ConsensusSocketTokenAuth {
+  token: string;
+  connect_url: string;
+  expires_in: number;
+}
+
+export interface ConsensusSocketConnectTarget {
+  connect_url: string;
+  token?: string;
+  expires_in?: number;
+}
+
+export interface ConsensusSocketCallbacks {
+  onOpen?: () => void;
+  onMessage?: (data: unknown) => void;
+  onClose?: (event?: unknown) => void;
+  onError?: (error: unknown) => void;
+}
+
+export interface ConsensusSocketSafeResult<T> {
+  ok: boolean;
+  data?: T;
+  error?: unknown;
+}
+
+export interface ConsensusSocketSessionState {
+  connected: boolean;
+  reconnecting: boolean;
+  closedByCaller: boolean;
+}
+
+export interface ConsensusSocketSession {
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+  close(code?: number, reason?: string): void;
+  on(event: "open" | "message" | "close" | "error", handler: (...args: unknown[]) => void): void;
+  off(event: "open" | "message" | "close" | "error", handler: (...args: unknown[]) => void): void;
+  getState(): ConsensusSocketSessionState;
+}
+
+export interface ConsensusSocketClientOptions {
+  /** Custom WebSocket constructor; auto-detected when omitted. */
+  webSocketFactory?: new (...args: unknown[]) => unknown;
+  /** Max time to wait for websocket open before failing (ms). */
+  openTimeoutMs?: number;
+  /** Fixed reconnect delay (ms). */
+  reconnectIntervalMs?: number;
+  /** Default token params merged into each requestToken call. */
+  defaults?: ConsensusSocketTokenParams;
+  /** Max websocket spend in USD (up to 6 decimals) before token requests are blocked. */
+  limit_usd?: number;
+  /** Called once when websocket budget is exhausted. */
+  on_limit_reached?: (budget: ConsensusSocketBudgetSnapshot) => void;
+}
+
+export interface ConsensusSocketBudgetSnapshot {
+  /** Configured max spend in USD, or null when no limit is configured. */
+  limit_usd: number | null;
+  /** Total spent so far in USD. */
+  spent_usd: number;
+  /** Remaining budget in USD, or null when unlimited. */
+  remaining_usd: number | null;
+  /** True when budget guard blocks further token purchases. */
+  exhausted: boolean;
+  /** Last locally quoted token/session price in USD. */
+  last_quote_usd: number;
+}
+
+export interface ConsensusSocketClient {
+  requestToken(
+    params?: ConsensusSocketTokenParams,
+    options?: { safe?: false }
+  ): Promise<ConsensusSocketTokenAuth>;
+  requestToken(
+    params: ConsensusSocketTokenParams | undefined,
+    options: { safe: true }
+  ): Promise<ConsensusSocketSafeResult<ConsensusSocketTokenAuth>>;
+  connect(
+    connectUrlOrAuth: string | ConsensusSocketConnectTarget,
+    callbacks?: ConsensusSocketCallbacks,
+    options?: { safe?: false }
+  ): Promise<ConsensusSocketSession>;
+  connect(
+    connectUrlOrAuth: string | ConsensusSocketConnectTarget,
+    callbacks: ConsensusSocketCallbacks | undefined,
+    options: { safe: true }
+  ): Promise<ConsensusSocketSafeResult<ConsensusSocketSession>>;
+  getBudget(): ConsensusSocketBudgetSnapshot;
+  resetBudget(): void;
+  isStandDown(): boolean;
+}
+
+export declare function SocketClient(
+  fetchWithPayment: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>,
+  options?: ConsensusSocketClientOptions
+): ConsensusSocketClient;