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

package/dest/tests/factories.js

@@ -1,90 +1,96 @@
-import { makeBlockBlobPublicInputs, makeSpongeBlob } from '@aztec/blob-lib/testing';
-import { ARCHIVE_HEIGHT, AVM_PROOF_LENGTH_IN_FIELDS, AZTEC_MAX_EPOCH_DURATION, BLOBS_PER_BLOCK, CONTRACT_CLASS_LOG_DATA_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_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, NUM_BASE_PARITY_PER_ROOT_PARITY, NUM_MSGS_PER_BASE_PARITY, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DATA_TREE_HEIGHT, PUBLIC_LOG_DATA_SIZE_IN_FIELDS, RECURSIVE_PROOF_LENGTH, TUBE_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
-import { makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { makeBlobAccumulator, makeFinalBlobAccumulator, makeFinalBlobBatchingChallenges, makeSpongeBlob } from '@aztec/blob-lib/testing';
+import { ARCHIVE_HEIGHT, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, CHONK_PROOF_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, 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, 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 { makeTuple } from '@aztec/foundation/array';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+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 { 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, AvmAppendTreeHint, AvmCircuitInputs, AvmCircuitPublicInputs, AvmContractClassHint, AvmContractInstanceHint, AvmEnqueuedCallHint, AvmExecutionHints, AvmNullifierReadTreeHint, AvmNullifierWriteTreeHint, AvmPublicDataReadTreeHint, AvmPublicDataWriteTreeHint, RevertCode } from '../avm/index.js';
-import { PublicDataHint } from '../avm/public_data_hint.js';
+import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths, AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCircuitInputs, AvmCircuitPublicInputs, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractDbCommitCheckpointHint, AvmContractDbCreateCheckpointHint, AvmContractDbRevertCheckpointHint, AvmContractInstanceHint, AvmCreateCheckpointHint, AvmDebugFunctionNameHint, AvmExecutionHints, AvmGetLeafPreimageHintNullifierTree, AvmGetLeafPreimageHintPublicDataTree, AvmGetLeafValueHint, AvmGetPreviousValueIndexHint, AvmGetSiblingPathHint, AvmRevertCheckpointHint, AvmSequentialInsertHintNullifierTree, AvmSequentialInsertHintPublicDataTree, AvmTxHint } from '../avm/index.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 { SerializableContractInstance, computeContractClassId, computePublicBytecodeCommitment } from '../contract/index.js';
+import { ContractDeploymentData, SerializableContractInstance, computeContractClassId, computePublicBytecodeCommitment } from '../contract/index.js';
 import { Gas, GasFees, GasSettings } from '../gas/index.js';
+import { computeCalldataHash } from '../hash/hash.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 { RollupValidationRequests } from '../kernel/hints/rollup_validation_requests.js';
-import { CombinedConstantData, PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PrivateToPublicAccumulatedData, PrivateToPublicKernelCircuitPublicInputs, PrivateToRollupAccumulatedData, mergeAccumulatedData } from '../kernel/index.js';
-import { LogHash, ScopedLogHash } from '../kernel/log_hash.js';
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
+import { ReadRequest, ScopedReadRequest } from '../kernel/hints/read_request.js';
+import { ClaimedLengthArray, PartialPrivateTailPublicInputsForPublic, PartialPrivateTailPublicInputsForRollup, PrivateKernelTailCircuitPublicInputs, PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PrivateToPublicAccumulatedData, PrivateToPublicKernelCircuitPublicInputs, PrivateToRollupAccumulatedData } from '../kernel/index.js';
+import { CountedLogHash, LogHash, ScopedLogHash } from '../kernel/log_hash.js';
 import { NoteHash } from '../kernel/note_hash.js';
 import { Nullifier } from '../kernel/nullifier.js';
 import { PrivateCallRequest } from '../kernel/private_call_request.js';
 import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inputs.js';
 import { PrivateLogData } from '../kernel/private_log_data.js';
 import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
-import { CountedPublicCallRequest, PublicCallRequest } from '../kernel/public_call_request.js';
+import { CountedPublicCallRequest, PublicCallRequest, PublicCallRequestArrayLengths } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
-import { ContractClassLog } from '../logs/contract_class_log.js';
+import { ExtendedDirectionalAppTaggingSecret } from '../logs/extended_directional_app_tagging_secret.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
-import { PublicLog } from '../logs/public_log.js';
-import { L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
-import { BaseParityInputs } from '../parity/base_parity_inputs.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 { 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 { BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '../rollup/block_root_rollup.js';
-import { ConstantRollupData } from '../rollup/constant_rollup_data.js';
-import { EmptyBlockRootRollupInputs } from '../rollup/empty_block_root_rollup_inputs.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 { 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 { 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 { NullifierLeafPreimage } from '../trees/nullifier_leaf.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, NUM_BYTES_PER_SHA256 } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
-import { MaxBlockNumber } from '../tx/max_block_number.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 { RollupTypes, Vector } from '../types/index.js';
+import { Vector } from '../types/index.js';
+import { VkData } from '../vks/index.js';
 import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
-import { VkWitnessData } from '../vks/vk_witness_data.js';
-import { mockTx } from './mocks.js';
 /**
  * Creates an arbitrary side effect object with the given seed.
  * @param seed - The seed to use for generating the object.
  * @returns A side effect object.
  */ function makeLogHash(seed) {
-    return new LogHash(fr(seed), seed + 1, seed + 2);
+    return new LogHash(fr(seed), seed + 1);
+}
+function makeCountedLogHash(seed) {
+    return new CountedLogHash(makeLogHash(seed), seed + 0x10);
 }
 function makeScopedLogHash(seed) {
     return new ScopedLogHash(makeLogHash(seed), makeAztecAddress(seed + 3));
@@ -93,20 +99,16 @@ function makeNoteHash(seed) {
     return new NoteHash(fr(seed), seed + 1);
 }
 function makeNullifier(seed) {
-    return new Nullifier(fr(seed), seed + 1, fr(seed + 2));
-}
-function makeContractClassLog(seed) {
-    // The '* 1' removes the 'Type instantiation is excessively deep and possibly infinite. ts(2589)' err
-    return new ContractClassLog(makeAztecAddress(seed), makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS * 1, fr, seed + 1));
+    return new Nullifier(fr(seed), fr(seed + 1), seed + 2);
 }
 function makePrivateLog(seed) {
-    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed));
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed), PRIVATE_LOG_SIZE_IN_FIELDS);
 }
 function makePrivateLogData(seed) {
     return new PrivateLogData(makePrivateLog(seed + 0x100), seed, seed + 1);
 }
 function makePublicLog(seed) {
-    return new PublicLog(makeAztecAddress(seed), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, fr, seed + 1));
+    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.
@@ -130,8 +132,8 @@ function makePublicLog(seed) {
  */ export function makeSelector(seed) {
     return new FunctionSelector(seed);
 }
-function makeReadRequest(n) {
-    return new ReadRequest(new Fr(BigInt(n)), n + 1);
+function makeScopedReadRequest(n) {
+    return new ScopedReadRequest(new ReadRequest(new Fr(BigInt(n)), n + 1), makeAztecAddress(n + 2));
 }
 /**
  * Creates arbitrary KeyValidationRequest from the given seed.
@@ -141,13 +143,13 @@ function makeReadRequest(n) {
     return new KeyValidationRequest(makePoint(seed), fr(seed + 2));
 }
 /**
- * Creates arbitrary KeyValidationRequestAndGenerator from the given seed.
- * @param seed - The seed to use for generating the KeyValidationRequestAndGenerator.
- * @returns A KeyValidationRequestAndGenerator.
- */ function makeKeyValidationRequestAndGenerators(seed) {
-    return new KeyValidationRequestAndGenerator(makeKeyValidationRequests(seed), fr(seed + 4));
+ * Creates arbitrary KeyValidationRequestAndSeparator from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequestAndSeparator.
+ * @returns A KeyValidationRequestAndSeparator.
+ */ function makeKeyValidationRequestAndSeparators(seed) {
+    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));
 }
 /**
@@ -177,25 +179,21 @@ function makePublicDataWrite(seed = 1) {
  */ export function makeContractStorageRead(seed = 1) {
     return new ContractStorageRead(fr(seed), fr(seed + 1), seed + 2);
 }
-export function makeRollupValidationRequests(seed = 1) {
-    return new RollupValidationRequests(new MaxBlockNumber(true, new Fr(seed + 0x31415)));
-}
 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));
 }
