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

package/dest/tests/factories.js

@@ -1,21 +1,21 @@
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from '@aztec/blob-lib';
-import { makeBatchedBlobAccumulator, makeBlockBlobPublicInputs, makeSpongeBlob } from '@aztec/blob-lib/testing';
-import { ARCHIVE_HEIGHT, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AZTEC_MAX_EPOCH_DURATION, BLOBS_PER_BLOCK, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FIELDS_PER_BLOB, FIXED_DA_GAS, FIXED_L2_GAS, GeneratorIndex, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_ENQUEUED_CALLS_PER_CALL, MAX_ENQUEUED_CALLS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_CALL, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL, MAX_PRIVATE_LOGS_PER_TX, 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, 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, VK_TREE_HEIGHT } from '@aztec/constants';
+import { makeBatchedBlobAccumulator, makeSpongeBlob } from '@aztec/blob-lib/testing';
+import { ARCHIVE_HEIGHT, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AZTEC_MAX_EPOCH_DURATION, CIVC_PROOF_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FIXED_DA_GAS, FIXED_L2_GAS, GeneratorIndex, 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, MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_CALL, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, 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_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_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, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
 import { 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 { MembershipWitness } from '@aztec/foundation/trees';
 import { FunctionSelector } from '../abi/function_selector.js';
 import { ContractStorageRead } from '../avm/contract_storage_read.js';
 import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_request.js';
 import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths, AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCircuitInputs, AvmCircuitPublicInputs, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractInstanceHint, AvmCreateCheckpointHint, AvmExecutionHints, AvmGetLeafPreimageHintNullifierTree, AvmGetLeafPreimageHintPublicDataTree, AvmGetLeafValueHint, AvmGetPreviousValueIndexHint, AvmGetSiblingPathHint, AvmRevertCheckpointHint, 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 { L2BlockHeader } from '../block/index.js';
 import { SerializableContractInstance, computeContractClassId, computePublicBytecodeCommitment } from '../contract/index.js';
+import { computeEffectiveGasFees } from '../fees/transaction_fee.js';
 import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
@@ -33,33 +33,31 @@ import { CountedPublicCallRequest, PublicCallRequest, PublicCallRequestArrayLeng
 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 { BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_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 { 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';
@@ -71,6 +69,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';
@@ -98,7 +97,7 @@ function makeNoteHash(seed) {
     return new NoteHash(fr(seed), seed + 1);
 }
 function makeNullifier(seed) {
-    return new Nullifier(fr(seed), seed + 1, fr(seed + 2));
+    return new Nullifier(fr(seed), fr(seed + 1), seed + 2);
 }
 function makePrivateLog(seed) {
     return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed), PRIVATE_LOG_SIZE_IN_FIELDS);
@@ -107,7 +106,7 @@ function makePrivateLogData(seed) {
     return new PrivateLogData(makePrivateLog(seed + 0x100), seed, seed + 1);
 }
 function makePublicLog(seed) {
-    return new PublicLog(makeAztecAddress(seed), makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, fr, seed + 1), PUBLIC_LOG_SIZE_IN_FIELDS);
+    return new PublicLog(makeAztecAddress(seed), new Array(10).fill(null).map((_, i)=>new Fr(seed + i)));
 }
 /**
  * Creates an arbitrary tx context with the given seed.
@@ -199,10 +198,10 @@ function makePrivateToAvmAccumulatedDataArrayLengths(seed = 1) {
     return new PrivateToAvmAccumulatedDataArrayLengths(seed, seed + 1, seed + 2);
 }
 function makeAvmAccumulatedData(seed = 1) {
-    return new AvmAccumulatedData(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), makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, makePublicDataWrite, seed + 0x400));
+    return new AvmAccumulatedData(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), 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);
@@ -229,9 +228,15 @@ export function makeGas(seed = 1) {
     const forRollup = !isForPublic ? new PartialPrivateTailPublicInputsForRollup(makePrivateToRollupAccumulatedData(seed + 0x100)) : undefined;
     return new PrivateKernelTailCircuitPublicInputs(makeTxConstantData(seed + 0x300), makeGas(seed + 0x600), makeAztecAddress(seed + 0x700), BigInt(seed + 0x800), forPublic, forRollup);
 }
-function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
+export function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
     return new PrivateToPublicKernelCircuitPublicInputs(makeTxConstantData(seed), makePrivateToPublicAccumulatedData(seed + 0x200), makePrivateToPublicAccumulatedData(seed + 0x300), makePublicCallRequest(seed + 0x400), makeGas(seed + 0x500), makeAztecAddress(seed + 0x600), BigInt(seed + 0x700));
 }
+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.
@@ -240,7 +245,7 @@ function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
     return new PrivateToRollupKernelCircuitPublicInputs(makeTxConstantData(seed + 0x100), makePrivateToRollupAccumulatedData(seed, fullAccumulatedData), makeGas(seed + 0x600), makeAztecAddress(seed + 0x700), BigInt(seed + 0x800));
 }
 function makeAvmCircuitPublicInputs(seed = 1) {
-    return new AvmCircuitPublicInputs(makeGlobalVariables(seed), makeTreeSnapshots(seed + 0x10), makeGas(seed + 0x20), makeGasSettings(), makeGasFees(seed + 0x30), makeAztecAddress(seed + 0x40), makePublicCallRequestArrayLengths(seed + 0x40), makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x100), makeTuple(MAX_ENQUEUED_CALLS_PER_TX, makePublicCallRequest, seed + 0x200), makePublicCallRequest(seed + 0x300), makePrivateToAvmAccumulatedDataArrayLengths(seed + 0x400), makePrivateToAvmAccumulatedDataArrayLengths(seed + 0x410), makePrivateToAvmAccumulatedData(seed + 0x500), makePrivateToAvmAccumulatedData(seed + 0x600), makeTreeSnapshots(seed + 0x700), makeGas(seed + 0x750), makeAvmAccumulatedDataArrayLengths(seed + 0x800), makeAvmAccumulatedData(seed + 0x800), fr(seed + 0x900), false);
+    return new AvmCircuitPublicInputs(makeGlobalVariables(seed), makeProtocolContracts(seed + 0x100), makeTreeSnapshots(seed + 0x10), makeGas(seed + 0x20), makeGasSettings(), makeGasFees(seed + 0x30), makeAztecAddress(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), makePrivateToAvmAccumulatedDataArrayLengths(seed + 0x400), makePrivateToAvmAccumulatedDataArrayLengths(seed + 0x410), makePrivateToAvmAccumulatedData(seed + 0x500), makePrivateToAvmAccumulatedData(seed + 0x600), makeTreeSnapshots(seed + 0x700), makeGas(seed + 0x750), makeAvmAccumulatedDataArrayLengths(seed + 0x800), makeAvmAccumulatedData(seed + 0x800), fr(seed + 0x900), false);
 }
 function makeSiblingPath(seed, size) {
     return makeTuple(size, fr, seed);
@@ -340,7 +345,7 @@ function makeClaimedLengthArray(arraySize, makeItem, seed, length = arraySize) {
         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
     });
@@ -358,10 +363,10 @@ export function makeGlobalVariables(seed = 1, overrides = {}) {
         ...compact(overrides)
     });
 }
-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));
 }
 /**
@@ -401,95 +406,42 @@ export function makeFeeRecipient(seed = 1) {
     return new SchnorrSignature(Buffer.alloc(SchnorrSignature.SIZE, seed));
 }
 function makeBlockConstantData(seed = 1, globalVariables) {
-    return new BlockConstantData(makeAppendOnlyTreeSnapshot(seed + 0x100), makeAppendOnlyTreeSnapshot(seed + 0x200), fr(seed + 0x300), fr(seed + 0x400), globalVariables ?? makeGlobalVariables(seed + 0x500));
+    return new BlockConstantData(makeAppendOnlyTreeSnapshot(seed + 0x100), makeAppendOnlyTreeSnapshot(seed + 0x200), 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(seed = 0, globalVariables = undefined) {
-    return new BaseOrMergeRollupPublicInputs(1, makeBlockConstantData(seed + 0x200, globalVariables), makePartialStateReference(seed + 0x300), makePartialStateReference(seed + 0x400), makeSpongeBlob(seed + 0x500), makeSpongeBlob(seed + 0x600), fr(seed + 0x901), fr(seed + 0x902), fr(seed + 0x903));
-}
-function makeEpochConstantData(seed = 1) {
-    return new EpochConstantData(fr(seed), fr(seed + 1), fr(seed + 2));
+ */ export function makeTxRollupPublicInputs(seed = 0, globalVariables = undefined) {
+    return new TxRollupPublicInputs(1, makeBlockConstantData(seed + 0x200, globalVariables), makePartialStateReference(seed + 0x300), makePartialStateReference(seed + 0x400), makeSpongeBlob(seed + 0x500), makeSpongeBlob(seed + 0x600), fr(seed + 0x901), fr(seed + 0x902), fr(seed + 0x903));
 }
 /**
  * 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 = undefined) {
-    return new BlockRootOrBlockMergePublicInputs(makeEpochConstantData(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 = undefined) {
-    return new PreviousRollupData(makeBaseOrMergeRollupPublicInputs(seed, globalVariables), makeRecursiveProof(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 = undefined) {
-    return new PreviousRollupBlockData(makeBlockRootOrBlockMergeRollupPublicInputs(seed, globalVariables), makeRecursiveProof(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) {
-    return new RootRollupInputs([
-        makePreviousRollupBlockData(seed, globalVariables),
-        makePreviousRollupBlockData(seed + 0x1000, globalVariables)
-    ]);
-}
-function makeBlockRootRollupData(seed = 0) {
-    return new BlockRootRollupData(makeRootParityInput(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));
+ */ export function makeBlockRollupPublicInputs(seed = 0) {
+    return new BlockRollupPublicInputs(makeCheckpointConstantData(seed + 0x100), makeAppendOnlyTreeSnapshot(seed + 0x200), makeAppendOnlyTreeSnapshot(seed + 0x300), 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));
 }
-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) {
-    return new BlockRootRollupInputs([
-        makePreviousRollupData(seed, globalVariables),
-        makePreviousRollupData(seed + 0x1000, globalVariables)
-    ], makeBlockRootRollupData(seed + 0x2000), makeBlockRootRollupBlobData(seed + 0x4000));
-}
-export function makeSingleTxBlockRootRollupInputs(seed = 0, 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) {
-    return new EmptyBlockRootRollupInputs(makeBlockRootRollupData(seed + 0x1000), makeBlockConstantData(0x2500, globalVariables));
-}
-export function makeRootParityInput(proofSize, seed = 0) {
-    return new RootParityInput(makeRecursiveProof(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);
 }
 export function makeParityPublicInputs(seed = 0) {
     return new ParityPublicInputs(new Fr(BigInt(seed + 0x200)), new Fr(BigInt(seed + 0x300)), new Fr(BigInt(seed + 0x400)));
 }
-export function makeBaseParityInputs(seed = 0) {
-    return new BaseParityInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
+export function makeParityBasePrivateInputs(seed = 0) {
+    return new ParityBasePrivateInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
 }
-export function makeRootParityInputs(seed = 0) {
-    return new RootParityInputs(makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, ()=>makeRootParityInput(RECURSIVE_PROOF_LENGTH), seed + 0x4100));
+export function makeParityRootPrivateInputs(seed = 0) {
+    return new ParityRootPrivateInputs(makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, ()=>makeProofData(seed, makeParityPublicInputs)));
 }
 /**
  * Makes root rollup public inputs.
@@ -497,7 +449,7 @@ export function makeRootParityInputs(seed = 0) {
  * @param blockNumber - The block number to use in the global variables of a header.
  * @returns A root rollup public inputs.
  */ export function makeRootRollupPublicInputs(seed = 0) {
-    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)));
+    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), makeEpochConstantData(seed + 0x600), makeBatchedBlobAccumulator(seed).toFinalBlobAccumulator());
 }
 /**
  * Makes content commitment
@@ -509,8 +461,8 @@ export function makeRootParityInputs(seed = 0) {
  */ export function makeHeader(seed = 0, blockNumber = undefined, slotNumber = undefined, overrides = {}) {
     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
@@ -524,6 +476,28 @@ export function makeRootParityInputs(seed = 0) {
         ...overrides
     });
 }
