@aztec/stdlib 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/tests/factories.ts

@@ -1,16 +1,14 @@
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from '@aztec/blob-lib';
-import { makeBatchedBlobAccumulator, makeBlockBlobPublicInputs, makeSpongeBlob } from '@aztec/blob-lib/testing';
+import { makeBatchedBlobAccumulator, makeSpongeBlob } from '@aztec/blob-lib/testing';
 import {
   ARCHIVE_HEIGHT,
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   AZTEC_MAX_EPOCH_DURATION,
-  BLOBS_PER_BLOCK,
+  CIVC_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,
+  L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
   MAX_ENQUEUED_CALLS_PER_CALL,
   MAX_ENQUEUED_CALLS_PER_TX,
@@ -26,29 +24,26 @@ 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 { EthAddress } from '@aztec/foundation/eth-address';
-import { BLS12Point, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable, Serializable, Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
@@ -78,10 +73,10 @@ import {
   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 { L2BlockHeader } from '../block/index.js';
 import {
   type ContractClassPublic,
   type ContractInstanceWithAddress,
@@ -92,6 +87,7 @@ import {
   computeContractClassId,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
+import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
 import { Gas, GasFees, GasSettings, type GasUsed } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
 import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operations.js';
@@ -124,38 +120,34 @@ import {
 import { PublicKeys, computeAddress } from '../keys/index.js';
 import { 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 { 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 } 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 { PublicTubePublicInputs } from '../rollup/public_tube_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';
@@ -167,6 +159,7 @@ 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';
@@ -200,7 +193,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 +207,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)),
   );
 }
 
@@ -355,13 +347,13 @@ 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) {
@@ -412,7 +404,7 @@ export function makePrivateKernelTailCircuitPublicInputs(
   );
 }
 
-function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
+export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   return new PrivateToPublicKernelCircuitPublicInputs(
     makeTxConstantData(seed),
     makePrivateToPublicAccumulatedData(seed + 0x200),
@@ -424,6 +416,14 @@ function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   );
 }
 
+export function makePublicTubePublicInputs(seed = 1) {
+  return new PublicTubePublicInputs(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.
@@ -445,12 +445,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),
@@ -597,7 +599,7 @@ 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),
+    anchorBlockHeader: makeHeader(seed + 0xd00, undefined),
     txContext: makeTxContext(seed + 0x1400),
     isFeePayer: false,
   });
@@ -617,11 +619,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));
 }
 
@@ -678,20 +680,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),
+    fr(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 +725,41 @@ 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 + 0x810),
+    BigInt(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) {
+  const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
+  return new CheckpointRollupPublicInputs(
+    makeEpochConstantData(seed),
+    makeAppendOnlyTreeSnapshot(seed + 0x100),
+    makeAppendOnlyTreeSnapshot(seed + 0x200),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => fr(seed), 0x300),
+    makeTuple(AZTEC_MAX_EPOCH_DURATION, () => makeFeeRecipient(seed), 0x700),
+    startBlobAccumulator.toBlobAccumulator(),
+    makeBatchedBlobAccumulator(seed + 1).toBlobAccumulator(),
+    startBlobAccumulator.finalBlobChallenges,
   );
 }
 
@@ -863,17 +771,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)),
   );
 }
 
@@ -889,12 +793,8 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs {
     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)),
+    makeEpochConstantData(seed + 0x600),
+    makeBatchedBlobAccumulator(seed).toFinalBlobAccumulator(),
   );
 }
 