-export function makeCombinedConstantData(seed = 1) {
-    return new CombinedConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201), makeGlobalVariables(seed + 0x300));
+function makePaddedTuple(length, fn, nonPaddedLength = 0, makePadding, offset = 0) {
+    return makeTuple(length, (i)=>i < nonPaddedLength ? fn(i + offset) : makePadding());
 }
 /**
  * Creates arbitrary accumulated data.
  * @param seed - The seed to use for generating the accumulated data.
  * @returns An accumulated data.
- */ export function makePrivateToRollupAccumulatedData(seed = 1, full = false) {
-    const tupleGenerator = full ? makeTuple : makeHalfFullTuple;
-    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));
+ */ 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 } = {}) {
+    return new PrivateToRollupAccumulatedData(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) {
-    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));
+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 } = {}) {
+    return new PrivateToPublicAccumulatedData(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));
 }
 function makePrivateToAvmAccumulatedData(seed = 1) {
     return new PrivateToAvmAccumulatedData(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));
@@ -204,10 +202,16 @@ 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);
 }
 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);
 }
 /**
  * Creates arbitrary call context.
@@ -229,20 +233,26 @@ export function makeGas(seed = 1) {
  */ export function makePrivateKernelTailCircuitPublicInputs(seed = 1, isForPublic = true) {
     const forPublic = isForPublic ? new PartialPrivateTailPublicInputsForPublic(makePrivateToPublicAccumulatedData(seed + 0x100), makePrivateToPublicAccumulatedData(seed + 0x200), makePublicCallRequest(seed + 0x400)) : undefined;
     const forRollup = !isForPublic ? new PartialPrivateTailPublicInputsForRollup(makePrivateToRollupAccumulatedData(seed + 0x100)) : undefined;
-    return new PrivateKernelTailCircuitPublicInputs(makeTxConstantData(seed + 0x300), makeRollupValidationRequests(seed + 0x500), makeGas(seed + 0x600), makeAztecAddress(seed + 0x700), forPublic, forRollup);
+    return new PrivateKernelTailCircuitPublicInputs(makeTxConstantData(seed + 0x300), makeGas(seed + 0x600), makeAztecAddress(seed + 0x700), BigInt(seed + 0x800), forPublic, forRollup);
+}
+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));
 }