+export function makeL2BlockHeader(seed = 0, blockNumber, slotNumber, overrides = {}) {
+    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.
@@ -556,24 +530,29 @@ function makeScopedL2ToL1Message(seed = 1) {
  */ export function makePartialStateReference(seed = 0) {
     return new PartialStateReference(makeAppendOnlyTreeSnapshot(MAX_NOTE_HASHES_PER_TX * seed), makeAppendOnlyTreeSnapshot(MAX_NULLIFIERS_PER_TX * (seed + 1)), makeAppendOnlyTreeSnapshot(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * (seed + 2)));
 }
-/**
- * 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) {
-    return new MergeRollupInputs([
-        makePreviousRollupData(seed),
-        makePreviousRollupData(seed + 0x1000)
+export function makeTxMergeRollupPrivateInputs(seed = 0) {
+    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));
+}
 /**
  * Makes arbitrary block merge rollup inputs.
  * @param seed - The seed to use for generating the merge rollup inputs.
  * @returns A block merge rollup inputs.
- */ export function makeBlockMergeRollupInputs(seed = 0) {
-    return new BlockMergeRollupInputs([
-        makePreviousRollupBlockData(seed),
-        makePreviousRollupBlockData(seed + 0x1000)
+ */ export function makeBlockMergeRollupPrivateInputs(seed = 0) {
+    return new BlockMergeRollupPrivateInputs([
+        makeProofData(seed, makeBlockRollupPublicInputs),
+        makeProofData(seed + 0x1000, makeBlockRollupPublicInputs)
     ]);
 }
 /**
@@ -605,26 +584,24 @@ function makeScopedL2ToL1Message(seed = 1) {
     return new PublicDataTreeLeafPreimage(makePublicDataTreeLeaf(seed), new Fr(seed + 2), BigInt(seed + 3));
 }
 /**
- * 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.
- */ export function makePrivateBaseStateDiffHints(seed = 1) {
+ * @returns A TreeSnapshotDiffHints object.
+ */ export function makeTreeSnapshotDiffHints(seed = 1) {
     const nullifierPredecessorPreimages = makeTuple(MAX_NULLIFIERS_PER_TX, (x)=>makeNullifierLeafPreimage(x), seed + 0x1000);
     const nullifierPredecessorMembershipWitnesses = makeTuple(MAX_NULLIFIERS_PER_TX, (x)=>makeMembershipWitness(NULLIFIER_TREE_HEIGHT, x), seed + 0x2000);
     const sortedNullifiers = makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x3000);
     const sortedNullifierIndexes = makeTuple(MAX_NULLIFIERS_PER_TX, (i)=>i, seed + 0x4000);
-    const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
-    const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_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);
-    return new PrivateBaseStateDiffHints(nullifierPredecessorPreimages, nullifierPredecessorMembershipWitnesses, sortedNullifiers, sortedNullifierIndexes, noteHashSubtreeSiblingPath, nullifierSubtreeSiblingPath, feeWriteLowLeafPreimage, feeWriteLowLeafMembershipWitness, feeWriteSiblingPath);
+    const noteHashSubtreeRootSiblingPath = makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
+    const nullifierSubtreeRootSiblingPath = makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x6000);
+    const feePayerBalanceMembershipWitness = makeMembershipWitness(PUBLIC_DATA_TREE_HEIGHT, seed + 0x8000);
+    return new TreeSnapshotDiffHints(noteHashSubtreeRootSiblingPath, nullifierPredecessorPreimages, nullifierPredecessorMembershipWitnesses, sortedNullifiers, sortedNullifierIndexes, nullifierSubtreeRootSiblingPath, feePayerBalanceMembershipWitness);
 }
 function makeVkData(seed = 1) {
     return new VkData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
 }
-function makePrivateTubeData(seed = 1, kernelPublicInputs) {
-    return new PrivateTubeData(kernelPublicInputs ?? makePrivateToRollupKernelCircuitPublicInputs(seed, true), makeRecursiveProof(TUBE_PROOF_LENGTH, seed + 0x100), makeVkData(seed + 0x200));
+export function makeProofData(seed = 0, makePublicInputs, proofSize = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
+    return new ProofData(makePublicInputs(seed), makeRecursiveProof(proofSize, seed + 0x100), makeVkData(seed + 0x200));
 }
 function makeContractClassLogFields(seed = 1) {
     return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
@@ -632,17 +609,17 @@ function makeContractClassLogFields(seed = 1) {
 function makePrivateBaseRollupHints(seed = 1) {
     const start = makePartialStateReference(seed + 0x100);
     const startSpongeBlob = makeSpongeBlob(seed + 0x200);
-    const stateDiffHints = makePrivateBaseStateDiffHints(seed + 0x600);
-    const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
+    const treeSnapshotDiffHints = makeTreeSnapshotDiffHints(seed + 0x600);
+    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
     });
@@ -651,30 +628,22 @@ 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(TUBE_PROOF_LENGTH, seed + 0x100), makeVkData(seed + 0x200));
-}
-function makeAvmProofData(seed = 1) {
-    return new AvmProofData(makeAvmCircuitPublicInputs(seed), makeRecursiveProof(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
     });
@@ -891,6 +860,7 @@ export async function makeAvmTxHint(seed = 0) {
     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),
@@ -908,7 +878,7 @@ export async function makeAvmTxHint(seed = 0) {
         revertCheckpointHints: makeArray(baseLength + 5, makeAvmCheckpointActionRevertCheckpointHint, seed + 0x5d00),
         ...overrides
     };
-    return new AvmExecutionHints(fields.globalVariables, fields.tx, fields.contractInstances, fields.contractClasses, fields.bytecodeCommitments, fields.startingTreeRoots, fields.getSiblingPathHints, fields.getPreviousValueIndexHints, fields.getLeafPreimageHintPublicDataTree, fields.getLeafPreimageHintNullifierTree, fields.getLeafValueHints, fields.sequentialInsertHintsPublicDataTree, fields.sequentialInsertHintsNullifierTree, fields.appendLeavesHints, fields.createCheckpointHints, fields.commitCheckpointHints, fields.revertCheckpointHints);
+    return new AvmExecutionHints(fields.globalVariables, fields.tx, fields.protocolContracts, fields.contractInstances, fields.contractClasses, fields.bytecodeCommitments, fields.startingTreeRoots, fields.getSiblingPathHints, fields.getPreviousValueIndexHints, fields.getLeafPreimageHintPublicDataTree, fields.getLeafPreimageHintNullifierTree, fields.getLeafValueHints, fields.sequentialInsertHintsPublicDataTree, fields.sequentialInsertHintsNullifierTree, fields.appendLeavesHints, fields.createCheckpointHints, fields.commitCheckpointHints, fields.revertCheckpointHints);
 }
 /**
  * Creates arbitrary AvmCircuitInputs.
@@ -932,34 +902,35 @@ export async function makeAvmTxHint(seed = 0) {
 }
 /** 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 } = {}) {
+}), vkTreeRoot = 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 *= 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.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
+        feePayer,
+        gasUsed
     }) : await mockTx(seed, {
         numberOfNonRevertiblePublicCallRequests: 0,
         numberOfRevertiblePublicCallRequests: 0,
-        feePayer
+        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;
         await tx.recomputeHash();
@@ -975,8 +946,10 @@ export async function makeAvmTxHint(seed = 0) {
         // 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;
@@ -995,7 +968,11 @@ export async function makeAvmTxHint(seed = 0) {
         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.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
         });

package/dest/tests/mocks.d.ts

@@ -2,22 +2,23 @@ import { Secp256k1Signer } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
+import { L2BlockHeader } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
 import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
 import type { ContractInstanceWithAddress } from '../contract/index.js';
+import { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
-import { ExtendedNote, UniqueNote } from '../note/extended_note.js';
+import { UniqueNote } from '../note/unique_note.js';
 import { BlockAttestation } from '../p2p/block_attestation.js';
 import { BlockProposal } from '../p2p/block_proposal.js';
 import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import { BlockHeader, StateReference, Tx } from '../tx/index.js';
+import { StateReference, Tx } from '../tx/index.js';
 import { TxSimulationResult } from '../tx/simulated_tx.js';
 import { TxHash } from '../tx/tx_hash.js';
 export declare const randomTxHash: () => TxHash;
-export declare const randomExtendedNote: ({ note, recipient, contractAddress, txHash, storageSlot, }?: Partial<ExtendedNote>) => Promise<ExtendedNote>;
 export declare const randomUniqueNote: ({ note, recipient, contractAddress, txHash, storageSlot, noteNonce, }?: Partial<UniqueNote>) => Promise<UniqueNote>;
-export declare const mockTx: (seed?: number, { numberOfNonRevertiblePublicCallRequests, numberOfRevertiblePublicCallRequests, numberOfRevertibleNullifiers, hasPublicTeardownCallRequest, publicCalldataSize, feePayer, clientIvcProof, maxPriorityFeesPerGas, chainId, version, vkTreeRoot, protocolContractTreeRoot, }?: {
+export declare const mockTx: (seed?: number, { numberOfNonRevertiblePublicCallRequests, numberOfRevertiblePublicCallRequests, numberOfRevertibleNullifiers, hasPublicTeardownCallRequest, publicCalldataSize, feePayer, clientIvcProof, maxPriorityFeesPerGas, gasUsed, chainId, version, vkTreeRoot, protocolContractsHash, }?: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
     numberOfRevertibleNullifiers?: number;
@@ -26,10 +27,11 @@ export declare const mockTx: (seed?: number, { numberOfNonRevertiblePublicCallRe
     feePayer?: AztecAddress;
     clientIvcProof?: ClientIvcProof;
     maxPriorityFeesPerGas?: GasFees;
+    gasUsed?: Gas;
     chainId?: Fr;
     version?: Fr;
     vkTreeRoot?: Fr;
-    protocolContractTreeRoot?: Fr;
+    protocolContractsHash?: Fr;
 }) => Promise<Tx>;
 export declare const mockTxForRollup: (seed?: number, opts?: Parameters<typeof mockTx>[1]) => Promise<Tx>;
 export declare const mockSimulatedTx: (seed?: number) => Promise<TxSimulationResult>;
@@ -43,7 +45,9 @@ export declare const randomDeployedContract: () => Promise<{
 }>;
 export interface MakeConsensusPayloadOptions {
     signer?: Secp256k1Signer;
-    header?: BlockHeader;
+    attesterSigner?: Secp256k1Signer;
+    proposerSigner?: Secp256k1Signer;
+    header?: L2BlockHeader;
     archive?: Fr;
     stateReference?: StateReference;
     txHashes?: TxHash[];
@@ -52,7 +56,7 @@ export interface MakeConsensusPayloadOptions {
 export declare const makeAndSignCommitteeAttestationsAndSigners: (attestationsAndSigners: CommitteeAttestationsAndSigners, signer?: Secp256k1Signer) => import("../block/index.js").Signature;
 export declare const makeBlockProposal: (options?: MakeConsensusPayloadOptions) => BlockProposal;
 export declare const makeBlockAttestation: (options?: MakeConsensusPayloadOptions) => BlockAttestation;
-export declare const makeBlockAttestationFromBlock: (block: L2Block, signer?: Secp256k1Signer) => BlockAttestation;
+export declare const makeBlockAttestationFromBlock: (block: L2Block, attesterSigner?: Secp256k1Signer, proposerSigner?: Secp256k1Signer) => BlockAttestation;
 export declare function randomPublishedL2Block(l2BlockNumber: number, opts?: {
     signers?: Secp256k1Signer[];
 }): Promise<PublishedL2Block>;