@@ -916,8 +816,8 @@ export function makeHeader(
 ): BlockHeader {
   return BlockHeader.from({
     lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x100),
-    contentCommitment: makeContentCommitment(seed + 0x200),
-    state: makeStateReference(seed + 0x600),
+    state: makeStateReference(seed + 0x200),
+    spongeBlobHash: fr(seed + 0x300),
     globalVariables: makeGlobalVariables((seed += 0x700), {
       ...(blockNumber ? { blockNumber } : {}),
       ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
@@ -928,6 +828,39 @@ export function makeHeader(
   });
 }
 
+export function makeL2BlockHeader(
+  seed = 0,
+  blockNumber?: number,
+  slotNumber?: number,
+  overrides: Partial<FieldsOf<L2BlockHeader>> = {},
+) {
+  return new L2BlockHeader(
+    makeAppendOnlyTreeSnapshot(seed + 0x100),
+    overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200),
+    overrides?.state ?? makeStateReference(seed + 0x600),
+    makeGlobalVariables((seed += 0x700), {
+      ...(blockNumber ? { blockNumber } : {}),
+      ...(slotNumber ? { slotNumber: new Fr(slotNumber) } : {}),
+    }),
+    new Fr(seed + 0x800),
+    new Fr(seed + 0x900),
+    new Fr(seed + 0xa00),
+  );
+}
+
+export function makeCheckpointHeader(seed = 0) {
+  return CheckpointHeader.from({
+    lastArchiveRoot: fr(seed + 0x100),
+    contentCommitment: makeContentCommitment(seed + 0x200),
+    slotNumber: new Fr(seed + 0x300),
+    timestamp: BigInt(seed + 0x400),
+    coinbase: makeEthAddress(seed + 0x500),
+    feeRecipient: makeAztecAddress(seed + 0x600),
+    gasFees: makeGasFees(seed + 0x700),
+    totalManaUsed: fr(seed + 0x800),
+  });
+}
+
 /**
  * Makes arbitrary state reference.
  * @param seed - The seed to use for generating the state reference.
@@ -982,13 +915,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 +944,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 +988,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 +1009,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,10 +1030,14 @@ 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),
   );
 }
@@ -1100,22 +1051,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 +1076,25 @@ 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, CIVC_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),
-  );
-}
-
-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),
-  );
-}
-
-export function makePublicBaseRollupInputs(seed = 0) {
-  const tubeData = makePublicTubeData(seed);
-  const avmProofData = makeAvmProofData(seed + 0x100);
+export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
+  const publicTubeProofData = makeProofData(seed, makePublicTubePublicInputs, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH);
+  const avmProofData = makeProofData(seed + 0x100, makeAvmCircuitPublicInputs, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
   const hints = makePublicBaseRollupHints(seed + 0x200);
 
-  return PublicBaseRollupInputs.from({
-    tubeData,
+  return PublicTxBaseRollupPrivateInputs.from({
+    publicTubeProofData,
     avmProofData,
     hints,
   });
@@ -1517,6 +1449,7 @@ 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),
@@ -1550,6 +1483,7 @@ export async function makeAvmExecutionHints(
   return new AvmExecutionHints(
     fields.globalVariables,
     fields.tx,
+    fields.protocolContracts,
     fields.contractInstances,
     fields.contractClasses,
     fields.bytecodeCommitments,
@@ -1605,11 +1539,13 @@ export async function makeBloatedProcessedTx({
   version = Fr.ZERO,
   gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) }),
   vkTreeRoot = Fr.ZERO,
-  protocolContractTreeRoot = Fr.ZERO,
+  protocolContracts = makeProtocolContracts(seed + 0x100),
   globalVariables = GlobalVariables.empty(),
   newL1ToL2Snapshot = AppendOnlyTreeSnapshot.empty(),
   feePayer,
   feePaymentPublicDataWrite,
+  // The default gasUsed is the tx overhead.
+  gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
   privateOnly = false,
 }: {
   seed?: number;
@@ -1621,9 +1557,10 @@ export async function makeBloatedProcessedTx({
   vkTreeRoot?: Fr;
   globalVariables?: GlobalVariables;
   newL1ToL2Snapshot?: AppendOnlyTreeSnapshot;
-  protocolContractTreeRoot?: Fr;
+  protocolContracts?: ProtocolContracts;
   feePayer?: AztecAddress;
   feePaymentPublicDataWrite?: PublicDataWrite;
+  gasUsed?: Gas;
   privateOnly?: boolean;
 } = {}) {
   seed *= 0x1000; // Avoid clashing with the previous mock values if seed only increases by 1.
@@ -1631,30 +1568,29 @@ export async function makeBloatedProcessedTx({
   feePayer ??= await AztecAddress.random();
 
   const txConstantData = TxConstantData.empty();
-  txConstantData.historicalHeader = header!;
+  txConstantData.anchorBlockHeader = header!;
   txConstantData.txContext.chainId = chainId;
   txConstantData.txContext.version = version;
   txConstantData.txContext.gasSettings = gasSettings;
   txConstantData.vkTreeRoot = vkTreeRoot;
-  txConstantData.protocolContractTreeRoot = protocolContractTreeRoot;
+  txConstantData.protocolContractsHash = await protocolContracts.hash();
 
   const tx = !privateOnly
-    ? await mockTx(seed, { feePayer })
+    ? await mockTx(seed, { feePayer, gasUsed })
     : await mockTx(seed, {
         numberOfNonRevertiblePublicCallRequests: 0,
         numberOfRevertiblePublicCallRequests: 0,
         feePayer,
+        gasUsed,
       });
   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 });
+  const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
 
   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;
@@ -1675,8 +1611,10 @@ export async function makeBloatedProcessedTx({
     // Create avm output.
     const avmOutput = AvmCircuitPublicInputs.empty();
     // Assign data from hints.
+    avmOutput.protocolContracts = protocolContracts;
     avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
     avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
+    avmOutput.effectiveGasFees = computeEffectiveGasFees(globalVariables.gasFees, gasSettings);
     // Assign data from private.
     avmOutput.globalVariables = globalVariables;
     avmOutput.startGasUsed = tx.data.gasUsed;
@@ -1717,7 +1655,11 @@ export async function makeBloatedProcessedTx({
       i => new PublicDataWrite(new Fr(i), new Fr(i + 10)),
       seed + 0x2000,
     );
+    avmOutput.accumulatedDataArrayLengths = avmOutput.accumulatedData.getArrayLengths();
     avmOutput.gasSettings = gasSettings;
+    // Note: The fee is computed from the tx's gas used, which only includes the gas used in private. But this shouldn't
+    // be a problem for the tests.
+    avmOutput.transactionFee = transactionFee;
 
     const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, { publicInputs: avmOutput });
     avmCircuitInputs.hints.startingTreeRoots.l1ToL2MessageTree = newL1ToL2Snapshot;