-function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
-    return new PrivateToPublicKernelCircuitPublicInputs(makeTxConstantData(seed), makeRollupValidationRequests(seed + 0x100), makePrivateToPublicAccumulatedData(seed + 0x200), makePrivateToPublicAccumulatedData(seed + 0x300), makePublicCallRequest(seed + 0x400), makeGas(seed + 0x500), makeAztecAddress(seed + 0x600));
+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) {
-    return new PrivateToRollupKernelCircuitPublicInputs(makeTxConstantData(seed + 0x100), makeRollupValidationRequests(seed), makePrivateToRollupAccumulatedData(seed, fullAccumulatedData), makeGas(seed + 0x600), makeAztecAddress(seed + 0x700));
+ */ export function makePrivateToRollupKernelCircuitPublicInputs(seed = 1) {
+    return new PrivateToRollupKernelCircuitPublicInputs(makeTxConstantData(seed + 0x100), makePrivateToRollupAccumulatedData(seed), 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(), makeAztecAddress(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), 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);
@@ -292,7 +302,10 @@ function makePrivateCallRequest(seed = 1) {
     return new PrivateCallRequest(makeCallContext(seed + 0x1), fr(seed + 0x3), fr(seed + 0x4), seed + 0x10, seed + 0x11);
 }
 export function makePublicCallRequest(seed = 1) {
-    return new PublicCallRequest(makeAztecAddress(seed), makeAztecAddress(seed + 1), makeSelector(seed + 2), false, fr(seed + 0x3));
+    return new PublicCallRequest(makeAztecAddress(seed), makeAztecAddress(seed + 1), false, fr(seed + 0x3));
+}
+export function makePublicCallRequestArrayLengths(seed = 1) {
+    return new PublicCallRequestArrayLengths(seed, seed + 1, seed % 2 === 0);
 }
 function makeCountedPublicCallRequest(seed = 1) {
     return new CountedPublicCallRequest(makePublicCallRequest(seed), seed + 0x100);
@@ -306,36 +319,42 @@ function makeCountedPublicCallRequest(seed = 1) {
         origin: makeAztecAddress(seed),
         functionData: new FunctionData(makeSelector(seed + 0x100), /*isPrivate=*/ true),
         argsHash: fr(seed + 0x200),
-        txContext: makeTxContext(seed + 0x400)
+        txContext: makeTxContext(seed + 0x400),
+        salt: fr(seed + 0x500)
     });
 }
+function makeClaimedLengthArray(arraySize, makeItem, seed, length = arraySize) {
+    return new ClaimedLengthArray(makeTuple(arraySize, makeItem, seed), length);
+}
 /**
  * Makes arbitrary private circuit public inputs.
  * @param seed - The seed to use for generating the private circuit public inputs.
  * @returns A private circuit public inputs.
  */ export function makePrivateCircuitPublicInputs(seed = 0) {
     return PrivateCircuitPublicInputs.from({
-        maxBlockNumber: new MaxBlockNumber(true, new Fr(seed + 0x31415)),
+        expirationTimestamp: BigInt(seed + 0x31415),
         callContext: makeCallContext(seed, {
             isStaticCall: true
         }),
         argsHash: fr(seed + 0x100),
         returnsHash: fr(seed + 0x200),
         minRevertibleSideEffectCounter: fr(0),
-        noteHashReadRequests: makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x300),
-        nullifierReadRequests: makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x310),
-        keyValidationRequestsAndGenerators: makeTuple(MAX_KEY_VALIDATION_REQUESTS_PER_CALL, makeKeyValidationRequestAndGenerators, seed + 0x320),
-        noteHashes: makeTuple(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
-        nullifiers: makeTuple(MAX_NULLIFIERS_PER_CALL, makeNullifier, seed + 0x500),
-        privateCallRequests: makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, makePrivateCallRequest, seed + 0x600),
-        publicCallRequests: makeTuple(MAX_ENQUEUED_CALLS_PER_CALL, makeCountedPublicCallRequest, seed + 0x700),
+        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, makeKeyValidationRequestAndSeparators, seed + 0x320),
+        noteHashes: makeClaimedLengthArray(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
+        nullifiers: makeClaimedLengthArray(MAX_NULLIFIERS_PER_CALL, makeNullifier, seed + 0x500),
+        privateCallRequests: makeClaimedLengthArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, makePrivateCallRequest, seed + 0x600),
+        publicCallRequests: makeClaimedLengthArray(MAX_ENQUEUED_CALLS_PER_CALL, makeCountedPublicCallRequest, seed + 0x700),
         publicTeardownCallRequest: makePublicCallRequest(seed + 0x800),
-        l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeL2ToL1Message, seed + 0x800),
-        privateLogs: makeTuple(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
-        contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeLogHash, seed + 0xa00),
+        l2ToL1Msgs: makeClaimedLengthArray(MAX_L2_TO_L1_MSGS_PER_CALL, makeCountedL2ToL1Message, seed + 0x800),
+        privateLogs: makeClaimedLengthArray(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
+        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
     });
@@ -344,43 +363,29 @@ export function makeGlobalVariables(seed = 1, overrides = {}) {
     return GlobalVariables.from({
         chainId: new Fr(seed),
         version: new Fr(seed + 1),
-        blockNumber: new Fr(seed + 2),
-        slotNumber: new Fr(seed + 3),
-        timestamp: new Fr(seed + 4),
+        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)),
-        gasFees: new GasFees(new Fr(seed + 7), new Fr(seed + 8)),
+        gasFees: new GasFees(seed + 7, seed + 8),
         ...compact(overrides)
     });
 }
-export function makeGasFees(seed = 1) {
-    return new GasFees(fr(seed), fr(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));
 }
-/**
- * Makes constant base rollup data.
- * @param seed - The seed to use for generating the constant base rollup data.
- * @param blockNumber - The block number to use for generating the global variables.
- * @returns A constant base rollup data.
- */ export function makeConstantRollupData(seed = 1, globalVariables = undefined) {
-    return ConstantRollupData.from({
-        lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x300),
-        vkTreeRoot: fr(seed + 0x401),
-        protocolContractTreeRoot: fr(seed + 0x402),
-        globalVariables: globalVariables ?? makeGlobalVariables(seed + 0x500)
-    });
-}
-export function makeScopedL2ToL1Message(seed = 1) {
-    return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
-}
 /**
  * Makes arbitrary append only tree snapshot.
  * @param seed - The seed to use for generating the append only tree snapshot.
  * @returns An append only tree snapshot.
  */ export function makeAppendOnlyTreeSnapshot(seed = 1) {
-    return new AppendOnlyTreeSnapshot(fr(seed), seed);
+    // Constrain nextAvailableLeafIndex to u32 range
+    const nextAvailableLeafIndex = seed % 2 ** 32;
+    return new AppendOnlyTreeSnapshot(fr(seed), nextAvailableLeafIndex);
 }
 /**
  * Makes arbitrary eth address.
@@ -411,90 +416,42 @@ export function makeScopedL2ToL1Message(seed = 1) {
  */ export function makeSchnorrSignature(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), 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(seed = 0, globalVariables = undefined) {
-    return new BaseOrMergeRollupPublicInputs(RollupTypes.Base, 1, makeConstantRollupData(seed + 0x200, globalVariables), makePartialStateReference(seed + 0x300), makePartialStateReference(seed + 0x400), makeSpongeBlob(seed + 0x500), makeSpongeBlob(seed + 0x600), fr(seed + 0x901), fr(seed + 0x902), fr(seed + 0x903));
+ */ 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(makeAppendOnlyTreeSnapshot(seed + 0x200), makeAppendOnlyTreeSnapshot(seed + 0x300), fr(seed + 0x400), fr(seed + 0x500), globalVariables ?? makeGlobalVariables(seed + 0x501), globalVariables ?? makeGlobalVariables(seed + 0x502), fr(seed + 0x600), makeTuple(AZTEC_MAX_EPOCH_DURATION, ()=>makeFeeRecipient(seed), 0x700), fr(seed + 0x800), fr(seed + 0x801), fr(seed + 0x900), makeTuple(AZTEC_MAX_EPOCH_DURATION, ()=>makeBlockBlobPublicInputs(seed), 0x100));
+ */ 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 + 0x800), fr(seed + 0x820), fr(seed + 0x830), fr(seed + 0x840), fr(seed + 0x850), fr(seed + 0x860));
 }
