@aztec/stdlib 0.0.1-fake-ceab37513c → 0.0.2-commit.217f559981

package/src/tests/factories.ts

@@ -1,16 +1,17 @@
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from '@aztec/blob-lib';
-import { makeBatchedBlobAccumulator, makeBlockBlobPublicInputs, makeSpongeBlob } from '@aztec/blob-lib/testing';
+import {
+  makeBlobAccumulator,
+  makeFinalBlobAccumulator,
+  makeFinalBlobBatchingChallenges,
+  makeSpongeBlob,
+} from '@aztec/blob-lib/testing';
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
-  AZTEC_MAX_EPOCH_DURATION,
-  BLOBS_PER_BLOCK,
+  CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  FIELDS_PER_BLOB,
-  FIXED_DA_GAS,
-  FIXED_L2_GAS,
-  GeneratorIndex,
-  L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
+  DomainSeparator,
+  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  MAX_CHECKPOINTS_PER_EPOCH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_ENQUEUED_CALLS_PER_TX,
@@ -26,29 +27,31 @@ import {
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
   MAX_PRIVATE_LOGS_PER_CALL,
   MAX_PRIVATE_LOGS_PER_TX,
+  MAX_PROTOCOL_CONTRACTS,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NESTED_RECURSIVE_PROOF_LENGTH,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
-  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
+  NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
   NUM_MSGS_PER_BASE_PARITY,
   PRIVATE_LOG_SIZE_IN_FIELDS,
   PUBLIC_DATA_TREE_HEIGHT,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
-  RECURSIVE_PROOF_LENGTH,
-  TUBE_PROOF_LENGTH,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
-import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
-import { compact, padArrayEnd } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
+import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { compact } from '@aztec/foundation/collection';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { SchnorrSignature } from '@aztec/foundation/crypto/schnorr';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
+import { Fq, Fr } from '@aztec/foundation/curves/bn254';
+import { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { BLS12Point, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable, Serializable, Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
@@ -64,8 +67,12 @@ import {
   AvmCircuitPublicInputs,
   AvmCommitCheckpointHint,
   AvmContractClassHint,
+  AvmContractDbCommitCheckpointHint,
+  AvmContractDbCreateCheckpointHint,
+  AvmContractDbRevertCheckpointHint,
   AvmContractInstanceHint,
   AvmCreateCheckpointHint,
+  AvmDebugFunctionNameHint,
   AvmExecutionHints,
   AvmGetLeafPreimageHintNullifierTree,
   AvmGetLeafPreimageHintPublicDataTree,
@@ -76,14 +83,14 @@ import {
   AvmSequentialInsertHintNullifierTree,
   AvmSequentialInsertHintPublicDataTree,
   AvmTxHint,
-  RevertCode,
 } from '../avm/index.js';
-import { PublicDataHint } from '../avm/public_data_hint.js';
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import type { L2Tips } from '../block/l2_block_source.js';
 import {
   type ContractClassPublic,
+  ContractDeploymentData,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
@@ -92,12 +99,11 @@ import {
   computeContractClassId,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
-import { Gas, GasFees, GasSettings, type GasUsed } from '../gas/index.js';
+import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
-import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
-import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
-import { ReadRequest } from '../kernel/hints/read_request.js';
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
+import { ReadRequest, ScopedReadRequest } from '../kernel/hints/read_request.js';
 import {
   ClaimedLengthArray,
   PartialPrivateTailPublicInputsForPublic,
@@ -122,61 +128,56 @@ import {
   PublicCallRequestArrayLengths,
 } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
-import { ContractClassLogFields } from '../logs/index.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
-import { PublicLog } from '../logs/public_log.js';
+import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
-import { BaseParityInputs } from '../parity/base_parity_inputs.js';
+import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js';
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import { RootParityInput } from '../parity/root_parity_input.js';
-import { RootParityInputs } from '../parity/root_parity_inputs.js';
+import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js';
+import { ProofData, ProofDataForFixedVk } from '../proofs/index.js';
 import { Proof } from '../proofs/proof.js';
-import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { makeRecursiveProof } from '../proofs/recursive_proof.js';
-import { AvmProofData } from '../rollup/avm_proof_data.js';
-import { BaseOrMergeRollupPublicInputs } from '../rollup/base_or_merge_rollup_public_inputs.js';
 import { PrivateBaseRollupHints, PublicBaseRollupHints } from '../rollup/base_rollup_hints.js';
-import { BlockMergeRollupInputs } from '../rollup/block_merge_rollup.js';
-import { BlockRootOrBlockMergePublicInputs, FeeRecipient } from '../rollup/block_root_or_block_merge_public_inputs.js';
+import { BlockConstantData } from '../rollup/block_constant_data.js';
+import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
+import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js';
 import {
-  BlockRootRollupBlobData,
-  BlockRootRollupData,
-  BlockRootRollupInputs,
-  SingleTxBlockRootRollupInputs,
-} from '../rollup/block_root_rollup.js';
-import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.js';
+  BlockRootFirstRollupPrivateInputs,
+  BlockRootSingleTxRollupPrivateInputs,
+} from '../rollup/block_root_rollup_private_inputs.js';
+import { CheckpointConstantData } from '../rollup/checkpoint_constant_data.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { CheckpointRollupPublicInputs, FeeRecipient } from '../rollup/checkpoint_rollup_public_inputs.js';
 import { EpochConstantData } from '../rollup/epoch_constant_data.js';
-import { BlockConstantData } from '../rollup/index.js';
-import { MergeRollupInputs } from '../rollup/merge_rollup.js';
-import { PreviousRollupBlockData } from '../rollup/previous_rollup_block_data.js';
-import { PreviousRollupData } from '../rollup/previous_rollup_data.js';
-import { PrivateBaseRollupInputs } from '../rollup/private_base_rollup_inputs.js';
-import { PrivateTubeData } from '../rollup/private_tube_data.js';
-import { PublicBaseRollupInputs } from '../rollup/public_base_rollup_inputs.js';
-import { PublicTubeData } from '../rollup/public_tube_data.js';
-import { RootRollupInputs, RootRollupPublicInputs } from '../rollup/root_rollup.js';
-import { PrivateBaseStateDiffHints } from '../rollup/state_diff_hints.js';
+import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
+import { PublicChonkVerifierPublicInputs } from '../rollup/public_chonk_verifier_public_inputs.js';
+import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
+import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
+import { TreeSnapshotDiffHints } from '../rollup/tree_snapshot_diff_hints.js';
+import { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
+import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { NullifierLeaf, NullifierLeafPreimage } from '../trees/nullifier_leaf.js';
 import { PublicDataTreeLeaf, PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { CallContext } from '../tx/call_context.js';
-import { ContentCommitment } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/processed_tx.js';
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
 import { PublicCallRequestWithCalldata } from '../tx/public_call_request_with_calldata.js';
 import { StateReference } from '../tx/state_reference.js';
 import { TreeSnapshots } from '../tx/tree_snapshots.js';
 import { TxConstantData } from '../tx/tx_constant_data.js';
 import { TxContext } from '../tx/tx_context.js';
+import { TxHash } from '../tx/tx_hash.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
 import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
-import { mockTx } from './mocks.js';
 
 /**
  * Creates an arbitrary side effect object with the given seed.
@@ -200,7 +201,7 @@ function makeNoteHash(seed: number) {
 }
 
 function makeNullifier(seed: number) {
-  return new Nullifier(fr(seed), seed + 1, fr(seed + 2));
+  return new Nullifier(fr(seed), fr(seed + 1), seed + 2);
 }
 
 function makePrivateLog(seed: number) {
@@ -214,8 +215,7 @@ function makePrivateLogData(seed: number) {
 function makePublicLog(seed: number) {
   return new PublicLog(
     makeAztecAddress(seed),
-    makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, fr, seed + 1),
-    PUBLIC_LOG_SIZE_IN_FIELDS,
+    new Array(10).fill(null).map((_, i) => new Fr(seed + i)),
   );
 }
 
@@ -245,8 +245,8 @@ export function makeSelector(seed: number): FunctionSelector {
   return new FunctionSelector(seed);
 }
 
-function makeReadRequest(n: number): ReadRequest {
-  return new ReadRequest(new Fr(BigInt(n)), n + 1);
+function makeScopedReadRequest(n: number): ScopedReadRequest {
+  return new ScopedReadRequest(new ReadRequest(new Fr(BigInt(n)), n + 1), makeAztecAddress(n + 2));
 }
 
 /**
@@ -259,15 +259,15 @@ function makeKeyValidationRequests(seed: number): KeyValidationRequest {
 }
 
 /**
- * Creates arbitrary KeyValidationRequestAndGenerator from the given seed.
- * @param seed - The seed to use for generating the KeyValidationRequestAndGenerator.
- * @returns A KeyValidationRequestAndGenerator.
+ * Creates arbitrary KeyValidationRequestAndSeparator from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequestAndSeparator.
+ * @returns A KeyValidationRequestAndSeparator.
  */
-function makeKeyValidationRequestAndGenerators(seed: number): KeyValidationRequestAndGenerator {
-  return new KeyValidationRequestAndGenerator(makeKeyValidationRequests(seed), fr(seed + 4));
+function makeKeyValidationRequestAndSeparators(seed: number): KeyValidationRequestAndSeparator {
+  return new KeyValidationRequestAndSeparator(makeKeyValidationRequests(seed), fr(seed + 4));
 }
 
-function makePublicDataWrite(seed = 1) {
+export function makePublicDataWrite(seed = 1) {
   return new PublicDataWrite(fr(seed), fr(seed + 1));
 }
 
@@ -307,7 +307,22 @@ export function makeContractStorageRead(seed = 1): ContractStorageRead {
 }
 
 function makeTxConstantData(seed = 1) {
-  return new TxConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201));
+  return new TxConstantData(
+    makeBlockHeader(seed),
+    makeTxContext(seed + 0x100),
+    new Fr(seed + 0x200),
+    new Fr(seed + 0x201),
+  );
+}
+
+function makePaddedTuple<T, N extends number>(
+  length: N,
+  fn: (i: number) => T,
+  nonPaddedLength = 0,
+  makePadding: () => T,
+  offset = 0,
+) {
+  return makeTuple(length, i => (i < nonPaddedLength ? fn(i + offset) : makePadding()));
 }
 
 /**
@@ -315,26 +330,86 @@ function makeTxConstantData(seed = 1) {
  * @param seed - The seed to use for generating the accumulated data.
  * @returns An accumulated data.
  */
-export function makePrivateToRollupAccumulatedData(seed = 1, full = false): PrivateToRollupAccumulatedData {
-  const tupleGenerator = full ? makeTuple : makeHalfFullTuple;
-
+export function makePrivateToRollupAccumulatedData(
+  seed = 1,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+  } = {},
+): PrivateToRollupAccumulatedData {
   return new PrivateToRollupAccumulatedData(
-    tupleGenerator(MAX_NOTE_HASHES_PER_TX, fr, seed + 0x120, Fr.zero),
-    tupleGenerator(MAX_NULLIFIERS_PER_TX, fr, seed + 0x200, Fr.zero),
-    tupleGenerator(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x600, ScopedL2ToL1Message.empty),
-    tupleGenerator(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, seed + 0x700, PrivateLog.empty),
-    tupleGenerator(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeScopedLogHash, seed + 0xa00, ScopedLogHash.empty), // contract class logs
+    makePaddedTuple(MAX_NOTE_HASHES_PER_TX, fr, numNoteHashes, Fr.zero, seed + 0x100),
+    makePaddedTuple(MAX_NULLIFIERS_PER_TX, fr, numNullifiers, Fr.zero, seed + 0x200),
+    makePaddedTuple(
+      MAX_L2_TO_L1_MSGS_PER_TX,
+      makeScopedL2ToL1Message,
+      numL2ToL1Messages,
+      ScopedL2ToL1Message.empty,
+      seed + 0x300,
+    ),
+    makePaddedTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, numPrivateLogs, PrivateLog.empty, seed + 0x400),
+    makePaddedTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_TX,
+      makeScopedLogHash,
+      numContractClassLogs,
+      ScopedLogHash.empty,
+      seed + 0x500,
+    ),
   );
 }
 
-export function makePrivateToPublicAccumulatedData(seed = 1) {
+export function makePrivateToPublicAccumulatedData(
+  seed = 1,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    numEnqueuedCalls = MAX_ENQUEUED_CALLS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+    numEnqueuedCalls?: number;
+  } = {},
+) {
   return new PrivateToPublicAccumulatedData(
-    makeTuple(MAX_NOTE_HASHES_PER_TX, fr, seed),
-    makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x100),
-    makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x200),
-    makeTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, seed + 0x700),
-    makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeScopedLogHash, seed + 0x900),
-    makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x500),
+    makePaddedTuple(MAX_NOTE_HASHES_PER_TX, fr, numNoteHashes, Fr.zero, seed),
+    makePaddedTuple(MAX_NULLIFIERS_PER_TX, fr, numNullifiers, Fr.zero, seed + 0x100),
+    makePaddedTuple(
+      MAX_L2_TO_L1_MSGS_PER_TX,
+      makeScopedL2ToL1Message,
+      numL2ToL1Messages,
+      ScopedL2ToL1Message.empty,
+      seed + 0x200,
+    ),
+    makePaddedTuple(MAX_PRIVATE_LOGS_PER_TX, makePrivateLog, numPrivateLogs, PrivateLog.empty, seed + 0x300),
+    makePaddedTuple(
+      MAX_CONTRACT_CLASS_LOGS_PER_TX,
+      makeScopedLogHash,
+      numContractClassLogs,
+      ScopedLogHash.empty,
+      seed + 0x400,
+    ),
+    makePaddedTuple(
+      MAX_ENQUEUED_CALLS_PER_TX,
+      makePublicCallRequest,
+      numEnqueuedCalls,
+      PublicCallRequest.empty,
+      seed + 0x500,
+    ),
   );
 }
 
@@ -355,17 +430,20 @@ function makeAvmAccumulatedData(seed = 1) {
     makeTuple(MAX_NOTE_HASHES_PER_TX, fr, seed),
     makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x100),
     makeTuple(MAX_L2_TO_L1_MSGS_PER_TX, makeScopedL2ToL1Message, seed + 0x200),
-    makeTuple(MAX_PUBLIC_LOGS_PER_TX, makePublicLog, seed + 0x300),
+    FlatPublicLogs.fromLogs(new Array(20).fill(null).map((_, i) => makePublicLog(seed + i * 256))),
     makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, makePublicDataWrite, seed + 0x400),
   );
 }
 
 function makeAvmAccumulatedDataArrayLengths(seed = 1) {
-  return new AvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2, seed + 3, seed + 4);
+  return new AvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2, seed + 3);
 }
 
 export function makeGas(seed = 1) {
-  return new Gas(seed, seed + 1);
+  // Constrain gas values to u32 range
+  const daGas = seed % 2 ** 32;
+  const l2Gas = (seed + 1) % 2 ** 32;
+  return new Gas(daGas, l2Gas);
 }
 
 /**
@@ -412,7 +490,7 @@ export function makePrivateKernelTailCircuitPublicInputs(
   );
 }
 
-function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
+export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   return new PrivateToPublicKernelCircuitPublicInputs(
     makeTxConstantData(seed),
     makePrivateToPublicAccumulatedData(seed + 0x200),
@@ -424,18 +502,23 @@ function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   );
 }
 
+export function makePublicChonkVerifierPublicInputs(seed = 1) {
+  return new PublicChonkVerifierPublicInputs(makePrivateToPublicKernelCircuitPublicInputs(seed), fr(seed + 0x1000));
+}
+
+export function makeProtocolContracts(seed = 1) {
+  return new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, makeAztecAddress, seed));
+}
+
 /**
  * Creates arbitrary public kernel circuit public inputs.
  * @param seed - The seed to use for generating the kernel circuit public inputs.
  * @returns Public kernel circuit public inputs.
  */
