@aztec/stdlib 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

package/src/interfaces/get_tx_by_hash_options.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+import type { ZodFor } from '../schemas/schemas.js';
+
+/** Options for retrieving txs via {@link AztecNode.getTxByHash} and {@link AztecNode.getTxsByHash}. */
+export type GetTxByHashOptions = {
+  /** Keep the proof on the returned tx; stripped by default. */
+  includeProof?: boolean;
+};
+
+/** Zod schema for {@link GetTxByHashOptions}. */
+export const GetTxByHashOptionsSchema: ZodFor<GetTxByHashOptions> = z.object({
+  includeProof: z.boolean().optional(),
+});

package/src/interfaces/merkle_tree_operations.ts

@@ -141,9 +141,8 @@ export interface MerkleTreeReadOperations {
   getRevision(): WorldStateRevision;
 
   /**
-   * Returns the IPC path of the underlying aztec-wsdb process. The C++ AVM (NAPI) uses this to
-   * connect to the same world state instance that the TS layer is using; the merkle tree fork and
-   * the AVM must point at the same WSDB process for the simulation to see consistent state.
+   * Returns the IPC path of the underlying aztec-wsdb process. External AVM simulators use this to
+   * connect to the same world state instance that the TS layer is using.
    */
   getIpcPath(): string;
 

package/src/interfaces/p2p.ts

@@ -1,21 +1,23 @@
 import type { CheckpointProposalHash, SlotNumber } from '@aztec/foundation/branded-types';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import type { BlockProposal } from '../p2p/block_proposal.js';
+import { BlockProposal } from '../p2p/block_proposal.js';
 import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
-import type { CheckpointProposalCore } from '../p2p/checkpoint_proposal.js';
+import { CheckpointProposal, type CheckpointProposalCore } from '../p2p/checkpoint_proposal.js';
 import { type ApiSchemaFor, optional, schemas } from '../schemas/index.js';
 import { Tx } from '../tx/tx.js';
 import { TxHash } from '../tx/tx_hash.js';
 import { MAX_RPC_TXS_LEN } from './api_limit.js';
+import { type GetTxByHashOptions, GetTxByHashOptionsSchema } from './get_tx_by_hash_options.js';
 
 export type PeerInfo =
   | { status: 'connected'; score: number; id: string }
   | { status: 'dialing'; dialStatus: string; id: string; addresses: string[] }
   | { status: 'cached'; id: string; addresses: string[]; enr: string; dialAttempts: number };
 
-const PeerInfoSchema = z.discriminatedUnion('status', [
+export const PeerInfoSchema = z.discriminatedUnion('status', [
   z.object({ status: z.literal('connected'), score: z.number(), id: z.string() }),
   z.object({ status: z.literal('dialing'), dialStatus: z.string(), id: z.string(), addresses: z.array(z.string()) }),
   z.object({
@@ -30,12 +32,14 @@ const PeerInfoSchema = z.discriminatedUnion('status', [
 /** Exposed API to the P2P module. */
 export interface P2PApi {
   /**
-   * Returns all pending transactions in the transaction pool.
+   * Returns all pending transactions in the transaction pool. The txs' proofs are stripped unless
+   * `includeProof` is set.
    * @param limit - The number of items to returns
    * @param after - The last known pending tx. Used for pagination
+   * @param options - Options for the returned txs (eg whether to include their proofs).
    * @returns An array of Txs.
    */
-  getPendingTxs(limit?: number, after?: TxHash): Promise<Tx[]>;
+  getPendingTxs(limit?: number, after?: TxHash, options?: GetTxByHashOptions): Promise<Tx[]>;
 
   /** Returns the number of pending txs in the p2p tx pool. */
   getPendingTxCount(): Promise<number>;
@@ -66,17 +70,32 @@ export interface P2PApi {
   ): Promise<CheckpointAttestation[]>;
 }
 
+export type ProposalsForSlot = {
+  blockProposals: BlockProposal[];
+  checkpointProposals: CheckpointProposalCore[];
+};
+
 export interface P2PClient extends P2PApi {
   /** Manually adds checkpoint attestations to the p2p client attestation pool. */
   addOwnCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
 
   /** Returns retained signed proposals for a slot. */
-  getProposalsForSlot(slot: SlotNumber): Promise<{
-    blockProposals: BlockProposal[];
-    checkpointProposals: CheckpointProposalCore[];
-  }>;
+  getProposalsForSlot(slot: SlotNumber): Promise<ProposalsForSlot>;
+
+  /** Returns whether a checkpoint proposal was retained for a slot. */
+  hasCheckpointProposalForSlot(slot: SlotNumber): Promise<boolean>;
 }
 
+const MAX_PROPOSALS_FOR_SLOT_RPC_LEN = 256;
+
+export const BlockProposalSchema = bufferSchemaFor(BlockProposal);
+export const CheckpointProposalSchema = bufferSchemaFor(CheckpointProposal);
+
+export const ProposalsForSlotSchema = z.object({
+  blockProposals: z.array(BlockProposalSchema).max(MAX_PROPOSALS_FOR_SLOT_RPC_LEN),
+  checkpointProposals: z.array(CheckpointProposalSchema).max(MAX_PROPOSALS_FOR_SLOT_RPC_LEN),
+});
+
 export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getCheckpointAttestationsForSlot: z.function({
     input: z.tuple([
@@ -89,6 +108,7 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
     input: z.tuple([
       optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)),
       optional(TxHash.schema),
+      optional(GetTxByHashOptionsSchema),
     ]),
     output: z.array(Tx.schema),
   }),

package/src/interfaces/private_kernel_prover.ts

@@ -5,13 +5,17 @@ import type {
   PrivateKernelCircuitPublicInputs,
   PrivateKernelInit2CircuitPrivateInputs,
   PrivateKernelInit3CircuitPrivateInputs,
+  PrivateKernelInit4CircuitPrivateInputs,
+  PrivateKernelInit5CircuitPrivateInputs,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInner2CircuitPrivateInputs,
   PrivateKernelInner3CircuitPrivateInputs,
+  PrivateKernelInner4CircuitPrivateInputs,
+  PrivateKernelInner5CircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelResetCircuitPrivateInputs,
+  PrivateKernelResetTailCircuitPrivateInputs,
   PrivateKernelSimulateOutput,
-  PrivateKernelTailCircuitPrivateInputs,
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/index.js';
 import type { ChonkProofWithPublicInputs } from '../proofs/chonk_proof.js';
@@ -83,6 +87,48 @@ export interface PrivateKernelProver {
     privateKernelInputsInit3: PrivateKernelInit3CircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
+  /**
+   * Creates a proof output for a batched first iteration that processes four app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInit4 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInit4Output(
+    privateKernelInputsInit4: PrivateKernelInit4CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched first kernel iteration (four app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInit4 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInit4(
+    privateKernelInputsInit4: PrivateKernelInit4CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a batched first iteration that processes five app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInit5 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInit5Output(
+    privateKernelInputsInit5: PrivateKernelInit5CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched first kernel iteration (five app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInit5 - The batched private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInit5(
+    privateKernelInputsInit5: PrivateKernelInit5CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
   /**
    * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
    *
@@ -145,6 +191,48 @@ export interface PrivateKernelProver {
     privateKernelInputsInner3: PrivateKernelInner3CircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
+  /**
+   * Creates a proof output for a batched inner iteration that processes four app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInner4 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInner4Output(
+    privateKernelInputsInner4: PrivateKernelInner4CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched inner kernel iteration (four app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInner4 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInner4(
+    privateKernelInputsInner4: PrivateKernelInner4CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a batched inner iteration that processes five app calls in a single
+   * private kernel circuit.
+   *
+   * @param privateKernelInputsInner5 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  generateInner5Output(
+    privateKernelInputsInner5: PrivateKernelInner5CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Executes the batched inner kernel iteration (five app calls) without generating a proof.
+   *
+   * @param privateKernelInputsInner5 - The batched private data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and an empty kernel proof.
+   */
+  simulateInner5(
+    privateKernelInputsInner5: PrivateKernelInner5CircuitPrivateInputs,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
+
   /**
    * Creates a proof output by resetting the arrays using the reset circuit.
    *
@@ -166,23 +254,21 @@ export interface PrivateKernelProver {
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelCircuitPublicInputs>>;
 
   /**
-   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   * Creates a proof output for the terminal reset+tail step. Dispatches to the rollup-bound or
+   * public-bound family based on `inputs.isForPublic()`.
    *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   * @param privateKernelInputs - Reset hints, dimensions, and tail params.
+   * @returns A Promise resolving to a ProofOutput containing the tail-shaped public inputs.
    */
-  generateTailOutput(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  generateResetTailOutput(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   /**
-   * Executes the final ordering iteration circuit.
-   *
-   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
-   * @returns A Promise resolving to a ProofOutput object containing public inputs an empty kernel proof.
+   * Simulates the terminal reset+tail step without generating a proof.
    */
-  simulateTail(
-    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  simulateResetTail(
+    privateKernelInputs: PrivateKernelResetTailCircuitPrivateInputs,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>>;
 
   generateHidingToRollupOutput(
@@ -204,7 +290,12 @@ export interface PrivateKernelProver {
    * Compute the gate count for a given circuit.
    * @param bytecode - The circuit bytecode in gzipped bincode format
    * @param circuitName - The name of the circuit
+   * @param circuitKind - The circuit kind expected by the Chonk backend
    * @returns A Promise resolving to the gate count
    */
-  computeGateCountForCircuit(bytecode: Buffer, circuitName: string): Promise<number>;
+  computeGateCountForCircuit(
+    bytecode: Buffer,
+    circuitName: string,
+    circuitKind: PrivateExecutionStep['kind'],
+  ): Promise<number>;
 }

package/src/interfaces/prover-client.ts

@@ -5,7 +5,6 @@ import { z } from 'zod';
 
 import { schemas, zodFor } from '../schemas/index.js';
 import type { TxHash } from '../tx/tx_hash.js';
-import type { EpochProver } from './epoch-prover.js';
 import type { ProvingJobConsumer } from './prover-broker.js';
 
 export type ActualProverConfig = {
@@ -124,10 +123,9 @@ function parseProverId(str: string) {
 /**
  * The interface to the prover client.
  * Provides the ability to generate proofs and build rollups.
+ *
  */
 export interface EpochProverManager {
-  createEpochProver(): EpochProver;
-
   start(): Promise<void>;
 
   stop(): Promise<void>;

package/src/interfaces/prover-node.ts

@@ -1,42 +1,47 @@
+import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+
 import { z } from 'zod';
 
-import { type L2Tips, L2TipsSchema } from '../block/l2_block_source.js';
 import { type ApiSchemaFor, schemas } from '../schemas/index.js';
-import { type WorldStateSyncStatus, WorldStateSyncStatusSchema } from './world_state.js';
+import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 
 const EpochProvingJobState = [
   'initialized',
-  'processing',
-  'awaiting-prover',
+  'awaiting-checkpoints',
+  'awaiting-root',
+  'awaiting-predecessor',
   'publishing-proof',
   'completed',
+  'superseded',
   'failed',
   'stopped',
+  'cancelled',
   'timed-out',
-  'reorg',
 ] as const;
 
 export type EpochProvingJobState = (typeof EpochProvingJobState)[number];
 
 export const EpochProvingJobTerminalState: EpochProvingJobState[] = [
   'completed',
+  'superseded',
   'failed',
   'stopped',
+  'cancelled',
   'timed-out',
-  'reorg',
 ] as const;
 
 export type EpochProvingJobTerminalState = (typeof EpochProvingJobTerminalState)[number];
 
-/** JSON RPC public interface to a prover node. */
+/** JSON RPC admin interface to a prover node. */
 export interface ProverNodeApi {
   getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]>;
 
-  startProof(epochNumber: number): Promise<void>;
-
-  getL2Tips(): Promise<L2Tips>;
-
-  getWorldStateSyncStatus(): Promise<WorldStateSyncStatus>;
+  /**
+   * Schedules proving for the given epoch and returns the job id immediately, without waiting for
+   * the proof to complete (proving can take far longer than an HTTP request). Poll `getJobs()` to
+   * track the returned job's progress.
+   */
+  startProof(epochNumber: number): Promise<string>;
 }
 
 /** Schemas for prover node API functions. */
@@ -46,9 +51,19 @@ export const ProverNodeApiSchema: ApiSchemaFor<ProverNodeApi> = {
     output: z.array(z.object({ uuid: z.string(), status: z.enum(EpochProvingJobState), epochNumber: z.number() })),
   }),
 
-  startProof: z.function({ input: z.tuple([schemas.Integer]), output: z.void() }),
-
-  getL2Tips: z.function({ input: z.tuple([]), output: L2TipsSchema }),
-
-  getWorldStateSyncStatus: z.function({ input: z.tuple([]), output: WorldStateSyncStatusSchema }),
+  startProof: z.function({ input: z.tuple([schemas.Integer]), output: z.string() }),
 };
+
+export function createProverNodeAdminClient(
+  url: string,
+  versions: Partial<ComponentsVersions> = {},
+  fetch = defaultFetch,
+  apiKey?: string,
+): ProverNodeApi {
+  return createSafeJsonRpcClient<ProverNodeApi>(url, ProverNodeApiSchema, {
+    namespaceMethods: 'prover',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+    ...(apiKey ? { extraHeaders: { 'x-api-key': apiKey } } : {}),
+  });
+}

package/src/interfaces/proving-job.ts

@@ -1,5 +1,5 @@
 import {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -204,7 +204,7 @@ export type ProvingJobInputsMap = {
 export const ProvingJobResult = z.discriminatedUnion('type', [
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_VM),
-    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
+    result: RecursiveProof.schemaFor(AVM_V2_PROOF_LENGTH_IN_FIELDS),
   }),
   z.object({
     type: z.literal(ProvingRequestType.PUBLIC_CHONK_VERIFIER),
@@ -319,7 +319,7 @@ export const ProvingJobResult = z.discriminatedUnion('type', [
 ]);
 export type ProvingJobResult = z.infer<typeof ProvingJobResult>;
 export type ProvingJobResultsMap = {
-  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
+  [ProvingRequestType.PUBLIC_VM]: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;
   [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: PublicInputsAndRecursiveProof<
     PublicChonkVerifierPublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
@@ -441,9 +441,20 @@ export const ProvingJobRejectedResult = z.object({
 });
 export type ProvingJobRejectedResult = z.infer<typeof ProvingJobRejectedResult>;
 
+/**
+ * The result of a job that was cancelled by its producer. Unlike a fulfilled or rejected result it
+ * is not truly terminal: re-enqueuing the same job id revives it, so an abort never permanently
+ * blocks a proof from being produced.
+ */
+export const ProvingJobAbortedResult = z.object({
+  status: z.literal('aborted'),
+});
+export type ProvingJobAbortedResult = z.infer<typeof ProvingJobAbortedResult>;
+
 export const ProvingJobSettledResult = z.discriminatedUnion('status', [
   ProvingJobFulfilledResult,
   ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
 ]);
 export type ProvingJobSettledResult = z.infer<typeof ProvingJobSettledResult>;
 
@@ -453,5 +464,6 @@ export const ProvingJobStatus = z.discriminatedUnion('status', [
   z.object({ status: z.literal('not-found') }),
   ProvingJobFulfilledResult,
   ProvingJobRejectedResult,
+  ProvingJobAbortedResult,
 ]);
 export type ProvingJobStatus = z.infer<typeof ProvingJobStatus>;

package/src/interfaces/server.ts

@@ -9,7 +9,6 @@ export * from './checkpoint_response.js';
 export * from './l1_publish_info.js';
 export * from './block-builder.js';
 export * from './configs.js';
-export * from './epoch-prover.js';
 export * from './l2_logs_source.js';
 export * from './merkle_tree_operations.js';
 export * from './p2p-bootstrap.js';

package/src/interfaces/server_circuit_prover.ts

@@ -1,5 +1,5 @@
 import type {
-  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
@@ -189,7 +189,7 @@ export interface ServerCircuitProver {
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
+  ): Promise<RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>>;
 }
 
 export type IVCProofVerificationResult = {

package/src/interfaces/validator.ts

@@ -84,6 +84,9 @@ export type ValidatorClientConfig = ValidatorHASignerConfig &
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowListExtend' | 'broadcastInvalidBlockProposal' | 'maxBlocksPerCheckpoint'> &
+  // `blockDurationMs` is optional on the loose `SequencerConfig` but is always populated via the shared
+  // `numberConfigHelper(3000)` mapping, so it is required on the fully-resolved validator config.
+  Required<Pick<SequencerConfig, 'blockDurationMs'>> &
   Pick<
     SlasherConfig,
     | 'slashBroadcastedInvalidBlockPenalty'
@@ -97,6 +100,12 @@ export type ValidatorClientFullConfig = ValidatorClientConfig &
      * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
      */
     disableTransactions?: boolean;
+
+    /**
+     * Maximum clock-disparity tolerance (ms) applied to proposal/attestation receive windows.
+     * @remarks Mirrors the property in P2PConfig. It's not picked from there to avoid circular dependencies.
+     */
+    maxGossipClockDisparityMs?: number;
   };
 
 export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
@@ -123,6 +132,7 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
   ValidatorClientConfigSchema.extend({
     txPublicSetupAllowListExtend: z.array(AllowedElementSchema).optional(),
     broadcastInvalidBlockProposal: z.boolean().optional(),
+    blockDurationMs: z.number().positive(),
     maxBlocksPerCheckpoint: z.number().positive().optional(),
     slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
     slashBroadcastedInvalidCheckpointProposalPenalty: schemas.BigInt,
@@ -130,6 +140,7 @@ export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullCo
     slashDuplicateAttestationPenalty: schemas.BigInt,
     slashAttestInvalidCheckpointProposalPenalty: schemas.BigInt,
     disableTransactions: z.boolean().optional(),
+    maxGossipClockDisparityMs: z.number().optional(),
   }),
 );
 

package/src/interfaces/world_state.ts

@@ -65,6 +65,20 @@ export interface ReadonlyWorldStateAccess {
 
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ReadonlyWorldStateAccess, ForkMerkleTreeOperations {
+  /**
+   * Returns a read handle to the world state at `blockNumber`, but only after verifying that the block at that
+   * height is on the fork identified by `blockHash`. This pins the returned view to a specific fork so a reorg
+   * that replaced the block at `blockNumber` cannot be served silently, closing the gap between resolving a query
+   * and reading its snapshot.
+   *
+   * Rejects if the block at `blockNumber` does not match `blockHash` (a reorg), or if the block's hash cannot be
+   * read from the requested view. Both are transient from a caller's perspective: re-resolving the query against
+   * the current chain and retrying may succeed or produce a more precise error. However, if the block's history
+   * has been pruned away (it predates the oldest historical block kept by world state), the rejection is terminal:
+   * retrying cannot bring the data back.
+   */
+  getVerifiedSnapshot(blockNumber: BlockNumber, blockHash: BlockHash): Promise<MerkleTreeReadOperations>;
+
   /** Starts the synchronizer. */
   start(): Promise<void | PromiseWithResolvers<void>>;