-/**
- * 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), VerificationKeyAsFields.makeFakeHonk(), makeMembershipWitness(VK_TREE_HEIGHT, seed + 0x120));
-}
-/**
- * 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), VerificationKeyAsFields.makeFakeHonk(), makeMembershipWitness(VK_TREE_HEIGHT, seed + 0x120));
-}
-/**
- * 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)
-    ], fr(seed + 0x2000));
-}
-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), makeHeader(seed + 0x2300), fr(seed + 0x2400));
-}
-function makeBlockRootRollupBlobData(seed = 0) {
-    return new BlockRootRollupBlobData(makeTuple(FIELDS_PER_BLOB * BLOBS_PER_BLOCK, fr, 0x2500), makeTuple(BLOBS_PER_BLOCK, ()=>makeTuple(2, fr, 0x2600)), 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), makeConstantRollupData(0x2500, globalVariables), true);
-}
-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) {
+    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));
 }
 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.
@@ -502,34 +459,44 @@ 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(makeAppendOnlyTreeSnapshot(seed + 0x200), makeAppendOnlyTreeSnapshot(seed + 0x300), fr(seed + 0x400), fr(seed + 0x500), fr(seed + 0x600), fr(seed + 0x700), fr(seed + 0x800), makeTuple(AZTEC_MAX_EPOCH_DURATION, ()=>makeFeeRecipient(seed), 0x900), fr(seed + 0x100), fr(seed + 0x101), fr(seed + 0x200), makeTuple(AZTEC_MAX_EPOCH_DURATION, ()=>makeBlockBlobPublicInputs(seed), 0x300));
-}
-/**
- * Makes content commitment
- */ export function makeContentCommitment(seed = 0) {
-    return new ContentCommitment(new Fr(seed), toBufferBE(BigInt(seed + 0x100), NUM_BYTES_PER_SHA256), toBufferBE(BigInt(seed + 0x200), NUM_BYTES_PER_SHA256), toBufferBE(BigInt(seed + 0x300), NUM_BYTES_PER_SHA256));
+    return new RootRollupPublicInputs(fr(seed + 0x100), fr(seed + 0x200), 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));
+}
+export function makeBlockHeader(seed = 0, overrides = {}) {
+    return BlockHeader.from({
+        lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x100),
+        state: makeStateReference(seed + 0x200),
+        spongeBlobHash: fr(seed + 0x300),
+        globalVariables: makeGlobalVariables(seed += 0x700, overrides),
+        totalFees: fr(seed + 0x800),
+        totalManaUsed: fr(seed + 0x900),
+        ...overrides
+    });
 }
-/**
- * Makes header.
- */ export function makeHeader(seed = 0, blockNumber = undefined, slotNumber = undefined) {
-    return new BlockHeader(makeAppendOnlyTreeSnapshot(seed + 0x100), makeContentCommitment(seed + 0x200), makeStateReference(seed + 0x600), makeGlobalVariables(seed += 0x700, {
-        ...blockNumber ? {
-            blockNumber: new Fr(blockNumber)
-        } : {},
-        ...slotNumber ? {
-            slotNumber: new Fr(slotNumber)
-        } : {}
-    }), fr(seed + 0x800), fr(seed + 0x900));
+export function makeCheckpointHeader(seed = 0, overrides = {}) {
+    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.
  * @returns A state reference.
  */ export function makeStateReference(seed = 0) {
-    return new StateReference(makeAppendOnlyTreeSnapshot(seed), makePartialStateReference(seed + 1));
+    return new StateReference(makeAppendOnlyTreeSnapshot(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP * seed), makePartialStateReference(seed + 1));
 }
 function makeTreeSnapshots(seed = 0) {
-    return new TreeSnapshots(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 0x10), makeAppendOnlyTreeSnapshot(seed + 0x20), makeAppendOnlyTreeSnapshot(seed + 0x30));
+    return new TreeSnapshots(makeAppendOnlyTreeSnapshot(seed * NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP), makeAppendOnlyTreeSnapshot((seed + 0x10) * MAX_NOTE_HASHES_PER_TX), makeAppendOnlyTreeSnapshot((seed + 0x20) * MAX_NULLIFIERS_PER_TX), makeAppendOnlyTreeSnapshot((seed + 0x30) * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX));
 }
 /**
  * Makes arbitrary L2 to L1 message.
@@ -538,33 +505,44 @@ function makeTreeSnapshots(seed = 0) {
  */ export function makeL2ToL1Message(seed = 0) {
     const recipient = EthAddress.fromField(new Fr(seed));
     const content = new Fr(seed + 1);
-    return new L2ToL1Message(recipient, content, seed + 2);
+    return new L2ToL1Message(recipient, content);
+}
+function makeCountedL2ToL1Message(seed = 0) {
+    return new CountedL2ToL1Message(makeL2ToL1Message(seed), seed + 2);
+}
+export function makeScopedL2ToL1Message(seed = 1) {
+    return new ScopedL2ToL1Message(makeL2ToL1Message(seed), makeAztecAddress(seed + 3));
 }
 /**
  * Makes arbitrary partial state reference.
  * @param seed - The seed to use for generating the partial state reference.
  * @returns A partial state reference.
  */ export function makePartialStateReference(seed = 0) {
-    return new PartialStateReference(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 1), makeAppendOnlyTreeSnapshot(seed + 2));
+    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)
     ]);
 }
 /**
@@ -574,85 +552,91 @@ function makeTreeSnapshots(seed = 0) {
  */ export function makePublicDataTreeLeaf(seed = 0) {
     return new PublicDataTreeLeaf(new Fr(seed), new Fr(seed + 1));
 }