-export function makePrivateToRollupKernelCircuitPublicInputs(
-  seed = 1,
-  fullAccumulatedData = true,
-): PrivateToRollupKernelCircuitPublicInputs {
+export function makePrivateToRollupKernelCircuitPublicInputs(seed = 1): PrivateToRollupKernelCircuitPublicInputs {
   return new PrivateToRollupKernelCircuitPublicInputs(
     makeTxConstantData(seed + 0x100),
-    makePrivateToRollupAccumulatedData(seed, fullAccumulatedData),
+    makePrivateToRollupAccumulatedData(seed),
     makeGas(seed + 0x600),
     makeAztecAddress(seed + 0x700),
     BigInt(seed + 0x800),
@@ -445,12 +528,14 @@ export function makePrivateToRollupKernelCircuitPublicInputs(
 function makeAvmCircuitPublicInputs(seed = 1) {
   return new AvmCircuitPublicInputs(
     makeGlobalVariables(seed),
+    makeProtocolContracts(seed + 0x100),
     makeTreeSnapshots(seed + 0x10),
     makeGas(seed + 0x20),
     makeGasSettings(),
     makeGasFees(seed + 0x30),
     makeAztecAddress(seed + 0x40),
-    makePublicCallRequestArrayLengths(seed + 0x40),
+    fr(seed + 0x50),
+    makePublicCallRequestArrayLengths(seed + 0x60),
     makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x100),
     makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x200),
     makePublicCallRequest(seed + 0x300),
@@ -571,16 +656,24 @@ function makeClaimedLengthArray<T extends Serializable, N extends number>(
  */
 export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicInputs {
   return PrivateCircuitPublicInputs.from({
-    includeByTimestamp: BigInt(seed + 0x31415),
+    expirationTimestamp: BigInt(seed + 0x31415),
     callContext: makeCallContext(seed, { isStaticCall: true }),
     argsHash: fr(seed + 0x100),
     returnsHash: fr(seed + 0x200),
     minRevertibleSideEffectCounter: fr(0),
-    noteHashReadRequests: makeClaimedLengthArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x300),
-    nullifierReadRequests: makeClaimedLengthArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x310),
-    keyValidationRequestsAndGenerators: makeClaimedLengthArray(
+    noteHashReadRequests: makeClaimedLengthArray(
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      makeScopedReadRequest,
+      seed + 0x300,
+    ),
+    nullifierReadRequests: makeClaimedLengthArray(
+      MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+      makeScopedReadRequest,
+      seed + 0x310,
+    ),
+    keyValidationRequestsAndSeparators: makeClaimedLengthArray(
       MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
-      makeKeyValidationRequestAndGenerators,
+      makeKeyValidationRequestAndSeparators,
       seed + 0x320,
     ),
     noteHashes: makeClaimedLengthArray(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
@@ -597,7 +690,9 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
     contractClassLogsHashes: makeClaimedLengthArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
     startSideEffectCounter: fr(seed + 0x849),
     endSideEffectCounter: fr(seed + 0x850),
-    historicalHeader: makeHeader(seed + 0xd00, undefined),
+    expectedNonRevertibleSideEffectCounter: fr(seed + 0x860),
+    expectedRevertibleSideEffectCounter: fr(seed + 0x861),
+    anchorBlockHeader: makeBlockHeader(seed + 0xd00),
     txContext: makeTxContext(seed + 0x1400),
     isFeePayer: false,
   });
@@ -607,8 +702,8 @@ export function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<Global
   return GlobalVariables.from({
     chainId: new Fr(seed),
     version: new Fr(seed + 1),
-    blockNumber: seed + 2,
-    slotNumber: new Fr(seed + 3),
+    blockNumber: BlockNumber(seed + 2),
+    slotNumber: SlotNumber(seed + 3),
     timestamp: BigInt(seed + 4),
     coinbase: EthAddress.fromField(new Fr(seed + 5)),
     feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),
@@ -617,11 +712,11 @@ export function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<Global
   });
 }
 
-export function makeGasFees(seed = 1) {
+function makeGasFees(seed = 1) {
   return new GasFees(seed, seed + 1);
 }
 
-export function makeFeeRecipient(seed = 1) {
+function makeFeeRecipient(seed = 1) {
   return new FeeRecipient(EthAddress.fromField(fr(seed)), fr(seed + 1));
 }
 
@@ -631,7 +726,9 @@ export function makeFeeRecipient(seed = 1) {
  * @returns An append only tree snapshot.
  */
 export function makeAppendOnlyTreeSnapshot(seed = 1): AppendOnlyTreeSnapshot {
-  return new AppendOnlyTreeSnapshot(fr(seed), seed);
+  // Constrain nextAvailableLeafIndex to u32 range
+  const nextAvailableLeafIndex = seed % 2 ** 32;
+  return new AppendOnlyTreeSnapshot(fr(seed), nextAvailableLeafIndex);
 }
 
 /**
@@ -678,20 +775,39 @@ function makeBlockConstantData(seed = 1, globalVariables?: GlobalVariables) {
     fr(seed + 0x300),
     fr(seed + 0x400),
     globalVariables ?? makeGlobalVariables(seed + 0x500),
+    fr(seed + 0x600),
+  );
+}
+
+function makeCheckpointConstantData(seed = 1) {
+  return new CheckpointConstantData(
+    fr(seed),
+    fr(seed + 1),
+    fr(seed + 2),
+    fr(seed + 3),
+    fr(seed + 4),
+    SlotNumber(seed + 5),
+    makeEthAddress(seed + 6),
+    makeAztecAddress(seed + 7),
+    makeGasFees(seed + 8),
   );
 }
 
+function makeEpochConstantData(seed = 1) {
+  return new EpochConstantData(fr(seed), fr(seed + 1), fr(seed + 2), fr(seed + 3), fr(seed + 4));
+}
+
 /**
  * Makes arbitrary base or merge rollup circuit public inputs.
  * @param seed - The seed to use for generating the base rollup circuit public inputs.
  * @param blockNumber - The block number to use for generating the base rollup circuit public inputs.
  * @returns A base or merge rollup circuit public inputs.
  */
-export function makeBaseOrMergeRollupPublicInputs(
+export function makeTxRollupPublicInputs(
   seed = 0,
   globalVariables: GlobalVariables | undefined = undefined,
-): BaseOrMergeRollupPublicInputs {
-  return new BaseOrMergeRollupPublicInputs(
+): TxRollupPublicInputs {
+  return new TxRollupPublicInputs(
     1,
     makeBlockConstantData(seed + 0x200, globalVariables),
     makePartialStateReference(seed + 0x300),
@@ -704,154 +820,42 @@ export function makeBaseOrMergeRollupPublicInputs(
   );
 }
 
-function makeEpochConstantData(seed = 1) {
-  return new EpochConstantData(fr(seed), fr(seed + 1), fr(seed + 2));
-}
-
 /**
  * Makes arbitrary block merge or block root rollup circuit public inputs.
  * @param seed - The seed to use for generating the block merge or block root rollup circuit public inputs.
  * @param blockNumber - The block number to use for generating the block merge or block root rollup circuit public inputs.
  * @returns A block merge or block root rollup circuit public inputs.
  */
-export function makeBlockRootOrBlockMergeRollupPublicInputs(
-  seed = 0,
-  globalVariables: GlobalVariables | undefined = undefined,
-): BlockRootOrBlockMergePublicInputs {
-  return new BlockRootOrBlockMergePublicInputs(
-    makeEpochConstantData(seed + 0x100),
+export function makeBlockRollupPublicInputs(seed = 0): BlockRollupPublicInputs {
+  return new BlockRollupPublicInputs(
+    makeCheckpointConstantData(seed + 0x100),
     makeAppendOnlyTreeSnapshot(seed + 0x200),
     makeAppendOnlyTreeSnapshot(seed + 0x300),
-    globalVariables ?? makeGlobalVariables(seed + 0x400),
-    globalVariables ?? makeGlobalVariables(seed + 0x500),
-    fr(seed + 0x600),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x650),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x700),
-    makeBlockBlobPublicInputs(seed),
-  );
-}
-
-/**
- * Makes arbitrary previous rollup data.
- * @param seed - The seed to use for generating the previous rollup data.
- * @param globalVariables - The global variables to use when generating the previous rollup data.
- * @returns A previous rollup data.
- */
-export function makePreviousRollupData(
-  seed = 0,
-  globalVariables: GlobalVariables | undefined = undefined,
-): PreviousRollupData {
-  return new PreviousRollupData(
-    makeBaseOrMergeRollupPublicInputs(seed, globalVariables),
-    makeRecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>(
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      seed + 0x50,
-    ),
-    makeVkData(seed + 0x100),
-  );
-}
-
-/**
- * Makes arbitrary previous rollup block data.
- * @param seed - The seed to use for generating the previous rollup block data.
- * @param globalVariables - The global variables to use when generating the previous rollup block data.
- * @returns A previous rollup block data.
- */
-export function makePreviousRollupBlockData(
-  seed = 0,
-  globalVariables: GlobalVariables | undefined = undefined,
-): PreviousRollupBlockData {
-  return new PreviousRollupBlockData(
-    makeBlockRootOrBlockMergeRollupPublicInputs(seed, globalVariables),
-    makeRecursiveProof<typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>(
-      NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
-      seed + 0x50,
-    ),
-    makeVkData(seed + 0x100),
-  );
-}
-
-/**
- * Makes root rollup inputs.
- * @param seed - The seed to use for generating the root rollup inputs.
- * @param globalVariables - The global variables to use.
- * @returns A root rollup inputs.
- */
-export function makeRootRollupInputs(seed = 0, globalVariables?: GlobalVariables): RootRollupInputs {
-  return new RootRollupInputs([
-    makePreviousRollupBlockData(seed, globalVariables),
-    makePreviousRollupBlockData(seed + 0x1000, globalVariables),
-  ]);
-}
-
-function makeBlockRootRollupData(seed = 0) {
-  return new BlockRootRollupData(
-    makeRootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>(NESTED_RECURSIVE_PROOF_LENGTH, seed + 0x2000),
-    makeTuple(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, fr, 0x2100),
-    makeTuple(ARCHIVE_HEIGHT, fr, 0x2200),
-    makeTuple(ARCHIVE_HEIGHT, fr, 0x2300),
-    makeHeader(seed + 0x2400),
-    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 0x2500)),
-    makeBatchedBlobAccumulator(seed + 0x2600).finalBlobChallenges,
-    fr(seed + 0x2700),
-  );
-}
-
-function makeBlockRootRollupBlobData(seed = 0) {
-  return new BlockRootRollupBlobData(
-    makeTuple(FIELDS_PER_BLOB * BLOBS_PER_BLOCK, fr, 0x2500),
-    makeTuple(BLOBS_PER_BLOCK, () => BLS12Point.random()),
-    fr(seed + 0x2700),
-  );
-}
-
-/**
- * Makes block root rollup inputs.
- * @param seed - The seed to use for generating the root rollup inputs.
- * @param globalVariables - The global variables to use.
- * @returns A block root rollup inputs.
- */
-export function makeBlockRootRollupInputs(seed = 0, globalVariables?: GlobalVariables): BlockRootRollupInputs {
-  return new BlockRootRollupInputs(
-    [makePreviousRollupData(seed, globalVariables), makePreviousRollupData(seed + 0x1000, globalVariables)],
-    makeBlockRootRollupData(seed + 0x2000),
-    makeBlockRootRollupBlobData(seed + 0x4000),
-  );
-}
-
-export function makeSingleTxBlockRootRollupInputs(seed = 0, globalVariables?: GlobalVariables) {
-  return new SingleTxBlockRootRollupInputs(
-    [makePreviousRollupData(seed, globalVariables)],
-    makeBlockRootRollupData(seed + 0x2000),
-    makeBlockRootRollupBlobData(seed + 0x4000),
-  );
-}
-
-/**
- * Makes empty block root rollup inputs.
- * @param seed - The seed to use for generating the root rollup inputs.
- * @param globalVariables - The global variables to use.
- * @returns A block root rollup inputs.
- */
-export function makeEmptyBlockRootRollupInputs(
-  seed = 0,
-  globalVariables?: GlobalVariables,
-): EmptyBlockRootRollupInputs {
-  return new EmptyBlockRootRollupInputs(
-    makeBlockRootRollupData(seed + 0x1000),
-    makeBlockConstantData(0x2500, globalVariables),
+    makeStateReference(seed + 0x400),
+    makeStateReference(seed + 0x500),
+    makeSpongeBlob(seed + 0x600),
+    makeSpongeBlob(seed + 0x700),
+    BigInt(seed + 0x800),
+    fr(seed + 0x820),
+    fr(seed + 0x830),
+    fr(seed + 0x840),
+    fr(seed + 0x850),
+    fr(seed + 0x860),
   );
 }
 
-export function makeRootParityInput<PROOF_LENGTH extends number>(
-  proofSize: PROOF_LENGTH,
-  seed = 0,
-): RootParityInput<PROOF_LENGTH> {
-  return new RootParityInput<PROOF_LENGTH>(
-    makeRecursiveProof<PROOF_LENGTH>(proofSize, seed),
-    VerificationKeyAsFields.makeFake(seed + 0x100),
-    makeTuple(VK_TREE_HEIGHT, fr, 0x200),
-    makeParityPublicInputs(seed + 0x300),
+export function makeCheckpointRollupPublicInputs(seed = 0) {
+  return new CheckpointRollupPublicInputs(
+    makeEpochConstantData(seed),
+    makeAppendOnlyTreeSnapshot(seed + 0x100),
+    makeAppendOnlyTreeSnapshot(seed + 0x200),
+    makeAppendOnlyTreeSnapshot(seed + 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x350),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
+    makeBlobAccumulator(seed + 0x600),
+    makeBlobAccumulator(seed + 0x700),
+    makeFinalBlobBatchingChallenges(seed + 0x800),
   );
 }
 
@@ -863,17 +867,13 @@ export function makeParityPublicInputs(seed = 0): ParityPublicInputs {
   );
 }
 
-export function makeBaseParityInputs(seed = 0): BaseParityInputs {
-  return new BaseParityInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
+export function makeParityBasePrivateInputs(seed = 0): ParityBasePrivateInputs {
+  return new ParityBasePrivateInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
 }
 
-export function makeRootParityInputs(seed = 0): RootParityInputs {
-  return new RootParityInputs(
-    makeTuple(
-      NUM_BASE_PARITY_PER_ROOT_PARITY,
-      () => makeRootParityInput<typeof RECURSIVE_PROOF_LENGTH>(RECURSIVE_PROOF_LENGTH),
-      seed + 0x4100,
-    ),
+export function makeParityRootPrivateInputs(seed = 0) {
+  return new ParityRootPrivateInputs(
+    makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, () => makeProofData(seed, makeParityPublicInputs)),
   );
 }
 
@@ -887,47 +887,46 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
   return new RootRollupPublicInputs(
     fr(seed + 0x100),
     fr(seed + 0x200),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
-    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x500),
-    fr(seed + 0x700),
-    fr(seed + 0x701),
-    fr(seed + 0x702),
-    fr(seed + 0x703),
-    fr(seed + 0x704),
-    FinalBlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed)),
+    fr(seed + 0x300),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400),
+    makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500),
+    makeEpochConstantData(seed + 0x600),
+    makeFinalBlobAccumulator(seed + 0x700),
   );
 }
 
-/**
- * Makes content commitment
- */
-export function makeContentCommitment(seed = 0): ContentCommitment {
-  return new ContentCommitment(fr(seed + 0x100), fr(seed + 0x200), fr(seed + 0x300));
-}
-
-/**
- * Makes header.
- */
-export function makeHeader(
+export function makeBlockHeader(
   seed = 0,
-  blockNumber: number | undefined = undefined,
-  slotNumber: number | undefined = undefined,
-  overrides: Partial<FieldsOf<BlockHeader>> = {},
+  overrides: Partial<FieldsOf<Omit<BlockHeader, 'globalVariables'>>> & Partial<FieldsOf<GlobalVariables>> = {},
 ): BlockHeader {
   return BlockHeader.from({
     lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x100),
-    contentCommitment: makeContentCommitment(seed + 0x200),
-    state: makeStateReference(seed + 0x600),
-    globalVariables: makeGlobalVariables((seed += 0x700), {
-      ...(blockNumber ? { blockNumber } : {}),
-      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
-    }),
+    state: makeStateReference(seed + 0x200),
+    spongeBlobHash: fr(seed + 0x300),
+    globalVariables: makeGlobalVariables((seed += 0x700), overrides),
     totalFees: fr(seed + 0x800),
     totalManaUsed: fr(seed + 0x900),
     ...overrides,
   });
 }
 
+export function makeCheckpointHeader(seed = 0, overrides: Partial<FieldsOf<CheckpointHeader>> = {}) {
+  return CheckpointHeader.from({
+    lastArchiveRoot: fr(seed + 0x100),
+    blockHeadersHash: fr(seed + 0x150),
+    blobsHash: fr(seed + 0x200),
+    inHash: fr(seed + 0x210),
+    epochOutHash: fr(seed + 0x220),
+    slotNumber: SlotNumber(seed + 0x300),
+    timestamp: BigInt(seed + 0x400),
+    coinbase: makeEthAddress(seed + 0x500),
+    feeRecipient: makeAztecAddress(seed + 0x600),
+    gasFees: makeGasFees(seed + 0x700),
+    totalManaUsed: fr(seed + 0x800),
+    ...overrides,
+  });
+}
+
 /**
  * Makes arbitrary state reference.
  * @param seed - The seed to use for generating the state reference.
@@ -965,7 +964,7 @@ function makeCountedL2ToL1Message(seed = 0) {
   return new CountedL2ToL1Message(makeL2ToL1Message(seed), seed + 2);
 }
 
-function makeScopedL2ToL1Message(seed = 1) {
+export function makeScopedL2ToL1Message(seed = 1) {
   return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
 }
 
@@ -982,13 +981,28 @@ export function makePartialStateReference(seed = 0): PartialStateReference {
   );
 }
 
-/**
- * Makes arbitrary merge rollup inputs.
- * @param seed - The seed to use for generating the merge rollup inputs.
- * @returns A merge rollup inputs.
- */
-export function makeMergeRollupInputs(seed = 0): MergeRollupInputs {
-  return new MergeRollupInputs([makePreviousRollupData(seed), makePreviousRollupData(seed + 0x1000)]);
+export function makeTxMergeRollupPrivateInputs(seed = 0): TxMergeRollupPrivateInputs {
+  return new TxMergeRollupPrivateInputs([
+    makeProofData(seed, makeTxRollupPublicInputs),
+    makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
+  ]);
+}
+
+export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
+  return new BlockRootFirstRollupPrivateInputs(
+    makeProofData(seed, makeParityPublicInputs),
+    [makeProofData(seed + 0x1000, makeTxRollupPublicInputs), makeProofData(seed + 0x2000, makeTxRollupPublicInputs)],
+    makeAppendOnlyTreeSnapshot(seed + 0x3000),
+    makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH),
+    makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT),
+  );
+}
+
+export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
+  return new BlockRootSingleTxRollupPrivateInputs(
+    makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
+    makeSiblingPath(seed + 0x4000, ARCHIVE_HEIGHT),
+  );
 }
 
 /**
@@ -996,8 +1010,11 @@ export function makeMergeRollupInputs(seed = 0): MergeRollupInputs {
  * @param seed - The seed to use for generating the merge rollup inputs.
  * @returns A block merge rollup inputs.
  */
-export function makeBlockMergeRollupInputs(seed = 0): BlockMergeRollupInputs {
-  return new BlockMergeRollupInputs([makePreviousRollupBlockData(seed), makePreviousRollupBlockData(seed + 0x1000)]);
+export function makeBlockMergeRollupPrivateInputs(seed = 0) {
+  return new BlockMergeRollupPrivateInputs([
+    makeProofData(seed, makeBlockRollupPublicInputs),
+    makeProofData(seed + 0x1000, makeBlockRollupPublicInputs),
+  ]);
 }
 
 /**
@@ -1037,11 +1054,11 @@ export function makePublicDataTreeLeafPreimage(seed = 0): PublicDataTreeLeafPrei
 }
 
 /**
- * Creates an instance of PrivateBaseStateDiffHints with arbitrary values based on the provided seed.
+ * Creates an instance of TreeSnapshotDiffHints with arbitrary values based on the provided seed.
  * @param seed - The seed to use for generating the hints.
- * @returns A PrivateBaseStateDiffHints object.
+ * @returns A TreeSnapshotDiffHints object.
  */
-export function makePrivateBaseStateDiffHints(seed = 1): PrivateBaseStateDiffHints {
+export function makeTreeSnapshotDiffHints(seed = 1): TreeSnapshotDiffHints {
   const nullifierPredecessorPreimages = makeTuple(
     MAX_NULLIFIERS_PER_TX,
     x => makeNullifierLeafPreimage(x),
@@ -1058,24 +1075,20 @@ export function makePrivateBaseStateDiffHints(seed = 1): PrivateBaseStateDiffHin
 
   const sortedNullifierIndexes = makeTuple(MAX_NULLIFIERS_PER_TX, i => i, seed + 0x4000);
 
-  const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
+  const noteHashSubtreeRootSiblingPath = makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
 
-  const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x6000);
+  const nullifierSubtreeRootSiblingPath = makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x6000);
 
-  const feeWriteLowLeafPreimage = makePublicDataTreeLeafPreimage(seed + 0x7000);
-  const feeWriteLowLeafMembershipWitness = makeMembershipWitness(PUBLIC_DATA_TREE_HEIGHT, seed + 0x8000);
-  const feeWriteSiblingPath = makeTuple(PUBLIC_DATA_TREE_HEIGHT, fr, seed + 0x9000);
+  const feePayerBalanceMembershipWitness = makeMembershipWitness(PUBLIC_DATA_TREE_HEIGHT, seed + 0x8000);
 
-  return new PrivateBaseStateDiffHints(
+  return new TreeSnapshotDiffHints(
+    noteHashSubtreeRootSiblingPath,
     nullifierPredecessorPreimages,
     nullifierPredecessorMembershipWitnesses,
     sortedNullifiers,
     sortedNullifierIndexes,
-    noteHashSubtreeSiblingPath,
-    nullifierSubtreeSiblingPath,
-    feeWriteLowLeafPreimage,
-    feeWriteLowLeafMembershipWitness,
-    feeWriteSiblingPath,
+    nullifierSubtreeRootSiblingPath,
+    feePayerBalanceMembershipWitness,
   );
 }
 
@@ -1083,14 +1096,26 @@ function makeVkData(seed = 1) {
   return new VkData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
 }
 
-function makePrivateTubeData(seed = 1, kernelPublicInputs?: PrivateToRollupKernelCircuitPublicInputs) {
-  return new PrivateTubeData(
-    kernelPublicInputs ?? makePrivateToRollupKernelCircuitPublicInputs(seed, true),
-    makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
+export function makeProofData<T extends Bufferable, PROOF_LENGTH extends number>(
+  seed = 0,
+  makePublicInputs: (seed: number) => T,
+  proofSize: PROOF_LENGTH = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH as PROOF_LENGTH,
+) {
+  return new ProofData(
+    makePublicInputs(seed),
+    makeRecursiveProof<PROOF_LENGTH>(proofSize, seed + 0x100),
     makeVkData(seed + 0x200),
   );
 }
 
+function makeProofDataForFixedVk<T extends Bufferable, PROOF_LENGTH extends number>(
+  seed = 0,
+  makePublicInputs: (seed: number) => T,
+  proofSize: PROOF_LENGTH = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH as PROOF_LENGTH,
+) {
+  return new ProofDataForFixedVk(makePublicInputs(seed), makeRecursiveProof<PROOF_LENGTH>(proofSize, seed + 0x100));
+}
+
 function makeContractClassLogFields(seed = 1) {
   return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
 }
@@ -1100,22 +1125,22 @@ function makePrivateBaseRollupHints(seed = 1) {
 
   const startSpongeBlob = makeSpongeBlob(seed + 0x200);
 
-  const stateDiffHints = makePrivateBaseStateDiffHints(seed + 0x600);
+  const treeSnapshotDiffHints = makeTreeSnapshotDiffHints(seed + 0x600);
 
-  const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
+  const anchorBlockArchiveSiblingPath = makeSiblingPath(seed + 0x9000, ARCHIVE_HEIGHT);
 
   const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x800);
 
   const constants = makeBlockConstantData(0x100);
 
-  const feePayerFeeJuiceBalanceReadHint = PublicDataHint.empty();
+  const feePayerBalanceLeafPreimage = PublicDataTreeLeafPreimage.empty();
 
   return PrivateBaseRollupHints.from({
     start,
     startSpongeBlob,
-    stateDiffHints,
-    feePayerFeeJuiceBalanceReadHint,
-    archiveRootMembershipWitness,
+    treeSnapshotDiffHints,
+    feePayerBalanceLeafPreimage,
+    anchorBlockArchiveSiblingPath,
     contractClassLogsFields,
     constants,
   });
@@ -1125,44 +1150,33 @@ function makePublicBaseRollupHints(seed = 1) {
   return PublicBaseRollupHints.from({
     startSpongeBlob: makeSpongeBlob(seed),
     lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x1000),
-    archiveRootMembershipWitness: makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x2000),
+    anchorBlockArchiveSiblingPath: makeSiblingPath(seed + 0x2000, ARCHIVE_HEIGHT),
     contractClassLogsFields: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x3000),
   });
 }
 
-export function makePrivateBaseRollupInputs(seed = 0) {
-  const tubeData = makePrivateTubeData(seed);
-  const hints = makePrivateBaseRollupHints(seed + 0x100);
-
-  return PrivateBaseRollupInputs.from({
-    tubeData,
-    hints,
+export function makePrivateTxBaseRollupPrivateInputs(seed = 0) {
+  return PrivateTxBaseRollupPrivateInputs.from({
+    hidingKernelProofData: makeProofData(seed, makePrivateToRollupKernelCircuitPublicInputs, CHONK_PROOF_LENGTH),
+    hints: makePrivateBaseRollupHints(seed + 0x100),
   });
 }
 
-function makePublicTubeData(seed = 1) {
-  return new PublicTubeData(
-    makePrivateToPublicKernelCircuitPublicInputs(seed),
-    makeRecursiveProof<typeof TUBE_PROOF_LENGTH>(TUBE_PROOF_LENGTH, seed + 0x100),
-    makeVkData(seed + 0x200),
+export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
+  const publicChonkVerifierProofData = makeProofData(
+    seed,
+    makePublicChonkVerifierPublicInputs,
+    RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
   );
-}
-
-function makeAvmProofData(seed = 1) {
-  return new AvmProofData(
-    makeAvmCircuitPublicInputs(seed),
-    makeRecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, seed + 0x100),
-    makeVkData(seed + 0x200),
+  const avmProofData = makeProofDataForFixedVk(
+    seed + 0x100,
+    makeAvmCircuitPublicInputs,
+    AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   );
-}
-
-export function makePublicBaseRollupInputs(seed = 0) {
-  const tubeData = makePublicTubeData(seed);
-  const avmProofData = makeAvmProofData(seed + 0x100);
   const hints = makePublicBaseRollupHints(seed + 0x200);
 
-  return PublicBaseRollupInputs.from({
-    tubeData,
+  return PublicTxBaseRollupPrivateInputs.from({
+    publicChonkVerifierProofData,
     avmProofData,
     hints,
   });
@@ -1250,13 +1264,10 @@ export async function makeMapAsync<T>(size: number, fn: (i: number) => Promise<[
   return new Map(await makeArrayAsync(size, i => fn(i + offset)));
 }
 
-export function makePublicKeys(seed = 0): PublicKeys {
-  return new PublicKeys(
-    new Point(new Fr(seed + 0), new Fr(seed + 1), false),
-    new Point(new Fr(seed + 2), new Fr(seed + 3), false),
-    new Point(new Fr(seed + 4), new Fr(seed + 5), false),
-    new Point(new Fr(seed + 6), new Fr(seed + 7), false),
-  );
+export async function makePublicKeys(seed = 0): Promise<PublicKeys> {
+  const f = (offset: number) => Grumpkin.mul(Grumpkin.generator, new Fq(seed + offset));
+
+  return new PublicKeys(await f(0), await f(1), await f(2), await f(3));
 }
 
 export async function makeContractInstanceFromClassId(
@@ -1272,15 +1283,15 @@ export async function makeContractInstanceFromClassId(
   const salt = new Fr(seed);
   const initializationHash = overrides?.initializationHash ?? new Fr(seed + 1);
   const deployer = overrides?.deployer ?? new AztecAddress(new Fr(seed + 2));
-  const publicKeys = overrides?.publicKeys ?? makePublicKeys(seed + 3);
+  const publicKeys = overrides?.publicKeys ?? (await makePublicKeys(seed + 3));
 
   const saltedInitializationHash = await poseidon2HashWithSeparator(
     [salt, initializationHash, deployer],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
   const partialAddress = await poseidon2HashWithSeparator(
     [classId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
+    DomainSeparator.PARTIAL_ADDRESS,
   );
   const address = await computeAddress(publicKeys, partialAddress);
   return new SerializableContractInstance({
@@ -1429,6 +1440,30 @@ export function makeAvmCheckpointActionRevertCheckpointHint(seed = 0): AvmRevert
   );
 }
 
+export function makeAvmContractDbCheckpointActionCreateCheckpointHint(seed = 0): AvmContractDbCreateCheckpointHint {
+  return new AvmContractDbCreateCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmContractDbCheckpointActionCommitCheckpointHint(seed = 0): AvmContractDbCommitCheckpointHint {
+  return new AvmContractDbCommitCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmContractDbCheckpointActionRevertCheckpointHint(seed = 0): AvmContractDbRevertCheckpointHint {
+  return new AvmContractDbRevertCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
 /**
  * Makes arbitrary AvmContractInstanceHint.
  * @param seed - The seed to use for generating the state reference.
@@ -1436,6 +1471,7 @@ export function makeAvmCheckpointActionRevertCheckpointHint(seed = 0): AvmRevert
  */
 export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
   return new AvmContractInstanceHint(
+    seed,
     new AztecAddress(new Fr(seed)),
     new Fr(seed + 0x2),
     new AztecAddress(new Fr(seed + 0x3)),
@@ -1451,19 +1487,28 @@ export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
   );
 }
 
+/**
+ * Makes arbitrary AvmDebugFunctionNameHint.
+ * @param seed - The seed to use for generating the hint.
+ * @returns AvmDebugFunctionNameHint.
+ */
+export function makeAvmDebugFunctionNameHint(seed = 0): AvmDebugFunctionNameHint {
+  return new AvmDebugFunctionNameHint(new AztecAddress(new Fr(seed)), new Fr(seed + 0x2), `function-${seed}`);
+}
+
 /* Makes arbitrary AvmContractClassHint.
  * @param seed - The seed to use for generating the state reference.
  * @returns AvmContractClassHint.
  */
 export function makeAvmContractClassHint(seed = 0): AvmContractClassHint {
   const bytecode = makeBytes(32, seed + 0x5);
-  return new AvmContractClassHint(new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
+  return new AvmContractClassHint(seed, new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
 }
 
 export async function makeAvmBytecodeCommitmentHint(seed = 0): Promise<AvmBytecodeCommitmentHint> {
   const classId = new Fr(seed + 2);
   const bytecode = makeBytes(32, seed + 0x5);
-  return new AvmBytecodeCommitmentHint(classId, await computePublicBytecodeCommitment(bytecode));
+  return new AvmBytecodeCommitmentHint(seed, classId, await computePublicBytecodeCommitment(bytecode));
 }
 
 export async function makePublicCallRequestWithCalldata(seed = 0): Promise<PublicCallRequestWithCalldata> {
@@ -1478,11 +1523,23 @@ export async function makePublicCallRequestWithCalldata(seed = 0): Promise<Publi
   return new PublicCallRequestWithCalldata(publicCallRequest, calldata);
 }
 
+export function makeContractClassLog(seed = 0): ContractClassLog {
+  return new ContractClassLog(makeAztecAddress(seed + 0x1000), makeContractClassLogFields(seed + 0x2000), seed % 20);
+}
+
+export function makeContractDeploymentData(seed = 0): ContractDeploymentData {
+  const contractClassLogs = makeArray(seed % 20, i => makeContractClassLog(i), seed + 0x1000);
+  const privateLogs = makeArray(seed % 20, i => makePrivateLog(i), seed + 0x2000);
+  return new ContractDeploymentData(contractClassLogs, privateLogs);
+}
+
 export async function makeAvmTxHint(seed = 0): Promise<AvmTxHint> {
   return new AvmTxHint(
     `txhash-${seed}`,
     makeGasSettings(),
     makeGasFees(seed + 0x1000),
+    makeContractDeploymentData(seed + 0x2000),
+    makeContractDeploymentData(seed + 0x3000),
     {
       noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
       nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
@@ -1517,9 +1574,26 @@ export async function makeAvmExecutionHints(
   const fields = {
     globalVariables: makeGlobalVariables(seed + 0x4000),
     tx: await makeAvmTxHint(seed + 0x4100),
+    protocolContracts: new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, makeAztecAddress, seed + 0x4600)),
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
     bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
+    debugFunctionNames: makeArray(baseLength + 5, makeAvmDebugFunctionNameHint, seed + 0x4a00),
+    contractDbCreateCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionCreateCheckpointHint,
+      seed + 0x5900,
+    ),
+    contractDbCommitCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionCommitCheckpointHint,
+      seed + 0x5b00,
+    ),
+    contractDbRevertCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionRevertCheckpointHint,
+      seed + 0x5d00,
+    ),
     startingTreeRoots: makeTreeSnapshots(seed + 0x4900),
     getSiblingPathHints: makeArray(baseLength + 5, makeAvmGetSiblingPathHint, seed + 0x4b00),
     getPreviousValueIndexHints: makeArray(baseLength + 5, makeAvmGetPreviousValueIndexHint, seed + 0x4d00),
@@ -1550,9 +1624,14 @@ export async function makeAvmExecutionHints(
   return new AvmExecutionHints(
     fields.globalVariables,
     fields.tx,
+    fields.protocolContracts,
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,
+    fields.debugFunctionNames,
+    fields.contractDbCreateCheckpointHints,
+    fields.contractDbCommitCheckpointHints,
+    fields.contractDbRevertCheckpointHints,
     fields.startingTreeRoots,
     fields.getSiblingPathHints,
     fields.getPreviousValueIndexHints,
@@ -1596,155 +1675,85 @@ export function fr(n: number): Fr {
   return new Fr(BigInt(n));
 }
 
-/** Makes a bloated processed tx for testing purposes. */
-export async function makeBloatedProcessedTx({
-  seed = 1,
-  header,
-  db,
-  chainId = Fr.ZERO,
-  version = Fr.ZERO,
-  gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) }),
-  vkTreeRoot = Fr.ZERO,
-  protocolContractTreeRoot = Fr.ZERO,
-  globalVariables = GlobalVariables.empty(),
-  newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
-  feePayer,
-  feePaymentPublicDataWrite,
-  privateOnly = false,
-}: {
-  seed?: number;
-  header?: BlockHeader;
-  db?: MerkleTreeReadOperations;
-  chainId?: Fr;
-  version?: Fr;
-  gasSettings?: GasSettings;
-  vkTreeRoot?: Fr;
-  globalVariables?: GlobalVariables;
-  newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
-  protocolContractTreeRoot?: Fr;
-  feePayer?: AztecAddress;
-  feePaymentPublicDataWrite?: PublicDataWrite;
-  privateOnly?: boolean;
-} = {}) {
-  seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
-  header ??= db?.getInitialHeader() ?? makeHeader(seed);
-  feePayer ??= await AztecAddress.random();
-
-  const txConstantData = TxConstantData.empty();
-  txConstantData.historicalHeader = header!;
-  txConstantData.txContext.chainId = chainId;
-  txConstantData.txContext.version = version;
-  txConstantData.txContext.gasSettings = gasSettings;
-  txConstantData.vkTreeRoot = vkTreeRoot;
-  txConstantData.protocolContractTreeRoot = protocolContractTreeRoot;
-
-  const tx = !privateOnly
-    ? await mockTx(seed, { feePayer })
-    : await mockTx(seed, {
-        numberOfNonRevertiblePublicCallRequests: 0,
-        numberOfRevertiblePublicCallRequests: 0,
-        feePayer,
-      });
-  tx.data.constants = txConstantData;
-
-  // No side effects were created in mockTx. The default gasUsed is the tx overhead.
-  tx.data.gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS });
-
-  if (privateOnly) {
-    const data = makePrivateToRollupAccumulatedData(seed + 0x1000);
-    clearContractClassLogs(data);
-
-    const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
-    feePaymentPublicDataWrite ??= new PublicDataWrite(Fr.random(), Fr.random());
-
-    tx.data.forRollup!.end = data;
-
-    await tx.recomputeHash();
-    return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
-  } else {
-    const dataFromPrivate = tx.data.forPublic!;
-
-    const nonRevertibleData = dataFromPrivate.nonRevertibleAccumulatedData;
-
-    // Create revertible data.
-    const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000);
-    clearContractClassLogs(revertibleData);
-    revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
-    dataFromPrivate.revertibleAccumulatedData = revertibleData;
-
-    // Create avm output.
-    const avmOutput = AvmCircuitPublicInputs.empty();
-    // Assign data from hints.
-    avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
-    avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
-    // Assign data from private.
-    avmOutput.globalVariables = globalVariables;
-    avmOutput.startGasUsed = tx.data.gasUsed;
-    avmOutput.gasSettings = gasSettings;
-    avmOutput.feePayer = feePayer;
-    avmOutput.publicCallRequestArrayLengths = new PublicCallRequestArrayLengths(
-      tx.data.numberOfNonRevertiblePublicCallRequests(),
-      tx.data.numberOfRevertiblePublicCallRequests(),
-      tx.data.hasTeardownPublicCallRequest(),
-    );
-    avmOutput.publicSetupCallRequests = dataFromPrivate.nonRevertibleAccumulatedData.publicCallRequests;
-    avmOutput.publicAppLogicCallRequests = dataFromPrivate.revertibleAccumulatedData.publicCallRequests;
-    avmOutput.publicTeardownCallRequest = dataFromPrivate.publicTeardownCallRequest;
-    avmOutput.previousNonRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
-      dataFromPrivate.nonRevertibleAccumulatedData.noteHashes,
-      dataFromPrivate.nonRevertibleAccumulatedData.nullifiers,
-      dataFromPrivate.nonRevertibleAccumulatedData.l2ToL1Msgs,
-    );
-    avmOutput.previousNonRevertibleAccumulatedDataArrayLengths =
-      avmOutput.previousNonRevertibleAccumulatedData.getArrayLengths();
-    avmOutput.previousRevertibleAccumulatedData = new PrivateToAvmAccumulatedData(
-      dataFromPrivate.revertibleAccumulatedData.noteHashes,
-      dataFromPrivate.revertibleAccumulatedData.nullifiers,
-      dataFromPrivate.revertibleAccumulatedData.l2ToL1Msgs,
-    );
-    avmOutput.previousRevertibleAccumulatedDataArrayLengths =
-      avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
-    // Assign final data emitted from avm.
-    avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
-    avmOutput.accumulatedData.nullifiers = padArrayEnd(
-      nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
-      Fr.ZERO,
-      MAX_NULLIFIERS_PER_TX,
-    );
-    avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
-    avmOutput.accumulatedData.publicDataWrites = makeTuple(
-      MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-      i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
-      seed + 0x2000,
-    );
-    avmOutput.gasSettings = gasSettings;
-
-    const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
-    avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;
-
-    const gasUsed = {
-      totalGas: Gas.empty(),
-      teardownGas: Gas.empty(),
-      publicGas: Gas.empty(),
-      billedGas: Gas.empty(),
-    } satisfies GasUsed;
-
-    await tx.recomputeHash();
-    return makeProcessedTxFromTxWithPublicCalls(
-      tx,
-      {
-        type: ProvingRequestType.PUBLIC_VM,
-        inputs: avmCircuitInputs,
-      },
-      gasUsed,
-      RevertCode.OK,
-      undefined /* revertReason */,
-    );
-  }
-}
-
-// Remove all contract class log hashes from the data as they are not required for the current tests.
-// If they are needed one day, change this to create the random fields first and update the data with real hashes of those fields.
-function clearContractClassLogs(data: { contractClassLogsHashes: ScopedLogHash[] }) {
-  data.contractClassLogsHashes.forEach((_, i) => (data.contractClassLogsHashes[i] = ScopedLogHash.empty()));
+/**
+ * Creates a random TxScopedL2Log with private log data.
+ */
+export function randomTxScopedPrivateL2Log(opts?: {
+  tag?: Fr;
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockTimestamp?: bigint;
+  noteHashes?: Fr[];
+  firstNullifier?: Fr;
+}) {
+  const log = PrivateLog.random(opts?.tag);
+  return new TxScopedL2Log(
+    opts?.txHash ?? TxHash.random(),
+    BlockNumber(opts?.blockNumber ?? 1),
+    opts?.blockTimestamp ?? 1n,
+    log.getEmittedFields(),
+    opts?.noteHashes ?? [Fr.random(), Fr.random()],
+    opts?.firstNullifier ?? Fr.random(),
+  );
+}
+
+/**
+ * Creates a random TxScopedL2Log with public log data.
+ */
+export async function randomTxScopedPublicL2Log(opts?: {
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockTimestamp?: bigint;
+  noteHashes?: Fr[];
+  firstNullifier?: Fr;
+}) {
+  const log = await PublicLog.random();
+  return new TxScopedL2Log(
+    opts?.txHash ?? TxHash.random(),
+    BlockNumber(opts?.blockNumber ?? 1),
+    opts?.blockTimestamp ?? 1n,
+    log.getEmittedFields(),
+    opts?.noteHashes ?? [Fr.random(), Fr.random()],
+    opts?.firstNullifier ?? Fr.random(),
+  );
+}
+
+/**
+ * Creates L2Tips with all tips pointing to the same block number.
+ * Useful for mocking aztecNode.getL2Tips() in tests.
+ * @param blockNumber - The block number to use for all tips.
+ * @param hash - Optional hash for the block (defaults to empty string).
+ * @param checkpointNumber - Optional checkpoint number (defaults to blockNumber).
+ * @param checkpointHash - Optional checkpoint hash (defaults to block hash).
+ * @returns L2Tips object with all tips at the same block.
+ */
+export function makeL2Tips(
+  blockNumber: number | BlockNumber,
+  hash = '',
+  checkpointNumber?: number | CheckpointNumber,
+  checkpointHash?: string,
+): L2Tips {
+  const bn = typeof blockNumber === 'number' ? BlockNumber(blockNumber) : blockNumber;
+  const cpn =
+    checkpointNumber !== undefined
+      ? typeof checkpointNumber === 'number'
+        ? CheckpointNumber(checkpointNumber)
+        : checkpointNumber
+      : CheckpointNumber.fromBlockNumber(bn);
+  const cph = checkpointHash ?? hash;
+  return {
+    proposed: { number: bn, hash },
+    checkpointed: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    proven: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    finalized: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+  };
 }