@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/interfaces/server_circuit_prover.ts

@@ -3,24 +3,36 @@ import type {
   NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
 } from '@aztec/constants';
 
 import type { AvmCircuitInputs } from '../avm/avm.js';
-import type { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import type { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import type { RootParityInputs } from '../parity/root_parity_inputs.js';
-import type { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
-import type { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
-import type { BlockRootOrBlockMergePublicInputs } from '../rollup/block_root_or_block_merge_public_inputs.js';
-import type { BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import type { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
-import type { PaddingBlockRootRollupInputs } from '../rollup/index.js';
-import type { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import type { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import type { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import type { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import type { TubeInputs } from '../rollup/tube_inputs.js';
+import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
+import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
+import type {
+  BlockRootEmptyTxFirstRollupPrivateInputs,
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootRollupPrivateInputs,
+  BlockRootSingleTxFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+} from '../rollup/block_root_rollup_private_inputs.js';
+import type { CheckpointMergeRollupPrivateInputs } from '../rollup/checkpoint_merge_rollup_private_inputs.js';
+import type { CheckpointRollupPublicInputs } from '../rollup/checkpoint_rollup_public_inputs.js';
+import type {
+  CheckpointPaddingRollupPrivateInputs,
+  CheckpointRootRollupPrivateInputs,
+  CheckpointRootSingleBlockRollupPrivateInputs,
+} from '../rollup/checkpoint_root_rollup_private_inputs.js';
+import type { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import type { PublicChonkVerifierPrivateInputs } from '../rollup/public_chonk_verifier_private_inputs.js';
+import type { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
+import type { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import type { RootRollupPrivateInputs } from '../rollup/root_rollup_private_inputs.js';
+import type { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import type { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import type { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import type { Tx } from '../tx/tx.js';
 import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from './proving-job.js';
 
@@ -33,7 +45,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getBaseParityProof(
-    inputs: BaseParityInputs,
+    inputs: ParityBasePrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof RECURSIVE_PROOF_LENGTH>>;
@@ -43,103 +55,119 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getRootParityProof(
-    inputs: RootParityInputs,
+    inputs: ParityRootPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
 
+  getPublicChonkVerifierProof(
+    inputs: PublicChonkVerifierPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<
+    PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+  >;
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getPrivateBaseRollupProof(
-    baseRollupInput: PrivateBaseRollupInputs,
+  getPrivateTxBaseRollupProof(
+    baseRollupInput: PrivateTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
-  getPublicBaseRollupProof(
-    inputs: PublicBaseRollupInputs,
+  getPublicTxBaseRollupProof(
+    inputs: PublicTxBaseRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
-   * Get a recursively verified client IVC proof (making it a compatible honk proof for the rest of the rollup).
+   * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getTubeProof(
-    tubeInput: TubeInputs,
+  getTxMergeRollupProof(
+    input: TxMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>;
+  ): Promise<PublicInputsAndRecursiveProof<TxRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getMergeRollupProof(
-    input: MergeRollupInputs,
+  getBlockRootFirstRollupProof(
+    input: BlockRootFirstRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootSingleTxFirstRollupProof(
+    input: BlockRootSingleTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootEmptyTxFirstRollupProof(
+    input: BlockRootEmptyTxFirstRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootRollupProof(
+    input: BlockRootRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  getBlockRootSingleTxRollupProof(
+    input: BlockRootSingleTxRollupPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
    */
-  getBlockRootRollupProof(
-    input: BlockRootRollupInputs,
+  getBlockMergeRollupProof(
+    input: BlockMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
-  >;
+  ): Promise<PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
 
-  getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  getCheckpointRootRollupProof(
+    input: CheckpointRootRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+  getCheckpointRootSingleBlockRollupProof(
+    input: CheckpointRootSingleBlockRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  getPaddingBlockRootRollupProof(
-    input: PaddingBlockRootRollupInputs,
+  getCheckpointPaddingRollupProof(
+    input: CheckpointPaddingRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getBlockMergeRollupProof(
-    input: BlockMergeRollupInputs,
+  getCheckpointMergeRollupProof(
+    input: CheckpointMergeRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<
-    PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
+    PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
   >;
 
   /**
@@ -147,7 +175,7 @@ export interface ServerCircuitProver {
    * @param input - Input to the circuit.
    */
   getRootRollupProof(
-    input: RootRollupInputs,
+    input: RootRollupPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>>;
@@ -158,7 +186,6 @@ export interface ServerCircuitProver {
    */
   getAvmProof(
     inputs: AvmCircuitInputs,
-    skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: Remove.
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;

package/src/interfaces/slasher.ts

@@ -1,5 +1,5 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -24,25 +24,29 @@ export interface SlasherConfig {
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
+  slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
-export const SlasherConfigSchema = z.object({
-  slashOverridePayload: schemas.EthAddress.optional(),
-  slashMinPenaltyPercentage: z.number(),
-  slashMaxPenaltyPercentage: z.number(),
-  slashValidatorsAlways: z.array(schemas.EthAddress),
-  slashValidatorsNever: z.array(schemas.EthAddress),
-  slashPrunePenalty: schemas.BigInt,
-  slashDataWithholdingPenalty: schemas.BigInt,
-  slashInactivityTargetPercentage: z.number(),
-  slashInactivityConsecutiveEpochThreshold: z.number(),
-  slashInactivityPenalty: schemas.BigInt,
-  slashProposeInvalidAttestationsPenalty: schemas.BigInt,
-  slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
-  slashUnknownPenalty: schemas.BigInt,
-  slashOffenseExpirationRounds: z.number(),
-  slashMaxPayloadSize: z.number(),
-  slashGracePeriodL2Slots: z.number(),
-  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
-  slashSelfAllowed: z.boolean().optional(),
-}) satisfies ZodFor<SlasherConfig>;
+export const SlasherConfigSchema = zodFor<SlasherConfig>()(
+  z.object({
+    slashOverridePayload: schemas.EthAddress.optional(),
+    slashMinPenaltyPercentage: z.number(),
+    slashMaxPenaltyPercentage: z.number(),
+    slashValidatorsAlways: z.array(schemas.EthAddress),
+    slashValidatorsNever: z.array(schemas.EthAddress),
+    slashPrunePenalty: schemas.BigInt,
+    slashDataWithholdingPenalty: schemas.BigInt,
+    slashInactivityTargetPercentage: z.number(),
+    slashInactivityConsecutiveEpochThreshold: z.number(),
+    slashInactivityPenalty: schemas.BigInt,
+    slashProposeInvalidAttestationsPenalty: schemas.BigInt,
+    slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
+    slashUnknownPenalty: schemas.BigInt,
+    slashOffenseExpirationRounds: z.number(),
+    slashMaxPayloadSize: z.number(),
+    slashGracePeriodL2Slots: z.number(),
+    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashExecuteRoundsLookBack: z.number(),
+    slashSelfAllowed: z.boolean().optional(),
+  }),
+);

package/src/interfaces/tx_provider.ts

@@ -1,4 +1,4 @@
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -9,8 +9,9 @@ export interface ITxProvider {
 
   getTxsForBlockProposal(
     blockProposal: BlockProposal,
+    blockNumber: number,
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 
-  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+  getTxsForBlock(block: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 }

package/src/interfaces/validator.ts

@@ -1,14 +1,19 @@
 import type { SecretValue } from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
-import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+import type { Tx } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
+import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+import type { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { AllowedElementSchema } from './allowed_element.js';
+
 /**
  * Validator client configuration
  */
@@ -28,37 +33,60 @@ export interface ValidatorClientConfig {
   /** Interval between polling for new attestations from peers */
   attestationPollingIntervalMs: number;
 
-  /** Re-execute transactions before attesting */
+  /** Whether to re-execute transactions in a block proposal before attesting */
   validatorReexecute: boolean;
 
   /** Will re-execute until this many milliseconds are left in the slot */
   validatorReexecuteDeadlineMs: number;
+
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
+
+  /** Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus */
+  fishermanMode?: boolean;
 }
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
-  Pick<SequencerConfig, 'txPublicSetupAllowList'> &
-  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>;
-
-export const ValidatorClientConfigSchema = z.object({
-  validatorAddresses: z.array(schemas.EthAddress).optional(),
-  disableValidator: z.boolean(),
-  disabledValidators: z.array(schemas.EthAddress),
-  attestationPollingIntervalMs: z.number().min(0),
-  validatorReexecute: z.boolean(),
-  validatorReexecuteDeadlineMs: z.number().min(0),
-}) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
+  Pick<SequencerConfig, 'txPublicSetupAllowList' | 'broadcastInvalidBlockProposal'> &
+  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'> & {
+    /**
+     * Whether transactions are disabled for this node
+     * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
+     */
+    disableTransactions?: boolean;
+  };
+
+export const ValidatorClientConfigSchema = zodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>()(
+  z.object({
+    validatorAddresses: z.array(schemas.EthAddress).optional(),
+    disableValidator: z.boolean(),
+    disabledValidators: z.array(schemas.EthAddress),
+    attestationPollingIntervalMs: z.number().min(0),
+    validatorReexecute: z.boolean(),
+    validatorReexecuteDeadlineMs: z.number().min(0),
+    alwaysReexecuteBlockProposals: z.boolean().optional(),
+    fishermanMode: z.boolean().optional(),
+  }),
+);
+
+export const ValidatorClientFullConfigSchema = zodFor<Omit<ValidatorClientFullConfig, 'validatorPrivateKeys'>>()(
+  ValidatorClientConfigSchema.extend({
+    txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+    broadcastInvalidBlockProposal: z.boolean().optional(),
+    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    disableTransactions: z.boolean().optional(),
+  }),
+);
 
 export interface Validator {
   start(): Promise<void>;
-  registerBlockProposalHandler(): void;
   updateConfig(config: Partial<ValidatorClientFullConfig>): void;
 
   // Block validation responsibilities
   createBlockProposal(
     blockNumber: number,
-    header: ProposedBlockHeader,
+    header: CheckpointHeader,
     archive: Fr,
-    stateReference: StateReference,
     txs: Tx[],
     proposerAddress: EthAddress | undefined,
     options: BlockProposalOptions,
@@ -67,4 +95,8 @@ export interface Validator {
 
   broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
   collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+  signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature>;
 }

package/src/interfaces/world_state.ts

@@ -1,3 +1,4 @@
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 import type { PromiseWithResolvers } from '@aztec/foundation/promise';
 
 import { z } from 'zod';
@@ -18,10 +19,10 @@ export enum WorldStateRunningState {
 }
 
 export interface WorldStateSyncStatus {
-  latestBlockNumber: number;
+  latestBlockNumber: BlockNumber;
   latestBlockHash: string;
-  finalizedBlockNumber: number;
-  oldestHistoricBlockNumber: number;
+  finalizedBlockNumber: BlockNumber;
+  oldestHistoricBlockNumber: BlockNumber;
   treesAreSynched: boolean;
 }
 
@@ -41,18 +42,28 @@ export interface WorldStateSynchronizerStatus {
 
 /** Provides writeable forks of the world state at a given block number. */
 export interface ForkMerkleTreeOperations {
-  /** Forks the world state at the given block number, defaulting to the latest one. */
-  fork(block?: number): Promise<MerkleTreeWriteOperations>;
-
-  /** Gets a handle that allows reading the state as it was at the given block number. */
-  getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+  /**
+   * Forks the world state at the given block number, defaulting to the latest one.
+   * @param block - The block number to fork at.
+   * @param opts - Optional parameters:
+   *  - closeDelayMs: number of milliseconds to wait before closing the fork on dispose.
+   */
+  fork(block?: BlockNumber, opts?: { closeDelayMs?: number }): Promise<MerkleTreeWriteOperations>;
 
   /** Backups the db to the target path. */
   backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
 }
 
+export interface ReadonlyWorldStateAccess {
+  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
+  getCommitted(): MerkleTreeReadOperations;
+
+  /** Gets a handle that allows reading the state as it was at the given block number. */
+  getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+}
+
 /** Defines the interface for a world state synchronizer. */
-export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
+export interface WorldStateSynchronizer extends ReadonlyWorldStateAccess, ForkMerkleTreeOperations {
   /** Starts the synchronizer. */
   start(): Promise<void | PromiseWithResolvers<void>>;
 
@@ -74,19 +85,16 @@ export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
    * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  syncImmediate(minBlockNumber?: number, skipThrowIfTargetNotReached?: boolean): Promise<number>;
-
-  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
-  getCommitted(): MerkleTreeReadOperations;
+  syncImmediate(minBlockNumber?: BlockNumber, skipThrowIfTargetNotReached?: boolean): Promise<BlockNumber>;
 
   /** Deletes the db */
   clear(): Promise<void>;
 }
 
-export const WorldStateSyncStatusSchema = z.object({
-  finalizedBlockNumber: z.number().int().nonnegative(),
-  latestBlockNumber: z.number().int().nonnegative(),
+export const WorldStateSyncStatusSchema: z.ZodType<WorldStateSyncStatus, z.ZodTypeDef, any> = z.object({
+  finalizedBlockNumber: BlockNumberSchema,
+  latestBlockNumber: BlockNumberSchema,
   latestBlockHash: z.string(),
-  oldestHistoricBlockNumber: z.number().int().nonnegative(),
+  oldestHistoricBlockNumber: BlockNumberSchema,
   treesAreSynched: z.boolean(),
-}) satisfies z.ZodType<WorldStateSyncStatus>;
+});

package/src/kernel/claimed_length_array.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import {
   BufferReader,
   FieldReader,

package/src/kernel/hints/build_nullifier_read_request_hints.ts

@@ -3,10 +3,11 @@ import {
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type NULLIFIER_TREE_HEIGHT,
 } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
-import { type IndexedTreeLeafPreimage, MembershipWitness } from '@aztec/foundation/trees';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { siloNullifier } from '../../hash/hash.js';
+import type { NullifierLeafPreimage } from '../../trees/nullifier_leaf.js';
 import type { ClaimedLengthArray } from '../claimed_length_array.js';
 import type { ScopedNullifier } from '../nullifier.js';
 import { NullifierReadRequestHintsBuilder } from './nullifier_read_request_hints.js';
@@ -24,7 +25,7 @@ export function isValidNullifierReadRequest(readRequest: ScopedReadRequest, null
 
 interface NullifierMembershipWitnessWithPreimage {
   membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>;
-  leafPreimage: IndexedTreeLeafPreimage;
+  leafPreimage: NullifierLeafPreimage;
 }
 
 export function getNullifierReadRequestResetActions(

package/src/kernel/hints/build_transient_data_hints.ts

@@ -16,7 +16,7 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
   futureNoteHashReads: ScopedReadRequest[],
   futureNullifierReads: ScopedReadRequest[],
   noteHashNullifierCounterMap: Map<number, number>,
-  validationRequestsSplitCounter: number,
+  splitCounter: number,
 ): { numTransientData: number; hints: Tuple<TransientDataSquashingHint, NULLIFIERS_LEN> } {
   const futureNoteHashReadsMap = new ScopedValueCache(futureNoteHashReads);
   const futureNullifierReadsMap = new ScopedValueCache(futureNullifierReads);
@@ -44,7 +44,7 @@ export function buildTransientDataHints<NOTE_HASHES_LEN extends number, NULLIFIE
 
     const nullifier = nullifiers.array[nullifierIndex];
     // Cannot nullify a non-revertible note hash with a revertible nullifier.
-    if (noteHash.counter < validationRequestsSplitCounter && nullifier.counter >= validationRequestsSplitCounter) {
+    if (noteHash.counter < splitCounter && nullifier.counter >= splitCounter) {
       continue;
     }
 

package/src/kernel/hints/find_private_kernel_reset_dimensions.ts

@@ -1,3 +1,5 @@
+import { isDefined } from '@aztec/foundation/types';
+
 import {
   PrivateKernelResetDimensions,
   type PrivateKernelResetDimensionsConfig,
@@ -10,10 +12,6 @@ interface DimensionOption {
   remainder?: PrivateKernelResetDimensions;
 }
 
-function isDefined<T>(value: T | undefined): value is T {
-  return value !== undefined;
-}
-
 function computeCost(dimensions: PrivateKernelResetDimensions, config: PrivateKernelResetDimensionsConfig) {
   return privateKernelResetDimensionNames.reduce(
     (accum, name) => accum + dimensions[name] * config.dimensions[name].cost,

package/src/kernel/hints/key_validation_hint.ts

@@ -1,4 +1,4 @@
-import { GrumpkinScalar } from '@aztec/foundation/fields';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class KeyValidationHint {

package/src/kernel/hints/key_validation_request.ts

@@ -1,5 +1,6 @@
 import { KEY_VALIDATION_REQUEST_LENGTH } from '@aztec/constants';
-import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 /**

package/src/kernel/hints/key_validation_request_and_generator.ts

@@ -1,5 +1,5 @@
 import { KEY_VALIDATION_REQUEST_AND_GENERATOR_LENGTH } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { KeyValidationRequest } from './key_validation_request.js';

package/src/kernel/hints/note_hash_read_request_hints.ts

@@ -1,6 +1,6 @@
 import { MAX_NOTE_HASH_READ_REQUESTS_PER_TX, NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { BufferReader } from '@aztec/foundation/serialize';
 import type { MembershipWitness } from '@aztec/foundation/trees';
 

package/src/kernel/hints/nullifier_read_request_hints.ts

@@ -1,7 +1,7 @@
 import { MAX_NULLIFIER_READ_REQUESTS_PER_TX, NULLIFIER_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import type { BufferReader } from '@aztec/foundation/serialize';
-import type { MembershipWitness, TreeLeafPreimage } from '@aztec/foundation/trees';
+import type { MembershipWitness } from '@aztec/foundation/trees';
 
 import { NullifierLeafPreimage } from '../../trees/index.js';
 import { PendingReadHint, ReadRequestAction, ReadRequestResetHints, SettledReadHint } from './read_request_hints.js';
@@ -11,7 +11,7 @@ export type NullifierReadRequestHints<PENDING extends number, SETTLED extends nu
   PENDING,
   SETTLED,
   typeof NULLIFIER_TREE_HEIGHT,
-  TreeLeafPreimage
+  NullifierLeafPreimage
 >;
 
 export function nullifierReadRequestHintsFromBuffer<PENDING extends number, SETTLED extends number>(
@@ -64,7 +64,7 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
   addSettledReadRequest(
     readRequestIndex: number,
     membershipWitness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>,
-    leafPreimage: TreeLeafPreimage,
+    leafPreimage: NullifierLeafPreimage,
   ) {
     if (this.numSettledReadHints === this.maxSettled) {
       throw new Error('Cannot add more settled read request.');