+/**
+ * Makes arbitrary nullifier leaf.
+ * @param seed - The seed to use for generating the nullifier leaf.
+ * @returns A nullifier leaf.
+ */ export function makeNullifierLeaf(seed = 0) {
+    return new NullifierLeaf(new Fr(seed));
+}
+/**
+ * Makes arbitrary nullifier leaf preimages.
+ * @param seed - The seed to use for generating the nullifier leaf preimage.
+ * @returns A nullifier leaf preimage.
+ */ export function makeNullifierLeafPreimage(seed = 0) {
+    return new NullifierLeafPreimage(makeNullifierLeaf(seed), new Fr(seed + 1), BigInt(seed + 2));
+}
 /**
  * Makes arbitrary public data tree leaf preimages.
  * @param seed - The seed to use for generating the public data tree leaf preimage.
  * @returns A public data tree leaf preimage.
  */ export function makePublicDataTreeLeafPreimage(seed = 0) {
-    return new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3));
+    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) {
-    const nullifierPredecessorPreimages = makeTuple(MAX_NULLIFIERS_PER_TX, (x)=>new NullifierLeafPreimage(fr(x), fr(x + 0x100), BigInt(x + 0x200)), seed + 0x1000);
+ * @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 makeVkWitnessData(seed = 1) {
-    return new VkWitnessData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
+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), makeVkWitnessData(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 makeProofDataForFixedVk(seed = 0, makePublicInputs, proofSize = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH) {
+    return new ProofDataForFixedVk(makePublicInputs(seed), makeRecursiveProof(proofSize, seed + 0x100));
+}
+function makeContractClassLogFields(seed = 1) {
+    return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
 }
 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 contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
-    const constants = makeConstantRollupData(0x100);
-    const feePayerFeeJuiceBalanceReadHint = PublicDataHint.empty();
+    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 feePayerBalanceLeafPreimage = PublicDataTreeLeafPreimage.empty();
     return PrivateBaseRollupHints.from({
         start,
         startSpongeBlob,
-        stateDiffHints,
-        feePayerFeeJuiceBalanceReadHint,
-        archiveRootMembershipWitness,
-        contractClassLogsPreimages,
+        treeSnapshotDiffHints,
+        feePayerBalanceLeafPreimage,
+        anchorBlockArchiveSiblingPath,
+        contractClassLogsFields,
         constants
     });
 }
 function makePublicBaseRollupHints(seed = 1) {
-    const startSpongeBlob = makeSpongeBlob(seed + 0x200);
-    const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
-    const contractClassLogsPreimages = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLog, seed + 0x800);
-    const constants = makeConstantRollupData(0x100);
     return PublicBaseRollupHints.from({
-        startSpongeBlob,
-        archiveRootMembershipWitness,
-        contractClassLogsPreimages,
-        constants
+        startSpongeBlob: makeSpongeBlob(seed),
+        lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x1000),
+        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(TUBE_PROOF_LENGTH, seed + 0x100), makeVkWitnessData(seed + 0x200));
-}
-function makeAvmProofData(seed = 1) {
-    return new AvmProofData(makeAvmCircuitPublicInputs(seed), makeRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS, seed + 0x100), makeVkWitnessData(seed + 0x200));
-}
-export function makePublicBaseRollupInputs(seed = 0) {
-    const tubeData = makePublicTubeData(seed);
-    const avmProofData = makeAvmProofData(seed + 0x100);
+export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
+    const publicChonkVerifierProofData = makeProofData(seed, makePublicChonkVerifierPublicInputs, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH);
+    const avmProofData = makeProofDataForFixedVk(seed + 0x100, makeAvmCircuitPublicInputs, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
     const hints = makePublicBaseRollupHints(seed + 0x200);
-    return PublicBaseRollupInputs.from({
-        tubeData,
+    return PublicTxBaseRollupPrivateInputs.from({
+        publicChonkVerifierProofData,
         avmProofData,
         hints
     });
@@ -667,11 +651,11 @@ export function makeExecutablePrivateFunctionWithMembershipProof(seed = 0) {
         privateFunctionTreeLeafIndex: seed + 3,
         artifactMetadataHash: fr(seed + 4),
         functionMetadataHash: fr(seed + 5),
-        unconstrainedFunctionsArtifactTreeRoot: fr(seed + 6),
+        utilityFunctionsTreeRoot: fr(seed + 6),
         vkHash: fr(seed + 7)
     };
 }
-export function makeUnconstrainedFunctionWithMembershipProof(seed = 0) {
+export function makeUtilityFunctionWithMembershipProof(seed = 0) {
     return {
         selector: makeSelector(seed),
         bytecode: makeBytes(100, seed + 1),
@@ -682,13 +666,10 @@ export function makeUnconstrainedFunctionWithMembershipProof(seed = 0) {
         privateFunctionsArtifactTreeRoot: fr(seed + 6)
     };
 }
-export async function makeContractClassPublic(seed = 0, publicDispatchFunction) {
+export async function makeContractClassPublic(seed = 0, publicBytecode) {
     const artifactHash = fr(seed + 1);
-    const publicFunctions = publicDispatchFunction ? [
-        publicDispatchFunction
-    ] : makeTuple(1, makeContractClassPublicFunction, seed + 2);
     const privateFunctionsRoot = fr(seed + 3);
-    const packedBytecode = publicDispatchFunction?.bytecode ?? makeBytes(100, seed + 4);
+    const packedBytecode = publicBytecode ?? makeBytes(100, seed + 4);
     const publicBytecodeCommitment = await computePublicBytecodeCommitment(packedBytecode);
     const id = await computeContractClassId({
         artifactHash,
@@ -700,18 +681,11 @@ export async function makeContractClassPublic(seed = 0, publicDispatchFunction)
         artifactHash,
         packedBytecode,
         privateFunctionsRoot,
-        publicFunctions,
         privateFunctions: [],
-        unconstrainedFunctions: [],
+        utilityFunctions: [],
         version: 1
     };
 }
-function makeContractClassPublicFunction(seed = 0) {
-    return {
-        selector: FunctionSelector.fromField(fr(seed + 1)),
-        bytecode: makeBytes(100, seed + 2)
-    };
-}
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function makeContractClassPrivateFunction(seed = 0) {
     return {
@@ -739,23 +713,24 @@ export function makeMap(size, fn, offset = 0) {
 export async function makeMapAsync(size, fn, offset = 0) {
     return new Map(await makeArrayAsync(size, (i)=>fn(i + offset)));
 }
-export function makePublicKeys(seed = 0) {
-    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) {
+    const f = (offset)=>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(classId, seed = 0, overrides) {
     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({
         version: 1,
@@ -767,41 +742,130 @@ export async function makeContractInstanceFromClassId(classId, seed = 0, overrid
         publicKeys
     }).withAddress(address);
 }
-export function makeAvmTreeHints(seed = 0) {
-    return new AvmAppendTreeHint(new Fr(seed), new Fr(seed + 1), makeArray(10, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmGetSiblingPathHint(seed = 0) {
+    // We want a possibly large index, but non-random.
+    const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+    return new AvmGetSiblingPathHint(makeAppendOnlyTreeSnapshot(seed), /*treeId=*/ (seed + 1) % 5, /*index=*/ index, makeArray(seed % 64, (i)=>new Fr(i), seed + 10));
+}
+export function makeAvmGetPreviousValueIndexHint(seed = 0) {
+    // We want a possibly large index, but non-random.
+    const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+    const value = new Fr(BigInt(`0x${sha256(Buffer.from((seed + 2).toString())).toString('hex')}`) % (1n << 128n));
+    return new AvmGetPreviousValueIndexHint(makeAppendOnlyTreeSnapshot(seed), /*treeId=*/ (seed + 1) % 5, value, index, /*alreadyPresent=*/ index % 2n === 0n);
+}
+export function makeAvmGetLeafPreimageHintPublicDataTree(seed = 0) {
+    // We want a possibly large index, but non-random.
+    const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+    return new AvmGetLeafPreimageHintPublicDataTree(makeAppendOnlyTreeSnapshot(seed), /*index=*/ index, /*leafPreimage=*/ makePublicDataTreeLeafPreimage(seed + 3));
+}
+export function makeAvmGetLeafPreimageHintNullifierTree(seed = 0) {
+    // We want a possibly large index, but non-random.
+    const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+    return new AvmGetLeafPreimageHintNullifierTree(makeAppendOnlyTreeSnapshot(seed), /*index=*/ index, /*leafPreimage=*/ makeNullifierLeafPreimage(seed + 3));
+}
+export function makeAvmGetLeafValueHint(seed = 0) {
+    // We want a possibly large index, but non-random.
+    const index = BigInt(`0x${sha256(Buffer.from(seed.toString())).toString('hex')}`) % (1n << 64n);
+    return new AvmGetLeafValueHint(makeAppendOnlyTreeSnapshot(seed), /*treeId=*/ (seed + 1) % 5, /*index=*/ index, /*value=*/ new Fr(seed + 3));
+}
+export function makeAvmSequentialInsertHintPublicDataTree(seed = 0) {
+    const lowLeavesWitnessData = {
+        leaf: makePublicDataTreeLeafPreimage(seed + 3),
+        index: BigInt(seed + 4),
+        path: makeArray(seed % 64, (i)=>new Fr(i), seed + 5)
+    };
+    const insertionWitnessData = {
+        leaf: makePublicDataTreeLeafPreimage(seed + 6),
+        index: BigInt(seed + 7),
+        path: makeArray(seed % 64, (i)=>new Fr(i), seed + 8)
+    };
+    return new AvmSequentialInsertHintPublicDataTree(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 1), MerkleTreeId.PUBLIC_DATA_TREE, makePublicDataTreeLeaf(seed + 2), lowLeavesWitnessData, insertionWitnessData);
+}
+export function makeAvmSequentialInsertHintNullifierTree(seed = 0) {
+    const lowLeavesWitnessData = {
+        leaf: makeNullifierLeafPreimage(seed + 3),
+        index: BigInt(seed + 4),
+        path: makeArray(seed % 64, (i)=>new Fr(i), seed + 5)
+    };
+    const insertionWitnessData = {
+        leaf: makeNullifierLeafPreimage(seed + 6),
+        index: BigInt(seed + 7),
+        path: makeArray(seed % 64, (i)=>new Fr(i), seed + 8)
+    };
+    return new AvmSequentialInsertHintNullifierTree(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 1), MerkleTreeId.NULLIFIER_TREE, makeNullifierLeaf(seed + 2), lowLeavesWitnessData, insertionWitnessData);
+}
+export function makeAvmAppendLeavesHint(seed = 0) {
+    return new AvmAppendLeavesHint(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 1), // Use NOTE_HASH_TREE or L1_TO_L2_MESSAGE_TREE as mentioned in the comment on AvmAppendLeavesHint
+    seed % 2 === 0 ? MerkleTreeId.NOTE_HASH_TREE : MerkleTreeId.L1_TO_L2_MESSAGE_TREE, makeArray(seed % 5 + 1, (i)=>new Fr(seed + i + 2), 0));
+}
+export function makeAvmCheckpointActionCreateCheckpointHint(seed = 0) {
+    return new AvmCreateCheckpointHint(/*actionCounter=*/ seed, /*oldCheckpointId=*/ seed + 1, /*newCheckpointId=*/ seed + 2);
 }
-export function makeAvmNullifierReadTreeHints(seed = 0) {
-    const lowNullifierPreimage = new NullifierLeafPreimage(new Fr(seed), new Fr(seed + 1), BigInt(seed + 2));
-    return new AvmNullifierReadTreeHint(lowNullifierPreimage, new Fr(seed + 1), makeArray(10, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmCheckpointActionCommitCheckpointHint(seed = 0) {
+    return new AvmCommitCheckpointHint(/*actionCounter=*/ seed, /*oldCheckpointId=*/ seed + 1, /*newCheckpointId=*/ seed + 2);
 }
-export function makeAvmPublicDataReadTreeHints(seed = 0) {
-    return new AvmPublicDataReadTreeHint(new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)), new Fr(seed + 1), makeArray(10, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmCheckpointActionRevertCheckpointHint(seed = 0) {
+    return new AvmRevertCheckpointHint(/*actionCounter=*/ seed, /*oldCheckpointId=*/ seed + 1, /*newCheckpointId=*/ seed + 2, /*beforeState=*/ makeTreeSnapshots(seed + 3), /*afterState=*/ makeTreeSnapshots(seed + 7));
 }
-export function makeAvmNullifierInsertionTreeHints(seed = 0) {
-    return new AvmNullifierWriteTreeHint(makeAvmNullifierReadTreeHints(seed), makeArray(20, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmContractDbCheckpointActionCreateCheckpointHint(seed = 0) {
+    return new AvmContractDbCreateCheckpointHint(/*actionCounter=*/ seed, /*oldCheckpointId=*/ seed + 1, /*newCheckpointId=*/ seed + 2);
 }
-export function makeAvmStorageReadTreeHints(seed = 0) {
-    return new AvmPublicDataReadTreeHint(new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)), new Fr(seed + 1), makeArray(10, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmContractDbCheckpointActionCommitCheckpointHint(seed = 0) {
+    return new AvmContractDbCommitCheckpointHint(/*actionCounter=*/ seed, /*oldCheckpointId=*/ seed + 1, /*newCheckpointId=*/ seed + 2);
 }
-export function makeAvmStorageUpdateTreeHints(seed = 0) {
-    return new AvmPublicDataWriteTreeHint(makeAvmStorageReadTreeHints(seed), new PublicDataTreeLeafPreimage(new Fr(seed), new Fr(seed + 1), new Fr(seed + 2), BigInt(seed + 3)), makeArray(20, (i)=>new Fr(i), seed + 0x1000));
+export function makeAvmContractDbCheckpointActionRevertCheckpointHint(seed = 0) {
+    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.
  * @returns AvmContractInstanceHint.
  */ export function makeAvmContractInstanceHint(seed = 0) {
-    return new AvmContractInstanceHint(new AztecAddress(new Fr(seed)), true, new Fr(seed + 0x2), new AztecAddress(new Fr(seed + 0x3)), new Fr(seed + 0x4), new Fr(seed + 0x5), new Fr(seed + 0x6), new PublicKeys(new Point(new Fr(seed + 0x7), new Fr(seed + 0x8), false), new Point(new Fr(seed + 0x9), new Fr(seed + 0x10), false), new Point(new Fr(seed + 0x11), new Fr(seed + 0x12), false), new Point(new Fr(seed + 0x13), new Fr(seed + 0x14), false)), makeAvmPublicDataReadTreeHints(seed + 0x2000), makeArray(4, (i)=>new Fr(i), seed + 0x3000));
+    return new AvmContractInstanceHint(seed, new AztecAddress(new Fr(seed)), new Fr(seed + 0x2), new AztecAddress(new Fr(seed + 0x3)), new Fr(seed + 0x4), new Fr(seed + 0x5), new Fr(seed + 0x6), new PublicKeys(new Point(new Fr(seed + 0x7), new Fr(seed + 0x8), false), new Point(new Fr(seed + 0x9), new Fr(seed + 0x10), false), new Point(new Fr(seed + 0x11), new Fr(seed + 0x12), false), new Point(new Fr(seed + 0x13), new Fr(seed + 0x14), false)));
+}
+/**
+ * Makes arbitrary AvmDebugFunctionNameHint.
+ * @param seed - The seed to use for generating the hint.
+ * @returns AvmDebugFunctionNameHint.
+ */ export function makeAvmDebugFunctionNameHint(seed = 0) {
+    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 async function makeAvmContractClassHint(seed = 0) {
+ */ export function makeAvmContractClassHint(seed = 0) {
     const bytecode = makeBytes(32, seed + 0x5);
-    return new AvmContractClassHint(new Fr(seed), true, new Fr(seed + 0x2), new Fr(seed + 0x3), await computePublicBytecodeCommitment(bytecode), bytecode);
+    return new AvmContractClassHint(seed, new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
 }
-export function makeAvmEnqueuedCallHint(seed = 0) {
-    return new AvmEnqueuedCallHint(new AztecAddress(new Fr(seed)), makeArray(seed % 20 + 4, (i)=>new Fr(i), seed + 0x1000));
+export async function makeAvmBytecodeCommitmentHint(seed = 0) {
+    const classId = new Fr(seed + 2);
+    const bytecode = makeBytes(32, seed + 0x5);
+    return new AvmBytecodeCommitmentHint(seed, classId, await computePublicBytecodeCommitment(bytecode));
+}
+export async function makePublicCallRequestWithCalldata(seed = 0) {
+    const calldata = makeArray(seed % 20 + 4, (i)=>new Fr(i), seed + 0x1000);
+    const calldataHash = await computeCalldataHash(calldata);
+    const publicCallRequest = new PublicCallRequest(new AztecAddress(new Fr(seed)), new AztecAddress(new Fr(seed + 1)), false, calldataHash);
+    return new PublicCallRequestWithCalldata(publicCallRequest, calldata);
+}
+export function makeContractClassLog(seed = 0) {
+    return new ContractClassLog(makeAztecAddress(seed + 0x1000), makeContractClassLogFields(seed + 0x2000), seed % 20);
+}
+export function makeContractDeploymentData(seed = 0) {
+    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) {
+    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),
+        l2ToL1Messages: makeArray(seed % 20 + 4, (i)=>makeScopedL2ToL1Message(i), seed + 0x3000)
+    }, {
+        noteHashes: makeArray(seed % 20 + 4, (i)=>new Fr(i), seed + 0x3000),
+        nullifiers: makeArray(seed % 20 + 4, (i)=>new Fr(i), seed + 0x4000),
+        l2ToL1Messages: makeArray(seed % 20 + 4, (i)=>makeScopedL2ToL1Message(i), seed + 0x5000)
+    }, await makeArrayAsync(seed % 20 + 4, (i)=>makePublicCallRequestWithCalldata(i), seed + 0x5000), await makeArrayAsync(seed % 20 + 4, (i)=>makePublicCallRequestWithCalldata(i), seed + 0x6000), await makePublicCallRequestWithCalldata(seed + 0x7000), makeGas(seed + 0x8000), makeAztecAddress(seed + 0x9000));
 }
 /**
  * Creates arbitrary AvmExecutionHints.
@@ -812,19 +876,31 @@ export function makeAvmEnqueuedCallHint(seed = 0) {
     const lengthSeedMod = 10;
     const baseLength = lengthOffset + seed % lengthSeedMod;
     const fields = {
-        enqueuedCalls: makeArray(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
-        contractInstances: makeArray(baseLength + 5, makeAvmContractInstanceHint, seed + 0x4700),
-        contractClasses: await makeArrayAsync(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
-        publicDataReads: makeArray(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
-        publicDataWrites: makeArray(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
-        nullifierReads: makeArray(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
-        nullifierWrites: makeArray(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
-        noteHashReads: makeArray(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
-        noteHashWrites: makeArray(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
-        l1ToL2MessageReads: makeArray(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
+        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),
+        getLeafPreimageHintPublicDataTree: makeArray(baseLength + 5, makeAvmGetLeafPreimageHintPublicDataTree, seed + 0x4f00),
+        getLeafPreimageHintNullifierTree: makeArray(baseLength + 5, makeAvmGetLeafPreimageHintNullifierTree, seed + 0x5100),
+        getLeafValueHints: makeArray(baseLength + 5, makeAvmGetLeafValueHint, seed + 0x5300),
+        sequentialInsertHintsPublicDataTree: makeArray(baseLength + 5, makeAvmSequentialInsertHintPublicDataTree, seed + 0x5500),
+        sequentialInsertHintsNullifierTree: makeArray(baseLength + 5, makeAvmSequentialInsertHintNullifierTree, seed + 0x5700),
+        appendLeavesHints: makeArray(baseLength + 5, makeAvmAppendLeavesHint, seed + 0x5800),
+        createCheckpointHints: makeArray(baseLength + 5, makeAvmCheckpointActionCreateCheckpointHint, seed + 0x5900),
+        commitCheckpointHints: makeArray(baseLength + 5, makeAvmCheckpointActionCommitCheckpointHint, seed + 0x5b00),
+        revertCheckpointHints: makeArray(baseLength + 5, makeAvmCheckpointActionRevertCheckpointHint, seed + 0x5d00),
         ...overrides
     };
-    return new AvmExecutionHints(fields.enqueuedCalls, fields.contractInstances, fields.contractClasses, fields.publicDataReads, fields.publicDataWrites, fields.nullifierReads, fields.nullifierWrites, fields.noteHashReads, fields.noteHashWrites, fields.l1ToL2MessageReads);
+    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, fields.getLeafPreimageHintPublicDataTree, fields.getLeafPreimageHintNullifierTree, fields.getLeafValueHints, fields.sequentialInsertHintsPublicDataTree, fields.sequentialInsertHintsNullifierTree, fields.appendLeavesHints, fields.createCheckpointHints, fields.commitCheckpointHints, fields.revertCheckpointHints);
 }
 /**
  * Creates arbitrary AvmCircuitInputs.
@@ -832,13 +908,11 @@ export function makeAvmEnqueuedCallHint(seed = 0) {
  * @returns the execution hints.
  */ export async function makeAvmCircuitInputs(seed = 0, overrides = {}) {
     const fields = {
-        functionName: `function${seed}`,
-        calldata: makeArray(seed % 100 + 10, (i)=>new Fr(i), seed + 0x1000),
-        avmHints: await makeAvmExecutionHints(seed + 0x3000),
+        hints: await makeAvmExecutionHints(seed + 0x3000),
         publicInputs: makeAvmCircuitPublicInputs(seed + 0x4000),
         ...overrides
     };
-    return new AvmCircuitInputs(fields.functionName, fields.calldata, fields.avmHints, fields.publicInputs);
+    return new AvmCircuitInputs(fields.hints, fields.publicInputs);
 }
 /**
  * TODO: Since the max value check is currently disabled this function is pointless. Should it be removed?
@@ -848,68 +922,77 @@ export function makeAvmEnqueuedCallHint(seed = 0) {
  */ export function fr(n) {
     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(), feePayer, feePaymentPublicDataWrite, 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.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);
-        const transactionFee = tx.data.gasUsed.computeFee(globalVariables.gasFees);
-        feePaymentPublicDataWrite ??= new PublicDataWrite(Fr.random(), Fr.random());
-        clearLogs(data);
-        tx.data.forRollup.end = data;
-        return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
-    } else {
-        const nonRevertibleData = tx.data.forPublic.nonRevertibleAccumulatedData;
-        const revertibleData = makePrivateToPublicAccumulatedData(seed + 0x1000);
-        revertibleData.nullifiers[MAX_NULLIFIERS_PER_TX - 1] = Fr.ZERO; // Leave one space for the tx hash nullifier in nonRevertibleAccumulatedData.
-        clearLogs(revertibleData);
-        tx.data.forPublic.revertibleAccumulatedData = revertibleData;
-        const avmOutput = AvmCircuitPublicInputs.empty();
-        avmOutput.globalVariables = globalVariables;
-        avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
-        avmOutput.accumulatedData.nullifiers = mergeAccumulatedData(nonRevertibleData.nullifiers, revertibleData.nullifiers, 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);
-        const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, {
-            publicInputs: avmOutput
-        });
-        const gasUsed = {
-            totalGas: Gas.empty(),
-            teardownGas: Gas.empty(),
-            publicGas: Gas.empty(),
-            billedGas: Gas.empty()
-        };
-        return makeProcessedTxFromTxWithPublicCalls(tx, {
-            type: ProvingRequestType.PUBLIC_VM,
-            inputs: avmCircuitInputs
-        }, gasUsed, RevertCode.OK, undefined /* revertReason */ );
-    }
-}
-// Remove all logs as it's ugly to mock them at the moment and we are going to change it to have the preimages be part of the public inputs soon.
-function clearLogs(data) {
-    data.publicLogs?.forEach((_, i)=>data.publicLogs[i] = PublicLog.empty());
-    data.contractClassLogsHashes.forEach((_, i)=>data.contractClassLogsHashes[i] = ScopedLogHash.empty());
+/**
+ * Creates a random TxScopedL2Log with private log data.
+ */ export function randomTxScopedPrivateL2Log(opts) {
+    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) {
+    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, hash = '', checkpointNumber, checkpointHash) {
+    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
+            }
+        }
+    };
+}
+export async function randomExtendedDirectionalAppTaggingSecret() {
+    const resolvedApp = await AztecAddress.random();
+    // Using the fromString method like this is messy as it leaks the underlying serialization format but I don't want to
+    // expose the type's constructor just for tests since in prod the secret is always constructed via compute. Also this
+    // method is tested in extended_directional_app_tagging_secret.test.ts hence all should be fine.
+    return ExtendedDirectionalAppTaggingSecret.fromString(`${Fr.random().toString()}:${resolvedApp.toString()}`);
 }