@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/interfaces/server_circuit_prover.ts

@@ -1,25 +1,38 @@
 import type {
-  AVM_PROOF_LENGTH_IN_FIELDS,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   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 { 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';
 
@@ -32,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>>;
@@ -42,95 +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<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>>;
+
+  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>
   >;
 
-  getSingleTxBlockRootRollupProof(
-    input: SingleTxBlockRootRollupInputs,
+  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>
   >;
 
-  /**
-   * Creates a proof for the given input.
-   * @param input - Input to the circuit.
-   */
-  getEmptyBlockRootRollupProof(
-    input: EmptyBlockRootRollupInputs,
+  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>
   >;
 
   /**
@@ -138,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>>;
@@ -149,11 +186,21 @@ export interface ServerCircuitProver {
    */
   getAvmProof(
     inputs: AvmCircuitInputs,
+    skipPublicInputsValidation?: boolean, // TODO(#14234)[Unconditional PIs validation]: Remove.
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>>;
+  ): Promise<ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>>;
 }
 
+export type IVCProofVerificationResult = {
+  // The result of verification
+  valid: boolean;
+  // The duration of the verification in milliseconds
+  durationMs: number;
+  // The total duration, including proof serialisation and file-system cleanup
+  totalDurationMs: number;
+};
+
 /**
  * A verifier used by nodes to check tx proofs are valid.
  */
@@ -163,5 +210,10 @@ export interface ClientProtocolCircuitVerifier {
    * @param tx - The tx to verify the proof of
    * @returns True if the proof is valid, false otherwise
    */
-  verifyProof(tx: Tx): Promise<boolean>;
+  verifyProof(tx: Tx): Promise<IVCProofVerificationResult>;
+
+  /**
+   * Stop the verifier.
+   */
+  stop(): Promise<void>;
 }

package/src/interfaces/service.ts

@@ -1,5 +1,4 @@
 import type { Logger } from '@aztec/foundation/log';
-import type { Maybe } from '@aztec/foundation/types';
 
 /** Represents a local service that can be started and stopped. */
 export interface Service {
@@ -11,10 +10,13 @@ export interface Service {
 
   /** Stops the service. */
   stop(): Promise<void>;
+
+  /** Resumes the service after it was stopped */
+  resume(): void;
 }
 
 /** Tries to call stop on a given object and awaits it. Logs any errors and does not rethrow. */
-export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise<void> {
+export async function tryStop(service?: any, logger?: Logger): Promise<void> {
   try {
     return typeof service === 'object' && service && 'stop' in service && typeof service.stop === 'function'
       ? await service.stop()

package/src/interfaces/slasher.ts

@@ -0,0 +1,50 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+export type SlasherClientType = 'empire' | 'tally';
+
+export interface SlasherConfig {
+  slashOverridePayload?: EthAddress;
+  slashMinPenaltyPercentage: number;
+  slashMaxPenaltyPercentage: number;
+  slashSelfAllowed?: boolean; // Whether to allow slashes to own validators
+  slashValidatorsAlways: EthAddress[]; // Array of validator addresses
+  slashValidatorsNever: EthAddress[]; // Array of validator addresses
+  slashInactivityTargetPercentage: number; // 0-1, 0.9 means 90%. Must be greater than 0
+  slashInactivityConsecutiveEpochThreshold: number; // Number of consecutive epochs a validator must be inactive before slashing
+  slashPrunePenalty: bigint;
+  slashDataWithholdingPenalty: bigint;
+  slashInactivityPenalty: bigint;
+  slashBroadcastedInvalidBlockPenalty: bigint;
+  slashProposeInvalidAttestationsPenalty: bigint;
+  slashAttestDescendantOfInvalidPenalty: bigint;
+  slashUnknownPenalty: bigint;
+  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,
+  slashExecuteRoundsLookBack: z.number(),
+  slashSelfAllowed: z.boolean().optional(),
+}) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/tx_provider.ts

@@ -0,0 +1,17 @@
+import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+export interface ITxProvider {
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+
+  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[] }>;
+}

package/src/interfaces/validator.ts

@@ -0,0 +1,95 @@
+import type { SecretValue } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import type { SequencerConfig, SlasherConfig } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
+import type { StateReference, 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
+ */
+export interface ValidatorClientConfig {
+  /** The private keys of the validators participating in attestation duties */
+  validatorPrivateKeys?: SecretValue<`0x${string}`[]>;
+
+  /** The addresses of the validators to use with remote signers */
+  validatorAddresses?: EthAddress[];
+
+  /** Do not run the validator */
+  disableValidator: boolean;
+
+  /** Temporarily disable these specific validator addresses */
+  disabledValidators: EthAddress[];
+
+  /** Interval between polling for new attestations from peers */
+  attestationPollingIntervalMs: number;
+
+  /** 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;
+}
+
+export type ValidatorClientFullConfig = ValidatorClientConfig &
+  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 = 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(),
+}) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
+
+export const ValidatorClientFullConfigSchema = ValidatorClientConfigSchema.extend({
+  txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+  broadcastInvalidBlockProposal: z.boolean().optional(),
+  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  disableTransactions: z.boolean().optional(),
+}) satisfies ZodFor<Omit<ValidatorClientFullConfig, 'validatorPrivateKeys'>>;
+
+export interface Validator {
+  start(): Promise<void>;
+  updateConfig(config: Partial<ValidatorClientFullConfig>): void;
+
+  // Block validation responsibilities
+  createBlockProposal(
+    blockNumber: number,
+    header: CheckpointHeader,
+    archive: Fr,
+    stateReference: StateReference,
+    txs: Tx[],
+    proposerAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal | undefined>;
+  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation[] | undefined>;
+
+  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,7 +1,12 @@
+import type { PromiseWithResolvers } from '@aztec/foundation/promise';
+
 import { z } from 'zod';
 
+import type { SnapshotDataKeys } from '../snapshots/types.js';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from './merkle_tree_operations.js';
 
+export type { SnapshotDataKeys };
+
 /**
  * Defines the possible states of the world state synchronizer.
  */
@@ -15,7 +20,7 @@ export enum WorldStateRunningState {
 export interface WorldStateSyncStatus {
   latestBlockNumber: number;
   latestBlockHash: string;
-  finalisedBlockNumber: number;
+  finalizedBlockNumber: number;
   oldestHistoricBlockNumber: number;
   treesAreSynched: boolean;
 }
@@ -41,42 +46,45 @@ export interface ForkMerkleTreeOperations {
 
   /** Gets a handle that allows reading the state as it was at the given block number. */
   getSnapshot(blockNumber: number): MerkleTreeReadOperations;
+
+  /** Backups the db to the target path. */
+  backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
 }
 
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
-  /**
-   * Starts the synchronizer.
-   * @returns A promise that resolves once the initial sync is completed.
-   */
-  start(): void;
+  /** Starts the synchronizer. */
+  start(): Promise<void | PromiseWithResolvers<void>>;
 
-  /**
-   * Returns the current status of the synchronizer.
-   * @returns The current status of the synchronizer.
-   */
+  /** Returns the current status of the synchronizer. */
   status(): Promise<WorldStateSynchronizerStatus>;
 
-  /**
-   * Stops the synchronizer.
-   */
+  /** Stops the synchronizer and its database. */
   stop(): Promise<void>;
 
+  /** Stops the synchronizer from syncing, but keeps the database online. */
+  stopSync(): Promise<void>;
+
+  /** Resumes synching after a stopSync call. */
+  resumeSync(): void;
+
   /**
    * Forces an immediate sync to an optionally provided minimum block number
-   * @param minBlockNumber - The minimum block number that we must sync to
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @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): Promise<number>;
+  syncImmediate(minBlockNumber?: number, skipThrowIfTargetNotReached?: boolean): Promise<number>;
 
-  /**
-   * Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data.
-   */
+  /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
   getCommitted(): MerkleTreeReadOperations;
+
+  /** Deletes the db */
+  clear(): Promise<void>;
 }
 
 export const WorldStateSyncStatusSchema = z.object({
-  finalisedBlockNumber: z.number().int().nonnegative(),
+  finalizedBlockNumber: z.number().int().nonnegative(),
   latestBlockNumber: z.number().int().nonnegative(),
   latestBlockHash: z.string(),
   oldestHistoricBlockNumber: z.number().int().nonnegative(),

package/src/kernel/claimed_length_array.ts

@@ -0,0 +1,104 @@
+import type { Fr } from '@aztec/foundation/fields';
+import {
+  BufferReader,
+  FieldReader,
+  type Serializable,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+
+export class ClaimedLengthArray<T extends Serializable, N extends number> {
+  constructor(
+    public array: Tuple<T, N>,
+    // Named `claimedLength` instead of `length` to avoid being confused with array.length.
+    public claimedLength: number,
+  ) {}
+
+  static fromBuffer<T extends Serializable, N extends number>(
+    buffer: Buffer | BufferReader,
+    deserializer: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+    arrayLength: N,
+  ): ClaimedLengthArray<T, N> {
+    const reader = BufferReader.asReader(buffer);
+    const array = reader.readArray(arrayLength, deserializer);
+    const claimedLength = reader.readNumber();
+    return new ClaimedLengthArray(array, claimedLength);
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.array, this.claimedLength);
+  }
+
+  static fromFields<T extends Serializable, N extends number>(
+    fields: Fr[] | FieldReader,
+    deserializer: {
+      fromFields: (reader: FieldReader) => T;
+    },
+    arrayLength: N,
+  ): ClaimedLengthArray<T, N> {
+    const reader = FieldReader.asReader(fields);
+    const array = reader.readArray(arrayLength, deserializer);
+    const claimedLength = reader.readU32();
+    return new ClaimedLengthArray(array, claimedLength);
+  }
+
+  toFields() {
+    return serializeToFields(this.array, this.claimedLength);
+  }
+
+  static empty<T extends Serializable, N extends number>(
+    elem: { empty: () => T },
+    arraySize: number,
+  ): ClaimedLengthArray<T, N> {
+    const array = Array(arraySize).fill(elem.empty()) as Tuple<T, N>;
+    return new ClaimedLengthArray(array, 0);
+  }
+
+  isEmpty() {
+    return this.claimedLength === 0;
+  }
+
+  getActiveItems(): T[] {
+    return this.array.slice(0, this.claimedLength);
+  }
+
+  getSize() {
+    return this.toBuffer().length;
+  }
+
+  [inspect.custom]() {
+    return `ClaimedLengthArray {
+      array: [${this.getActiveItems()
+        .map(x => inspect(x))
+        .join(', ')}],
+      claimedLength: ${this.claimedLength},
+    `;
+  }
+}
+
+export function ClaimedLengthArrayFromBuffer<T extends Serializable, N extends number>(
+  deserializer: {
+    fromBuffer: (reader: BufferReader) => T;
+  },
+  arrayLength: N,
+): {
+  fromBuffer: (reader: BufferReader) => ClaimedLengthArray<T, N>;
+} {
+  return { fromBuffer: (reader: BufferReader) => ClaimedLengthArray.fromBuffer(reader, deserializer, arrayLength) };
+}
+
+export function ClaimedLengthArrayFromFields<T extends Serializable, N extends number>(
+  deserializer: {
+    fromFields: (reader: FieldReader) => T;
+  },
+  arrayLength: N,
+): {
+  fromFields: (reader: FieldReader) => ClaimedLengthArray<T, N>;
+} {
+  return { fromFields: (reader: FieldReader) => ClaimedLengthArray.fromFields(reader, deserializer, arrayLength) };
+}

package/src/kernel/hiding_kernel_private_inputs.ts

@@ -0,0 +1,37 @@
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { VkData } from '../vks/index.js';
+import { PrivateToPublicKernelCircuitPublicInputs } from './private_to_public_kernel_circuit_public_inputs.js';
+import { PrivateToRollupKernelCircuitPublicInputs } from './private_to_rollup_kernel_circuit_public_inputs.js';
+
+export class HidingKernelToRollupPrivateInputs {
+  constructor(
+    public previousKernelPublicInputs: PrivateToRollupKernelCircuitPublicInputs,
+    public previousKernelVkData: VkData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernelPublicInputs, this.previousKernelVkData);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readObject(PrivateToRollupKernelCircuitPublicInputs), reader.readObject(VkData));
+  }
+}
+
+export class HidingKernelToPublicPrivateInputs {
+  constructor(
+    public previousKernelPublicInputs: PrivateToPublicKernelCircuitPublicInputs,
+    public previousKernelVkData: VkData,
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousKernelPublicInputs, this.previousKernelVkData);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new this(reader.readObject(PrivateToPublicKernelCircuitPublicInputs), reader.readObject(VkData));
+  }
+}