zk-credits 0.2.10 → 0.2.12

package/README.md

@@ -1,248 +1,119 @@
-> Release candidate `0.2.9` is prepared for owner publication. Registry commands
-> below apply after publication; the existing `0.2.8` lacks this flow.
-
 # zk-credits
 
-Loopback sidecar that attaches a hash-pinned BN254 Groth16 proof to each
-coding-agent LLM request through the experimental x402 `zk-prepaid` scheme.
-Built for the invite-only experimental Base Sepolia pilot. Product calls use
-founder-provisioned test credits and have no product payment step; the circuit
-is not independently audited. External research participants in slots A and C
-receive $25 for a 30-minute session regardless of setup success. That payment
-is not product revenue or willingness-to-pay evidence.
+API credits for Codex, Cline, and x402 agents. The local sidecar proves each
+spend and forwards your request to the gateway.
 
-```bash
-npm install --global zk-credits@0.2.9
-```
+Requires Node.js 20 or later. Runs on Base Sepolia.
 
-## Pinned pilot versions
+## Quick start
 
-The pilot supports exactly these versions. Do not substitute another, and do
-not mix versions between the sidecar, the adapter package, and the gateway:
+1. [Activate your credits](https://hazecredits.vercel.app) and download your activated credential.
+2. Install the package and configure a Base Sepolia RPC endpoint:
 
-| Package | Version |
-| --- | --- |
-| `zk-credits` (this sidecar) | `0.2.9` |
-| `@zk-credits/x402-zk-prepaid` (adapter) | `0.1.0` |
-| `@zk-credits/shared` | `0.1.0` |
-
-The pinned Base Sepolia trial version is `0.2.9`. It includes passwordless
-OS credential storage, the hash-pinned proving archive, public Base Sepolia RPC
-by default, a narrow Codex Responses bridge, and the request-aware x402 adapter.
-Setup validates the public chain witness and gateway-known root. No private
-GitHub repository access or recovery password is required for the new flow.
-
-Verify the shipped artifacts before your first prove. The package's
-`circuits/manifest.json` fixes the SHA-256 of the frozen
-`private_credit_spend.wasm`, `private_credit_spend.zkey`, and
-`verification_key_private_credit.json`; compute the digest of each delivered
-file and compare it to the manifest. A mismatch is a proof failure, and the
-sidecar refuses to prove rather than sending a payment. The founder compares
-the same digests against the delivered set before inviting you.
-
-## What one credit buys
-
-One credit buys one successfully committed response from the single service
-class `coding-deepseek-v4-flash-v1` (`deepseek/deepseek-v4-flash`). It is not
-an arbitrary API call, and the gateway enforces the class before it reserves
-the credit:
-
-- text messages, tool definitions, and tool calls, with one generated choice;
-- no provider streaming, images, files, audio, web search, model fallback,
-  client-selected routing, or unknown cost-affecting fields;
-- input capped at 128,000 UTF-8 byte units (counted conservatively, never below the
-  provider's token count), output at 4,000 tokens, request body at 256 KiB,
-  encrypted replay at 1 MiB, and upstream timeout at 120 seconds.
-
-The requested `model` field is ignored: the gateway always dispatches the
-class model, so an OpenAI-compatible client configured with any model name
-still receives the class. A rejected request consumes no credit.
-
-## First run
-
-1. Sign in at https://hazecredits.vercel.app and redeem your invite. Save and
-   reimport the passwordless recovery capsule, fund your pilot credential, then
-   download the activated credential. Anyone possessing these files can spend
-   their credits; keep them private.
-2. Import the activated file and validate setup:
-
-   ```bash
-   export ZK_CREDITS_CREDENTIAL_PATH="$HOME/Downloads/zk-credits-credential.json"
-   zk-credits setup codex
+   ```sh
+   npm install --global zk-credits
+   zk-credits config rpc
    ```
 
-   For your own x402 agent, use `zk-credits setup x402` instead. Setup installs
-   and verifies the packaged archive and artifact hashes, synchronizes public
-   Base events from the manifest-pinned bond and deployment block, and checks
-   the gateway-known root. Credentials enter OS secure storage: macOS Keychain,
-   Windows Credential Manager, or persistent Linux Secret Service. Storage
-   access approval may be needed; unavailable or denied storage fails closed.
-3. Review consent, choose your task, and run `zk-credits codex` or
-   `zk-credits x402-agent`. Subsequent launches use OS storage without a password
-   or import file. The activated download remains a private recovery backup.
-
-The RPC defaults to the launch endpoint baked into the package. If that endpoint is limited,
-run `zk-credits config rpc` and enter your own Base Sepolia endpoint in the hidden
-local prompt. Saved settings stay owner-only; `BASE_RPC_URL` takes precedence.
-Provider keys must not appear in chat or evidence. No gateway admin token is
-needed for operator setup.
-
-Existing encrypted exports require `zk-credits setup codex --legacy` (or
-`setup x402 --legacy`) and their original password in a hidden local prompt.
-A missing or altered proving artifact fails closed before payment creation.
-Setup and proving stay local; no supplied witness file is accepted for the
-manifest-pinned V2 deployment.
-
-The sidecar binds `127.0.0.1:3210` only. It does not modify `~/.cline` or
-`~/.codex`.
-
-## Supported route
-
-The pilot serves one bounded upstream spend path: non-streaming
-`POST /v1/chat/completions`, either through this sidecar or through an
-x402-native agent that explicitly registers the project `zk-prepaid` adapter.
-The sidecar also accepts Codex `POST /v1/responses` requests with text input
-and function tools, translates them to that bounded chat request, and converts
-the committed result into Responses SSE events. It rejects unsupported fields
-before starting a proof. Generic x402 clients, public facilitators, Bazaar,
-MCP, and the standard `exact` rail are unsupported; the sidecar never falls
-back to another rail.
-
-| Route | Auth | Purpose |
-| --- | --- | --- |
-| `GET /health` | none | Liveness for the local launcher |
-| `GET /v1/models` | local token | Codex model discovery |
-| `GET /metrics` | local token | Aggregate proof metrics (below) |
-| `POST /v1/chat/completions` | local token | The only proving and spend path |
-| `POST /v1/responses` | local token | Codex bridge to the bounded chat spend path |
-
-The chat route rejects streaming bodies (`stream`, `stream_options`) and a
-missing `model` with a `4xx` before any proof. The Responses route requires
-`stream: true`, text-only message/function-call input, and the known Codex
-metadata fields; it rejects images, unsupported tools, and unknown controls
-before any proof. Its upstream request is always `stream: false`. Anthropic
-`/v1/messages` and unknown paths return `404 unsupported_openai_path`. The
-sidecar never substitutes a model and never falls back to another rail.
-
-### Gateway responses and retries
-
-| Response | Meaning | What to do |
-| --- | --- | --- |
-| `402` | No usable authorization, or a stale or invalid one | Re-prove against the fresh challenge |
-| `409 claim_already_committed` | Your exact request already succeeded | Read `encryptedReplay` from the response, or fetch it from `POST /x402/replay`; do not re-prove |
-| `409 claim_commit_ambiguous` | The commit outcome is unknown | Retry the same request; never re-prove a different one |
-| `503 pilot_paused` | The operator paused the pilot | Wait. This is retryable, consumes no credit, and is not a proof failure |
-| `503 provider_spend_cap_exhausted` | The provider-spend cap paused the pilot | Wait for the operator to review. No credit was consumed |
-| `503 claim_store_unavailable` | Transient gateway fault | Retry with backoff |
-
-The gateway never asks you to re-prove for its own account. A `503` is
-retryable and free; a proof failure is local and never reaches the gateway.
-
-## Proof path
-
-- Local artifacts only, hash-pinned against the shipped manifest.
-- One prove at a time per sidecar process, in a terminable child-process
-  worker with a 10-second deadline. (snarkjs cannot run inside a Node
-  `worker_threads` worker: its `web-worker` polyfill re-enters itself there.)
-- Every proof is self-verified locally with the pinned verification key
-  before `PAYMENT-SIGNATURE` can be emitted, and its six public signals must
-  exactly match `[root, timestamp, domain, requestSignal, nullifier, share]`.
-- A failed attempt retries with the same slot, request signal, nonce,
-  response key, and gateway `issuedAt` while more than ten seconds remain in
-  the challenge window.
-- A slot is provisional during proving and recorded in the durable local
-  ledger (`$ZK_CREDITS_HOME/base-slots.json`) only after self-verification.
-  Proof misses, timeouts, hash failures, and verification failures release
-  it.
-
-## `GET /metrics`
-
-Aggregate only, authenticated with the same local token:
-
-```json
-{
-  "attempts": 12,
-  "successes": 11,
-  "failures": 1,
-  "retries": 1,
-  "failuresByCategory": { "timeout": 1, "artifact_hash_mismatch": 0, "...": 0 },
-  "hotProve": { "samples": 11, "p50Ms": 1180.4, "p95Ms": 1902.7 },
-  "updatedAt": "2026-09-20T14:00:00.000Z"
-}
-```
+3. Import your credential and connect Codex:
 
-The first prove in a process is the cold sample and is excluded from the hot
-percentiles. Proofs, public signals, nullifiers, credentials, requests, and
-any identifying label are never recorded or exposed.
+   ```sh
+   ZK_CREDITS_CREDENTIAL_PATH=/path/to/activated-credential.json zk-credits setup codex
+   zk-credits codex
+   ```
+
+Setup stores your credential in OS secure storage. Keep your recovery file
+private: anyone with it can spend your credits.
 
 ## Commands
 
-```
-zk-credits cline [cline arguments...]
-zk-credits setup codex [--model <model>] [--legacy]
-zk-credits setup x402 [--legacy]
-zk-credits config rpc
-zk-credits codex [codex arguments...]
-zk-credits status
-zk-credits serve [--port <port>] [--internal-trial-one-proof]
-zk-credits x402-agent
-zk-credits founder-demo-agent
-zk-credits trial-registered-adapter
-eval "$(zk-credits env)"
+| Command | Purpose |
+| --- | --- |
+| `zk-credits setup codex` | Import a credential and configure Codex |
+| `zk-credits setup x402` | Prepare an x402 agent |
+| `zk-credits codex [args...]` | Start Codex with the local sidecar |
+| `zk-credits codex --task-evidence` | Run a coding task and show its aggregate payment evidence on exit |
+| `zk-credits investigate --chain base <transaction-hash>` | Investigate a failed Base transaction using prepaid inference |
+| `zk-credits cline [args...]` | Start Cline with the local sidecar |
+| `zk-credits x402-agent` | Run the included x402 agent |
+| `zk-credits serve` | Run the sidecar in the foreground |
+| `zk-credits doctor` | Inspect the service, PID, setup, RPC source, and log location |
+| `zk-credits stop` | Stop the local sidecar |
+| `zk-credits status` | Check the Codex configuration and sidecar |
+| `zk-credits config rpc` | Save or change your Base Sepolia RPC endpoint |
+| `zk-credits --help` | Show command and troubleshooting guidance |
+
+`doctor` and `stop` are available in version 0.2.11. They work before setup.
+The default port is `3210`; set `ZK_CREDITS_SIDECAR_PORT` to select another port.
+Automatic startup logs are saved to `~/.zk-credits/sidecar.log`, or
+`$ZK_CREDITS_HOME/sidecar.log` when set.
+
+## Troubleshooting
+
+**Sidecar stopped or setup missing:** Run `zk-credits doctor`. If setup is
+missing, import your activated credential with the setup command above.
+Otherwise run `zk-credits serve` and read its output.
+
+**Port occupied or “Server is not running”:** `x402-agent` starts its own local
+server. Run `zk-credits stop` before switching from `serve` to `x402-agent`.
+For older versions, inspect the listener before stopping it:
+
+```sh
+lsof -nP -iTCP:3210 -sTCP:LISTEN
+ps -p <PID> -o pid,ppid,etime,command
+kill -TERM <PID>
 ```
 
-`serve --internal-trial-one-proof` is an opt-in maintainer mode for the
-internal Base Sepolia trial. During that process lifetime, one authenticated,
-valid spend request may reach the prepaid transport and the proof factory may
-attempt one proof. A later valid request receives HTTP 409 with
-`internal_trial_limit_reached`; ordinary `serve` behavior is unchanged without
-the flag.
-
-`trial-registered-adapter` is a maintainer-only internal trial command. It
-requires the locally recovered credential and pinned proving bundle, prompts
-for the credential password and gateway admin token without echo when they are
-not already configured, and requires an explicit confirmation before sending
-one billable request. It checks gateway readiness, authenticated admin status,
-Base root agreement, Codex profile/sidecar status, and remaining local slot
-capacity, then reports only the exchange phases and aggregate counter deltas.
-Run it only after recovery is complete and with the same `ZK_CREDITS_HOME`
-used by the sidecar; it registers `zk-prepaid` directly through the official
-x402 client adapter and reuses the durable slot ledger.
-
-Codex SDK:
-
-```ts
-import { buildCodexSdkOptions, buildCodexThreadOptions } from 'zk-credits/codex';
-```
+Check the PID and command to confirm it is your sidecar. For a foreground
+process, press Ctrl+C. `stop` authenticates the service and lets active requests
+finish before exit.
 
-`zk-credits/x402` exports `createLocalX402Agent` for an operator who is
-integrating the adapter into their own x402 agent. It loads the same local
-credential, pinned proof artifacts, public witness, proof engine, and slot
-ledger used by the sidecar. The request-aware client binds the actual method,
-URL, and body into each spend; its metrics endpoint exposes authenticated
-aggregate counters on loopback. See
-[`docs/onboarding/base-zk-credits-x402-agent.md`](../../docs/onboarding/base-zk-credits-x402-agent.md)
-for integration and measured-call steps. The included `zk-credits x402-agent`
-command is a small task-running starter for the founder demo and local
-rehearsal; external slot C uses their own agent.
-
-The credential secret is loaded from OS secure storage only into local memory. The sidecar cache
-contains public Base event leaves and never stores the secret, prompt, response,
-proof, account, or wallet.
-
-## Validation
-
-```bash
-npm test                                      # unit + fixture suites
-npm run build                                 # tsc + bundled CLI
-ZK_CREDITS_ARTIFACT_DIR="$PWD/circuits/artifacts" \
-  npx vitest run pinned-artifacts             # opt-in real fullProve + self-verify
+**Base witness synchronization failed:** Run `zk-credits config rpc` and enter
+a Base Sepolia endpoint (chain ID `84532`). Stop and restart the sidecar, or
+retry setup if it failed. `BASE_RPC_URL` overrides the saved endpoint.
+A missing funded credential or rejected root can require activation checks;
+changing the RPC may not resolve it.
+
+## Clients and privacy
+
+Codex and Cline use the local OpenAI-compatible transport. Your own x402 agent
+must register the custom `zk-prepaid` adapter; generic x402 clients do not
+support this scheme automatically. See the [x402 integration guide](https://github.com/mangekyou-labs/haze-api/blob/main/docs/onboarding/base-zk-credits-x402-agent.md).
+
+Your credential stays on your device. Proofs are sent to authorize each spend. The gateway and model provider receive request content and
+can observe traffic metadata. This does not hide your IP address.
+
+Base Sepolia test credits only. The circuit is not independently audited.
+
+### Coding-task evidence (0.2.12 candidate)
+
+After setup, `zk-credits codex --task-evidence` launches Codex against a fresh,
+dedicated local sidecar and prints aggregate payment counters when Codex exits.
+The provider and profile are fixed for attribution. The summary contains no
+prompts, bearer credentials, proofs, or payment headers. `exchange_verified`
+confirms a successful agent exit and an observed settled response; inspect the
+code diff and tests separately to judge the coding task. The supported model and
+reasoning defaults are selected automatically, including with older setups:
+
+```sh
+zk-credits codex --task-evidence
 ```
 
-The opt-in artifact test needs an installed bundle and the built
-`dist/proof-child.js`. CI stays deterministic through injected worker and
-crypto fixtures; the default suites stay green with no bundle installed.
+Enter your task, review the change and tests, then exit Codex to see the summary.
+Version 0.2.12 is prepared for owner publication; 0.2.11 lacks this command.
+See the [indexer sample](https://github.com/mangekyou-labs/haze-api/tree/main/examples/base-usdc-indexer).
+
+### Transaction investigator (0.2.12 candidate)
+
+After closing Codex, run `zk-credits investigate --chain base <transaction-hash>`
+with the same configured credential. It fetches public execution evidence and
+uses the custom x402 `zk-prepaid` adapter for model inference. Base mainnet is
+the investigated chain; credit funding remains on Base Sepolia and consumption
+is offchain. It does not purchase external traces. Keep missing-evidence notices
+visible and distinguish observed errors from model hypotheses.
 
-Base Sepolia only. The circuit is experimental and not independently audited.
-Development proving material is not suitable for mainnet; the repository's
-release gates require an audited production circuit and ceremony.
+Repeating a transaction hash recovers its existing local task; it need not make
+a new paid call or return a complete report. Do not delete task journals or reset
+credential accounting to force a fresh exchange. Unknown payment outcomes must
+be reconciled before another paid task. A saved report must be labeled as a prior
+run, with its own payment summary.

package/dist/base-sidecar.d.ts

@@ -65,6 +65,28 @@ export interface BasePrepaidClientOptions {
      * a public signal, or a credential identifier.
      */
     lifecycle?: ZkPrepaidLifecycleObserver;
+    /** Caller-owned durable policy and accounting boundary; failures propagate. */
+    authorization?: BaseAuthorizationBridge;
+}
+export interface BaseAuthorizationRequest extends BasePaymentContext {
+    attemptId: string;
+    body: Uint8Array;
+}
+export type BaseUsageObservation = {
+    attemptId: string;
+    slot: number;
+} & ({
+    type: 'provisional' | 'released' | 'retired';
+} | {
+    type: 'settlement';
+    outcome: 'confirmed' | 'failed' | 'unknown';
+    reservationId?: string;
+});
+export interface BaseAuthorizationBridge {
+    /** Persist reservation and validate actual terms before any fresh proof. */
+    beforeProof(request: BaseAuthorizationRequest): Promise<void>;
+    /** Contains no request content, credential, proof, signature or replay key. */
+    observe(event: BaseUsageObservation): Promise<void>;
 }
 export interface BasePrepaidClient {
     client: ZkPrepaidClient;
@@ -80,6 +102,8 @@ export interface BasePaymentContext {
 export interface BasePreparedPayment {
     payment: PaymentPayload;
     responsePrivateKey: string;
+    attemptId: string;
+    slot: number;
 }
 export declare function validateBaseCreditWitness(witness: BaseCreditWitness): BaseCreditWitness;
 /** Creates the shared local proof factory used by both client transports. */

package/dist/base-sidecar.js

@@ -7,7 +7,7 @@
  *
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { createDecipheriv, generateKeyPair as generateKeyPairCallback, privateDecrypt, randomBytes } from 'node:crypto';
+import { createDecipheriv, generateKeyPair as generateKeyPairCallback, privateDecrypt, randomBytes, randomUUID } from 'node:crypto';
 import { promisify } from 'node:util';
 import { BASE_MEMBERSHIP_TREE_CAPACITY, canonicalizeBaseJson, computeCreditLeaf, computeNullifier, computeShare, computeSlotBlinding, deriveRequestSignal, deriveSparseCreditWitness, secretFromBase64Url, secretToField, } from '@zk-credits/shared/base';
 import { buildPaymentPayload, createZkPrepaidClient, decodeHeader, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, } from '@zk-credits/x402-zk-prepaid';
@@ -77,8 +77,13 @@ export function createBasePaymentFactory(options) {
         const slotLedger = options.slotLedger;
         if (!slotLedger)
             throw new Error('A durable slot ledger is required for the Base pilot');
+        const attemptId = randomUUID();
+        const bytes = new Uint8Array(requestBodyBytes(body));
+        await options.authorization?.beforeProof({ attemptId, method, url, body: bytes, requirements: structuredClone(requirements) });
         const selectedSlot = slotLedger.allocateProvisional();
+        let retired = false;
         try {
+            await options.authorization?.observe({ type: 'provisional', attemptId, slot: selectedSlot });
             const nonce = randomNonce();
             const responseKeys = await responseKey();
             const requestSignal = await deriveRequestSignal({
@@ -128,6 +133,8 @@ export function createBasePaymentFactory(options) {
                 throw new Error('Proof public signals do not match the canonical statement');
             }
             await slotLedger.commit(selectedSlot);
+            retired = true;
+            await options.authorization?.observe({ type: 'retired', attemptId, slot: selectedSlot });
             const payment = buildPaymentPayload({
                 requirements,
                 proof: proofForPayment(proof.proof),
@@ -135,10 +142,13 @@ export function createBasePaymentFactory(options) {
                 nonce,
                 responseKey: responseKeys.publicKey,
             });
-            return { payment, responsePrivateKey: responseKeys.privateKey };
+            return { payment, responsePrivateKey: responseKeys.privateKey, attemptId, slot: selectedSlot };
         }
         catch (error) {
-            slotLedger.release(selectedSlot);
+            if (!retired) {
+                slotLedger.release(selectedSlot);
+                await options.authorization?.observe({ type: 'released', attemptId, slot: selectedSlot });
+            }
             throw error;
         }
     };
@@ -266,9 +276,49 @@ export function createBasePrepaidClient(options) {
             headers: new Headers(response.headers),
         });
     };
+    const observeSettlement = async (response, init) => {
+        const header = new Headers(init?.headers).get(PAYMENT_SIGNATURE_HEADER);
+        if (!header || !options.authorization)
+            return;
+        let payment;
+        try {
+            payment = decodeHeader(header);
+        }
+        catch {
+            return;
+        }
+        const key = pendingByNonce.get(payment.payload.nonce);
+        const pending = key ? pendingPayments.get(key) : undefined;
+        if (!pending)
+            return;
+        let outcome = 'unknown';
+        let reservationId;
+        try {
+            const encoded = response.headers.get(PAYMENT_RESPONSE_HEADER);
+            const result = encoded ? decodeHeader(encoded) : undefined;
+            if (result && result.network === pending.payment.accepted.network && result.transaction === ''
+                && (result.reservationId === undefined || (typeof result.reservationId === 'string' && result.reservationId.length > 0 && result.reservationId.length <= 256))
+                && typeof result.success === 'boolean' && !('payer' in result)) {
+                // A failed response can describe an ambiguous ready/commit failure.
+                outcome = result.success ? 'confirmed' : 'unknown';
+                reservationId = result.reservationId;
+            }
+        }
+        catch { /* Missing or malformed settlement leaves consumption unknown. */ }
+        await options.authorization.observe({ type: 'settlement', attemptId: pending.attemptId, slot: pending.slot, outcome,
+            ...(reservationId === undefined ? {} : { reservationId }) });
+    };
     const fetchWithReplay = async (input, init) => {
         prunePending();
-        const response = await fetcher(input, init);
+        let response;
+        try {
+            response = await fetcher(input, { ...init, redirect: 'error' });
+        }
+        catch (error) {
+            await observeSettlement(new Response(null, { status: 503 }), init);
+            throw error;
+        }
+        await observeSettlement(response, init);
         if (response.status !== 409)
             return trackPaymentResponse(response, init);
         let replayAvailable = false;
@@ -343,7 +393,7 @@ export function createBasePrepaidClient(options) {
                 const nonce = payment.payload.nonce;
                 const expiresAt = Date.now() + REPLAY_TTL_MS;
                 replayKeys.set(nonce, { privateKey: prepared.responsePrivateKey, expiresAt });
-                pendingPayments.set(key, { payment, expiresAt });
+                pendingPayments.set(key, { payment, expiresAt, attemptId: prepared.attemptId, slot: prepared.slot });
                 pendingByNonce.set(nonce, key);
                 prunePending();
                 return payment;
@@ -358,7 +408,25 @@ export function createBasePrepaidClient(options) {
             }
         },
     });
-    return { client, committedSlots: () => options.slotLedger?.committedSlots() ?? [] };
+    return {
+        client: {
+            clearRequirements: client.clearRequirements,
+            async fetch(input, init) {
+                const source = input instanceof Request ? input : undefined;
+                const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+                const body = init?.body ?? (source?.body ? new Uint8Array(await source.clone().arrayBuffer()) : undefined);
+                const snapshot = body instanceof ArrayBuffer ? new Uint8Array(body.slice(0))
+                    : body instanceof Uint8Array ? new Uint8Array(body) : body;
+                return client.fetch(url, {
+                    ...(source ? { method: source.method, headers: new Headers(source.headers), signal: source.signal } : {}),
+                    ...init,
+                    headers: new Headers(init?.headers ?? source?.headers),
+                    ...(snapshot === undefined ? {} : { body: snapshot }),
+                });
+            },
+        },
+        committedSlots: () => options.slotLedger?.committedSlots() ?? [],
+    };
 }
 function parsePublicTreeArtifact(value) {
     if (!value || typeof value !== 'object')