@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/tests/factories.ts

@@ -0,0 +1,1728 @@
+import {
+  makeBlobAccumulator,
+  makeFinalBlobAccumulator,
+  makeFinalBlobBatchingChallenges,
+  makeSpongeBlob,
+} from '@aztec-labs/blob-lib/testing';
+import {
+  ARCHIVE_HEIGHT,
+  AVM_V2_PROOF_LENGTH_IN_FIELDS,
+  CHONK_PROOF_LENGTH,
+  CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
+  INBOX_PARITY_SIZE_SMALL,
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  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_L1_TO_L2_MSGS_PER_BLOCK,
+  MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
+  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_PROCESSABLE_L2_GAS,
+  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,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+  PUBLIC_DATA_TREE_HEIGHT,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+  VK_TREE_HEIGHT,
+} from '@aztec-labs/constants';
+import { type FieldsOf, makeTuple } from '@aztec-labs/foundation/array';
+import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec-labs/foundation/branded-types';
+import { compact } from '@aztec-labs/foundation/collection';
+import { Grumpkin } from '@aztec-labs/foundation/crypto/grumpkin';
+import { sha256 } from '@aztec-labs/foundation/crypto/sha256';
+import { Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar, Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Bufferable, Serializable, Tuple } from '@aztec-labs/foundation/serialize';
+import { MembershipWitness } from '@aztec-labs/foundation/trees';
+
+import { FunctionSelector } from '../abi/function_selector.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 { PublicDataWrite } from '../avm/public_data_write.js';
+import { AztecAddress } from '../aztec-address/index.js';
+import { BlockHash } from '../block/block_hash.js';
+import type { L2Tips } from '../block/l2_block_source.js';
+import {
+  type ContractClassPublic,
+  ContractDeploymentData,
+  type ContractInstanceWithAddress,
+  type PrivateFunction,
+  SerializableContractInstance,
+  computeContractClassId,
+  computePartialAddress,
+  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 { 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,
+  PublicCallRequestArrayLengths,
+} from '../kernel/public_call_request.js';
+import { PublicKey, PublicKeys, computeAddress, hashPublicKey } from '../keys/index.js';
+import { AppTaggingSecret } from '../logs/app_tagging_secret.js';
+import { AppTaggingSecretKind } from '../logs/app_tagging_secret_kind.js';
+import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
+import type { LogResult } from '../logs/log_result.js';
+import { PrivateLog } from '../logs/private_log.js';
+import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
+import { L1ToL2MessageBundle } from '../messaging/l1_to_l2_message_bundle.js';
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
+import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
+import { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js';
+import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { ProofData, ProofDataForFixedVk } from '../proofs/index.js';
+import { Proof } from '../proofs/proof.js';
+import { makeRecursiveProof } from '../proofs/recursive_proof.js';
+import { PrivateBaseRollupHints, PublicBaseRollupHints } from '../rollup/base_rollup_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 {
+  BlockRootRollupPrivateInputs,
+  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 { 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 { FunctionData } from '../tx/function_data.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { ProtocolContracts } from '../tx/protocol_contracts.js';
+import { PublicCallRequestWithCalldata } from '../tx/public_call_request_with_calldata.js';
+import { StateReference } from '../tx/state_reference.js';
+import { TreeSnapshots } from '../tx/tree_snapshots.js';
+import { TxConstantData } from '../tx/tx_constant_data.js';
+import { TxContext } from '../tx/tx_context.js';
+import { TxHash } from '../tx/tx_hash.js';
+import { TxRequest } from '../tx/tx_request.js';
+import { Vector } from '../types/index.js';
+import { VkData } from '../vks/index.js';
+import { VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.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: number) {
+  return new LogHash(fr(seed), seed + 1);
+}
+
+function makeCountedLogHash(seed: number) {
+  return new CountedLogHash(makeLogHash(seed), seed + 0x10);
+}
+
+function makeScopedLogHash(seed: number) {
+  return new ScopedLogHash(makeLogHash(seed), makeAztecAddress(seed + 3));
+}
+
+function makeNoteHash(seed: number) {
+  return new NoteHash(fr(seed), seed + 1);
+}
+
+function makeNullifier(seed: number) {
+  return new Nullifier(fr(seed), fr(seed + 1), seed + 2);
+}
+
+function makePrivateLog(seed: number) {
+  return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed), PRIVATE_LOG_SIZE_IN_FIELDS);
+}
+
+function makePrivateLogData(seed: number) {
+  return new PrivateLogData(makePrivateLog(seed + 0x100), seed, seed + 1);
+}
+
+function makePublicLog(seed: number) {
+  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.
+ * @param seed - The seed to use for generating the tx context.
+ * @returns A tx context.
+ */
+export function makeTxContext(seed: number = 1): TxContext {
+  // @todo @LHerskind should probably take value for chainId as it will be verified later.
+  return new TxContext(new Fr(seed), Fr.ZERO, makeGasSettings());
+}
+
+/**
+ * Creates a default instance of gas settings. No seed value is used to ensure we allocate a sensible amount of gas for testing.
+ */
+export function makeGasSettings() {
+  return GasSettings.fallback({
+    gasLimits: new Gas(196_608, MAX_PROCESSABLE_L2_GAS),
+    maxFeesPerGas: new GasFees(10, 10),
+  });
+}
+
+/**
+ * Creates arbitrary selector from the given seed.
+ * @param seed - The seed to use for generating the selector.
+ * @returns A selector.
+ */
+export function makeSelector(seed: number): FunctionSelector {
+  return new FunctionSelector(seed);
+}
+
+function makeScopedReadRequest(n: number): ScopedReadRequest {
+  return new ScopedReadRequest(new ReadRequest(new Fr(BigInt(n)), n + 1), makeAztecAddress(n + 2));
+}
+
+/**
+ * Creates arbitrary KeyValidationRequest from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequest.
+ * @returns A KeyValidationRequest.
+ */
+function makeKeyValidationRequests(seed: number): KeyValidationRequest {
+  return new KeyValidationRequest(fr(seed), fr(seed + 2));
+}
+
+/**
+ * Creates arbitrary KeyValidationRequestAndSeparator from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequestAndSeparator.
+ * @returns A KeyValidationRequestAndSeparator.
+ */
+function makeKeyValidationRequestAndSeparators(seed: number): KeyValidationRequestAndSeparator {
+  return new KeyValidationRequestAndSeparator(makeKeyValidationRequests(seed), fr(seed + 4));
+}
+
+export function makePublicDataWrite(seed = 1) {
+  return new PublicDataWrite(fr(seed), fr(seed + 1));
+}
+
+function makeTxConstantData(seed = 1) {
+  return new TxConstantData(
+    makeBlockHeader(seed),
+    makeTxContext(seed + 0x100),
+    new Fr(seed + 0x200),
+    new Fr(seed + 0x201),
+  );
+}
+
+function makePaddedTuple<T, N extends number>(
+  length: N,
+  fn: (i: number) => T,
+  nonPaddedLength = 0,
+  makePadding: () => T,
+  offset = 0,
+) {
+  return makeTuple(length, i => (i < nonPaddedLength ? fn(i + offset) : makePadding()));
+}
+
+/**
+ * Creates arbitrary accumulated data.
+ * @param seed - The seed to use for generating the accumulated data.
+ * @returns An accumulated data.
+ */
+export function makePrivateToRollupAccumulatedData(
+  seed = 1,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+  } = {},
+): PrivateToRollupAccumulatedData {
+  return new PrivateToRollupAccumulatedData(
+    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,
+  {
+    numNoteHashes = MAX_NOTE_HASHES_PER_TX,
+    numNullifiers = MAX_NULLIFIERS_PER_TX,
+    numL2ToL1Messages = MAX_L2_TO_L1_MSGS_PER_TX,
+    numPrivateLogs = MAX_PRIVATE_LOGS_PER_TX,
+    numContractClassLogs = MAX_CONTRACT_CLASS_LOGS_PER_TX,
+    numEnqueuedCalls = MAX_ENQUEUED_CALLS_PER_TX,
+  }: {
+    numNoteHashes?: number;
+    numNullifiers?: number;
+    numL2ToL1Messages?: number;
+    numPrivateLogs?: number;
+    numContractClassLogs?: number;
+    numEnqueuedCalls?: number;
+  } = {},
+) {
+  return new PrivateToPublicAccumulatedData(
+    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),
+  );
+}
+
+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),
+    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) {
+  // 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.
+ * @param seed - The seed to use for generating the call context.
+ * @returns A call context.
+ */
+export function makeCallContext(seed = 0, overrides: Partial<FieldsOf<CallContext>> = {}): CallContext {
+  return CallContext.from({
+    msgSender: makeAztecAddress(seed),
+    contractAddress: makeAztecAddress(seed + 1),
+    functionSelector: makeSelector(seed + 3),
+    isStaticCall: false,
+    ...overrides,
+  });
+}
+
+/**
+ * Creates arbitrary private kernel tail circuit public inputs.
+ * @param seed - The seed to use for generating the kernel circuit public inputs.
+ * @returns Private kernel tail circuit public inputs.
+ */
+export function makePrivateKernelTailCircuitPublicInputs(
+  seed = 1,
+  isForPublic = true,
+): PrivateKernelTailCircuitPublicInputs {
+  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),
+    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),
+  );
+}
+
+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): PrivateToRollupKernelCircuitPublicInputs {
+  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),
+    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<N extends number>(seed: number, size: N) {
+  return makeTuple(size, fr, seed);
+}
+
+/**
+ * Creates arbitrary/mocked membership witness where the sibling paths is an array of fields in an ascending order starting from `start`.
+ * @param size - The size of the membership witness.
+ * @param start - The start of the membership witness.
+ * @returns A membership witness.
+ */
+export function makeMembershipWitness<N extends number>(size: N, start: number): MembershipWitness<N> {
+  return new MembershipWitness(size, BigInt(start), makeSiblingPath(start, size));
+}
+
+/**
+ * Creates arbitrary/mocked verification key in fields format.
+ * @returns A verification key as fields object
+ */
+export function makeVerificationKeyAsFields(size: number): VerificationKeyAsFields {
+  return VerificationKeyAsFields.makeFake(size);
+}
+
+/**
+ * Creates an arbitrary point in a curve.
+ * @param seed - Seed to generate the point values.
+ * @returns A point.
+ */
+export function makePoint(seed = 1): Point {
+  return new Point(fr(seed), fr(seed + 1));
+}
+
+/**
+ * Creates an arbitrary grumpkin scalar.
+ * @param seed - Seed to generate the values.
+ * @returns A GrumpkinScalar.
+ */
+export function makeGrumpkinScalar(seed = 1): GrumpkinScalar {
+  return GrumpkinScalar.fromHighLow(fr(seed), fr(seed + 1));
+}
+
+/**
+ * Makes arbitrary proof.
+ * @param seed - The seed to use for generating/mocking the proof.
+ * @returns A proof.
+ */
+export function makeProof(seed = 1) {
+  return new Proof(Buffer.alloc(16, seed), 0);
+}
+
+function makePrivateCallRequest(seed = 1): PrivateCallRequest {
+  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), 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);
+}
+
+/**
+ * Makes arbitrary tx request.
+ * @param seed - The seed to use for generating the tx request.
+ * @returns A tx request.
+ */
+export function makeTxRequest(seed = 1): TxRequest {
+  return TxRequest.from({
+    origin: makeAztecAddress(seed),
+    functionData: new FunctionData(makeSelector(seed + 0x100), /*isPrivate=*/ true),
+    argsHash: fr(seed + 0x200),
+    txContext: makeTxContext(seed + 0x400),
+    salt: fr(seed + 0x500),
+  });
+}
+
+function makeClaimedLengthArray<T extends Serializable, N extends number>(
+  arraySize: N,
+  makeItem: (seed: number) => T,
+  seed: number,
+  length = arraySize,
+): ClaimedLengthArray<T, N> {
+  return new ClaimedLengthArray(makeTuple(arraySize, makeItem, seed) as Tuple<T, N>, 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): PrivateCircuitPublicInputs {
+  return PrivateCircuitPublicInputs.from({
+    expirationTimestamp: BigInt(seed + 0x31415),
+    callContext: makeCallContext(seed, { isStaticCall: true }),
+    argsHash: fr(seed + 0x100),
+    returnsHash: fr(seed + 0x200),
+    minRevertibleSideEffectCounter: fr(0),
+    noteHashReadRequests: makeClaimedLengthArray(
+      MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+      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: 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),
+    expectedNonRevertibleSideEffectCounter: fr(seed + 0x860),
+    expectedRevertibleSideEffectCounter: fr(seed + 0x861),
+    anchorBlockHeader: makeBlockHeader(seed + 0xd00),
+    txContext: makeTxContext(seed + 0x1400),
+    isFeePayer: false,
+    txRequestSalt: fr(seed + 0x1500),
+  });
+}
+
+export function makeGlobalVariables(seed = 1, overrides: Partial<FieldsOf<GlobalVariables>> = {}): GlobalVariables {
+  return GlobalVariables.from({
+    chainId: new Fr(seed),
+    version: new Fr(seed + 1),
+    blockNumber: BlockNumber(seed + 2),
+    slotNumber: SlotNumber(seed + 3),
+    timestamp: BigInt(seed + 4),
+    coinbase: EthAddress.fromField(new Fr(seed + 5)),
+    feeRecipient: AztecAddress.fromFieldUnsafe(new Fr(seed + 6)),
+    gasFees: new GasFees(seed + 7, seed + 8),
+    ...compact(overrides),
+  });
+}
+
+function makeGasFees(seed = 1) {
+  return new GasFees(seed, seed + 1);
+}
+
+function makeFeeRecipient(seed = 1) {
+  return new FeeRecipient(EthAddress.fromField(fr(seed)), fr(seed + 1));
+}
+
+/**
+ * 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): AppendOnlyTreeSnapshot {
+  // Constrain nextAvailableLeafIndex to u32 range
+  const nextAvailableLeafIndex = seed % 2 ** 32;
+  return new AppendOnlyTreeSnapshot(fr(seed), nextAvailableLeafIndex);
+}
+
+/**
+ * Makes arbitrary eth address.
+ * @param seed - The seed to use for generating the eth address.
+ * @returns An eth address.
+ */
+export function makeEthAddress(seed = 1): EthAddress {
+  return EthAddress.fromField(fr(seed));
+}
+
+/**
+ * Creates a buffer of a given size filled with a given value.
+ * @param size - The size of the buffer to create.
+ * @param fill - The value to fill the buffer with.
+ * @returns A buffer of a given size filled with a given value.
+ */
+export function makeBytes(size = 32, fill = 1): Buffer {
+  return Buffer.alloc(size, fill);
+}
+
+/**
+ * Makes arbitrary aztec address.
+ * @param seed - The seed to use for generating the aztec address.
+ * @returns An aztec address.
+ */
+export function makeAztecAddress(seed = 1): AztecAddress {
+  return AztecAddress.fromFieldUnsafe(fr(seed));
+}
+
+function makeBlockConstantData(seed = 1, globalVariables?: 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 makeTxRollupPublicInputs(
+  seed = 0,
+  globalVariables: GlobalVariables | undefined = undefined,
+): TxRollupPublicInputs {
+  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 makeBlockRollupPublicInputs(seed = 0): BlockRollupPublicInputs {
+  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),
+    makeL1ToL2MessageSponge(seed + 0x835),
+    makeL1ToL2MessageSponge(seed + 0x838),
+    fr(seed + 0x840),
+    fr(seed + 0x850),
+    fr(seed + 0x860),
+  );
+}
+
+export function makeL1ToL2MessageSponge(seed = 0): L1ToL2MessageSponge {
+  return new L1ToL2MessageSponge(makeSpongeBlob(seed).sponge, seed % (INBOX_PARITY_SIZE_SMALL + 1));
+}
+
+export function makeCheckpointRollupPublicInputs(seed = 0) {
+  return new CheckpointRollupPublicInputs(
+    makeEpochConstantData(seed),
+    makeAppendOnlyTreeSnapshot(seed + 0x100),
+    makeAppendOnlyTreeSnapshot(seed + 0x200),
+    makeAppendOnlyTreeSnapshot(seed + 0x300),
+    makeAppendOnlyTreeSnapshot(seed + 0x350),
+    fr(seed + 0x360),
+    fr(seed + 0x370),
+    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): ParityPublicInputs {
+  return new ParityPublicInputs(
+    new Fr(BigInt(seed + 0x400)),
+    new Fr(BigInt(seed + 0x500)),
+    makeL1ToL2MessageSponge(seed + 0x580),
+    new Fr(BigInt(seed + 0x800)),
+  );
+}
+
+export function makeInboxParityPrivateInputs(seed = 0): InboxParityPrivateInputs {
+  const size = INBOX_PARITY_SIZE_SMALL;
+  const numMsgs = seed % (size + 1);
+  const messages = Array.from({ length: size }, (_, i) => (i < numMsgs ? fr(i + seed + 0x3000) : Fr.ZERO));
+  return new InboxParityPrivateInputs(size, messages, numMsgs, new Fr(seed + 0x3500), new Fr(seed + 0x5000));
+}
+
+/**
+ * Makes root rollup public inputs.
+ * @param seed - The seed to use for generating the root rollup public inputs.
+ * @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): RootRollupPublicInputs {
+  return new RootRollupPublicInputs(
+    fr(seed + 0x100),
+    fr(seed + 0x200),
+    fr(seed + 0x300),
+    fr(seed + 0x320),
+    fr(seed + 0x340),
+    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: Partial<FieldsOf<Omit<BlockHeader, 'globalVariables'>>> & Partial<FieldsOf<GlobalVariables>> = {},
+): BlockHeader {
+  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,
+  });
+}
+
+export function makeCheckpointHeader(seed = 0, overrides: Partial<FieldsOf<CheckpointHeader>> = {}) {
+  return CheckpointHeader.from({
+    lastArchiveRoot: fr(seed + 0x100),
+    blockHeadersHash: fr(seed + 0x150),
+    blobsHash: fr(seed + 0x200),
+    inboxRollingHash: fr(seed + 0x215),
+    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),
+    accumulatedFees: fr(seed + 0x850),
+    ...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): StateReference {
+  return new StateReference(
+    makeAppendOnlyTreeSnapshot(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT * seed),
+    makePartialStateReference(seed + 1),
+  );
+}
+
+function makeTreeSnapshots(seed = 0) {
+  return new TreeSnapshots(
+    makeAppendOnlyTreeSnapshot(seed * MAX_L1_TO_L2_MSGS_PER_CHECKPOINT),
+    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.
+ * @param seed - The seed to use for generating the state reference.
+ * @returns L2 to L1 message.
+ */
+export function makeL2ToL1Message(seed = 0): L2ToL1Message {
+  const recipient = EthAddress.fromField(new Fr(seed));
+  const content = new Fr(seed + 1);
+
+  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): PartialStateReference {
+  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)),
+  );
+}
+
+export function makeTxMergeRollupPrivateInputs(seed = 0): TxMergeRollupPrivateInputs {
+  return new TxMergeRollupPrivateInputs([
+    makeProofData(seed, makeTxRollupPublicInputs),
+    makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
+  ]);
+}
+
+export function makeBlockRootRollupPrivateInputs(seed = 0) {
+  return new BlockRootRollupPrivateInputs(
+    [makeProofData(seed + 0x1000, makeTxRollupPublicInputs), makeProofData(seed + 0x2000, makeTxRollupPublicInputs)],
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), MAX_L1_TO_L2_MSGS_PER_BLOCK),
+    makeAppendOnlyTreeSnapshot(seed + 0x3000),
+    makeL1ToL2MessageSponge(seed + 0x3500),
+    makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),
+    makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT),
+  );
+}
+
+export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
+  return new BlockRootSingleTxRollupPrivateInputs(
+    makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), 0),
+    makeAppendOnlyTreeSnapshot(seed + 0x2800),
+    makeL1ToL2MessageSponge(seed + 0x3000),
+    makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),
+    makeSiblingPath(seed + 0x5000, 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 makeBlockMergeRollupPrivateInputs(seed = 0) {
+  return new BlockMergeRollupPrivateInputs([
+    makeProofData(seed, makeBlockRollupPublicInputs),
+    makeProofData(seed + 0x1000, makeBlockRollupPublicInputs),
+  ]);
+}
+
+/**
+ * Makes arbitrary public data tree leaves.
+ * @param seed - The seed to use for generating the public data tree leaf.
+ * @returns A public data tree leaf.
+ */
+export function makePublicDataTreeLeaf(seed = 0): PublicDataTreeLeaf {
+  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): NullifierLeaf {
+  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): NullifierLeafPreimage {
+  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): PublicDataTreeLeafPreimage {
+  return new PublicDataTreeLeafPreimage(makePublicDataTreeLeaf(seed), new Fr(seed + 2), BigInt(seed + 3));
+}
+
+/**
+ * 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 TreeSnapshotDiffHints object.
+ */
+export function makeTreeSnapshotDiffHints(seed = 1): TreeSnapshotDiffHints {
+  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 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));
+}
+
+export function makeProofData<T extends Bufferable, PROOF_LENGTH extends number>(
+  seed = 0,
+  makePublicInputs: (seed: number) => T,
+  proofSize: PROOF_LENGTH = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH as PROOF_LENGTH,
+) {
+  return new ProofData(
+    makePublicInputs(seed),
+    makeRecursiveProof<PROOF_LENGTH>(proofSize, seed + 0x100),
+    makeVkData(seed + 0x200),
+  );
+}
+
+function makeProofDataForFixedVk<T extends Bufferable, PROOF_LENGTH extends number>(
+  seed = 0,
+  makePublicInputs: (seed: number) => T,
+  proofSize: PROOF_LENGTH = NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH as PROOF_LENGTH,
+) {
+  return new ProofDataForFixedVk(makePublicInputs(seed), makeRecursiveProof<PROOF_LENGTH>(proofSize, seed + 0x100));
+}
+
+function makeContractClassLogFields(seed = 1) {
+  return new ContractClassLogFields(makeArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, fr, seed));
+}
+
+function makePrivateBaseRollupHints(seed = 1) {
+  const start = makePartialStateReference(seed + 0x100);
+
+  const startSpongeBlob = makeSpongeBlob(seed + 0x200);
+
+  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,
+    treeSnapshotDiffHints,
+    feePayerBalanceLeafPreimage,
+    anchorBlockArchiveSiblingPath,
+    contractClassLogsFields,
+    constants,
+  });
+}
+
+function makePublicBaseRollupHints(seed = 1) {
+  return PublicBaseRollupHints.from({
+    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 makePrivateTxBaseRollupPrivateInputs(seed = 0) {
+  return PrivateTxBaseRollupPrivateInputs.from({
+    hidingKernelProofData: makeProofData(seed, makePrivateToRollupKernelCircuitPublicInputs, CHONK_PROOF_LENGTH),
+    hints: makePrivateBaseRollupHints(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);
+  const hints = makePublicBaseRollupHints(seed + 0x200);
+
+  return PublicTxBaseRollupPrivateInputs.from({
+    publicChonkVerifierProofData,
+    avmProofData,
+    hints,
+  });
+}
+
+export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer): Promise<ContractClassPublic> {
+  const artifactHash = fr(seed + 1);
+  const privateFunctionsRoot = fr(seed + 3);
+  const packedBytecode = publicBytecode ?? makeBytes(100, seed + 4);
+  const publicBytecodeCommitment = await computePublicBytecodeCommitment(packedBytecode);
+  const id = await computeContractClassId({ artifactHash, privateFunctionsRoot, publicBytecodeCommitment });
+  return {
+    id,
+    artifactHash,
+    packedBytecode,
+    privateFunctionsRoot,
+    version: 1,
+  };
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function makeContractClassPrivateFunction(seed = 0): PrivateFunction {
+  return {
+    selector: FunctionSelector.fromField(fr(seed + 1)),
+    vkHash: fr(seed + 2),
+  };
+}
+
+export function makeArray<T>(length: number, fn: (i: number) => T, offset = 0) {
+  return Array.from({ length }, (_: any, i: number) => fn(i + offset));
+}
+
+export function makeArrayAsync<T>(length: number, fn: (i: number) => Promise<T>, offset = 0) {
+  return Promise.all(
+    Array(length)
+      .fill(0)
+      .map((_: any, i: number) => fn(i + offset)),
+  );
+}
+
+export function makeVector<T extends Bufferable>(length: number, fn: (i: number) => T, offset = 0) {
+  return new Vector(makeArray(length, fn, offset));
+}
+
+export async function makeVectorAsync<T extends Bufferable>(length: number, fn: (i: number) => Promise<T>, offset = 0) {
+  return new Vector(await makeArrayAsync(length, fn, offset));
+}
+
+export function makeMap<T>(size: number, fn: (i: number) => [string, T], offset = 0) {
+  return new Map(makeArray(size, i => fn(i + offset)));
+}
+
+export async function makeMapAsync<T>(size: number, fn: (i: number) => Promise<[string, T]>, offset = 0) {
+  return new Map(await makeArrayAsync(size, i => fn(i + offset)));
+}
+
+export async function makePublicKeys(seed = 0): Promise<PublicKeys> {
+  const f = (offset: number) => Grumpkin.mul(Grumpkin.generator, new Fq(seed + offset));
+  const ivpkM = await f(1);
+  return new PublicKeys(
+    await hashPublicKey(await f(0)),
+    ivpkM,
+    await hashPublicKey(await f(2)),
+    await hashPublicKey(await f(3)),
+    await hashPublicKey(await f(4)),
+    await hashPublicKey(await f(5)),
+  );
+}
+
+export async function makeContractInstanceFromClassId(
+  classId: Fr,
+  seed = 0,
+  overrides?: {
+    deployer?: AztecAddress;
+    initializationHash?: Fr;
+    immutablesHash?: Fr;
+    publicKeys?: PublicKeys;
+    currentClassId?: Fr;
+  },
+): Promise<ContractInstanceWithAddress> {
+  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 ?? (await makePublicKeys(seed + 3));
+  const immutablesHash = overrides?.immutablesHash ?? new Fr(seed + 4);
+
+  const partialAddress = await computePartialAddress({
+    originalContractClassId: classId,
+    salt,
+    initializationHash,
+    immutablesHash,
+    deployer,
+  });
+  const address = await computeAddress(publicKeys, partialAddress);
+  return new SerializableContractInstance({
+    version: 2,
+    salt,
+    deployer,
+    currentContractClassId: overrides?.currentClassId ?? classId,
+    originalContractClassId: classId,
+    initializationHash,
+    immutablesHash,
+    publicKeys,
+  }).withAddress(address);
+}
+
+export function makeAvmGetSiblingPathHint(seed = 0): AvmGetSiblingPathHint {
+  // 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): AvmGetPreviousValueIndexHint {
+  // 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): AvmGetLeafPreimageHintPublicDataTree {
+  // 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): AvmGetLeafPreimageHintNullifierTree {
+  // 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): AvmGetLeafValueHint {
+  // 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): AvmSequentialInsertHintPublicDataTree {
+  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): AvmSequentialInsertHintNullifierTree {
+  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): AvmAppendLeavesHint {
+  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): AvmCreateCheckpointHint {
+  return new AvmCreateCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmCheckpointActionCommitCheckpointHint(seed = 0): AvmCommitCheckpointHint {
+  return new AvmCommitCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmCheckpointActionRevertCheckpointHint(seed = 0): AvmRevertCheckpointHint {
+  return new AvmRevertCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+    /*beforeState=*/ makeTreeSnapshots(seed + 3),
+    /*afterState=*/ makeTreeSnapshots(seed + 7),
+  );
+}
+
+export function makeAvmContractDbCheckpointActionCreateCheckpointHint(seed = 0): AvmContractDbCreateCheckpointHint {
+  return new AvmContractDbCreateCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmContractDbCheckpointActionCommitCheckpointHint(seed = 0): AvmContractDbCommitCheckpointHint {
+  return new AvmContractDbCommitCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+export function makeAvmContractDbCheckpointActionRevertCheckpointHint(seed = 0): AvmContractDbRevertCheckpointHint {
+  return new AvmContractDbRevertCheckpointHint(
+    /*actionCounter=*/ seed,
+    /*oldCheckpointId=*/ seed + 1,
+    /*newCheckpointId=*/ seed + 2,
+  );
+}
+
+/**
+ * Makes arbitrary AvmContractInstanceHint.
+ * @param seed - The seed to use for generating the state reference.
+ * @returns AvmContractInstanceHint.
+ */
+export function makeAvmContractInstanceHint(seed = 0): AvmContractInstanceHint {
+  return new AvmContractInstanceHint(
+    seed,
+    new AztecAddress(new Fr(seed)),
+    new Fr(seed + 0x2),
+    new AztecAddress(new Fr(seed + 0x3)),
+    new Fr(seed + 0x4),
+    new Fr(seed + 0x5),
+    new Fr(seed + 0x6),
+    new Fr(seed + 0x7),
+    new PublicKeys(
+      new Fr(seed + 0x7),
+      new PublicKey(new Fr(seed + 0x9), new Fr(seed + 0x10)),
+      new Fr(seed + 0x11),
+      new Fr(seed + 0x13),
+      new Fr(seed + 0x15),
+      new Fr(seed + 0x17),
+    ),
+  );
+}
+
+/**
+ * Makes arbitrary AvmDebugFunctionNameHint.
+ * @param seed - The seed to use for generating the hint.
+ * @returns AvmDebugFunctionNameHint.
+ */
+export function makeAvmDebugFunctionNameHint(seed = 0): AvmDebugFunctionNameHint {
+  return new AvmDebugFunctionNameHint(new AztecAddress(new Fr(seed)), new Fr(seed + 0x2), `function-${seed}`);
+}
+
+/* Makes arbitrary AvmContractClassHint.
+ * @param seed - The seed to use for generating the state reference.
+ * @returns AvmContractClassHint.
+ */
+export function makeAvmContractClassHint(seed = 0): AvmContractClassHint {
+  const bytecode = makeBytes(32, seed + 0x5);
+  return new AvmContractClassHint(seed, new Fr(seed), new Fr(seed + 0x2), new Fr(seed + 0x3), bytecode);
+}
+
+export async function makeAvmBytecodeCommitmentHint(seed = 0): Promise<AvmBytecodeCommitmentHint> {
+  const classId = new Fr(seed + 2);
+  const bytecode = makeBytes(32, seed + 0x5);
+  return new AvmBytecodeCommitmentHint(seed, classId, await computePublicBytecodeCommitment(bytecode));
+}
+
+export async function makePublicCallRequestWithCalldata(seed = 0): Promise<PublicCallRequestWithCalldata> {
+  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 /*isStatic*/,
+    calldataHash,
+  );
+  return new PublicCallRequestWithCalldata(publicCallRequest, calldata);
+}
+
+export function makeContractClassLog(seed = 0): ContractClassLog {
+  return new ContractClassLog(makeAztecAddress(seed + 0x1000), makeContractClassLogFields(seed + 0x2000), seed % 20);
+}
+
+export function makeContractDeploymentData(seed = 0): ContractDeploymentData {
+  const contractClassLogs = makeArray(seed % 20, i => makeContractClassLog(i), seed + 0x1000);
+  const privateLogs = makeArray(seed % 20, i => makePrivateLog(i), seed + 0x2000);
+  return new ContractDeploymentData(contractClassLogs, privateLogs);
+}
+
+export async function makeAvmTxHint(seed = 0): Promise<AvmTxHint> {
+  return new AvmTxHint(
+    `txhash-${seed}`,
+    makeGasSettings(),
+    makeGasFees(seed + 0x1000),
+    makeContractDeploymentData(seed + 0x2000),
+    makeContractDeploymentData(seed + 0x3000),
+    {
+      noteHashes: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x1000),
+      nullifiers: makeArray((seed % 20) + 4, i => new Fr(i), seed + 0x2000),
+      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), //setupEnqueuedCalls
+    await makeArrayAsync((seed % 20) + 4, i => makePublicCallRequestWithCalldata(i), seed + 0x6000), // appLogicEnqueuedCalls
+    await makePublicCallRequestWithCalldata(seed + 0x7000), // teardownEnqueuedCall
+    makeGas(seed + 0x8000), // gasUsedByPrivate
+    makeAztecAddress(seed + 0x9000), // feePayer
+  );
+}
+
+/**
+ * Creates arbitrary AvmExecutionHints.
+ * @param seed - The seed to use for generating the hints.
+ * @returns the execution hints.
+ */
+export async function makeAvmExecutionHints(
+  seed = 0,
+  overrides: Partial<FieldsOf<AvmExecutionHints>> = {},
+): Promise<AvmExecutionHints> {
+  const lengthOffset = 10;
+  const lengthSeedMod = 10;
+  const baseLength = lengthOffset + (seed % lengthSeedMod);
+
+  const fields = {
+    globalVariables: makeGlobalVariables(seed + 0x4000),
+    tx: await makeAvmTxHint(seed + 0x4100),
+    protocolContracts: new ProtocolContracts(makeTuple(MAX_PROTOCOL_CONTRACTS, makeAztecAddress, seed + 0x4600)),
+    contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
+    contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
+    bytecodeCommitments: await makeArrayAsync(baseLength + 5, makeAvmBytecodeCommitmentHint, seed + 0x4900),
+    debugFunctionNames: makeArray(baseLength + 5, makeAvmDebugFunctionNameHint, seed + 0x4a00),
+    contractDbCreateCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionCreateCheckpointHint,
+      seed + 0x5900,
+    ),
+    contractDbCommitCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionCommitCheckpointHint,
+      seed + 0x5b00,
+    ),
+    contractDbRevertCheckpointHints: makeArray(
+      baseLength + 5,
+      makeAvmContractDbCheckpointActionRevertCheckpointHint,
+      seed + 0x5d00,
+    ),
+    startingTreeRoots: makeTreeSnapshots(seed + 0x4900),
+    getSiblingPathHints: makeArray(baseLength + 5, makeAvmGetSiblingPathHint, seed + 0x4b00),
+    getPreviousValueIndexHints: makeArray(baseLength + 5, makeAvmGetPreviousValueIndexHint, seed + 0x4d00),
+    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.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.
+ * @param seed - The seed to use for generating the hints.
+ * @returns the execution hints.
+ */
+export async function makeAvmCircuitInputs(
+  seed = 0,
+  overrides: Partial<FieldsOf<AvmCircuitInputs>> = {},
+): Promise<AvmCircuitInputs> {
+  const fields = {
+    hints: await makeAvmExecutionHints(seed + 0x3000),
+    publicInputs: makeAvmCircuitPublicInputs(seed + 0x4000),
+    ...overrides,
+  };
+
+  return new AvmCircuitInputs(fields.hints, fields.publicInputs);
+}
+
+/**
+ * TODO: Since the max value check is currently disabled this function is pointless. Should it be removed?
+ * Test only. Easy to identify big endian field serialize.
+ * @param n - The number.
+ * @returns The field.
+ */
+export function fr(n: number): Fr {
+  return new Fr(BigInt(n));
+}
+
+/** Creates a random {@link LogResult} with private-log-shaped data. `includeEffects` populates `noteHashes` + `nullifiers`. */
+export function randomPrivateLogResult(opts?: {
+  tag?: Fr;
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockHash?: BlockHash;
+  blockTimestamp?: bigint;
+  txIndexWithinBlock?: number;
+  logIndexWithinTx?: number;
+  noteHashes?: Fr[];
+  nullifiers?: Fr[];
+  includeEffects?: boolean;
+}): LogResult {
+  const log = PrivateLog.random(opts?.tag);
+  const includeEffects = opts?.includeEffects ?? (opts?.noteHashes !== undefined || opts?.nullifiers !== undefined);
+  const base: LogResult = {
+    logData: log.getEmittedFields(),
+    blockNumber: BlockNumber(opts?.blockNumber ?? 1),
+    blockHash: opts?.blockHash ?? BlockHash.random(),
+    blockTimestamp: opts?.blockTimestamp ?? 1n,
+    txHash: opts?.txHash ?? TxHash.random(),
+    txIndexWithinBlock: opts?.txIndexWithinBlock ?? 0,
+    logIndexWithinTx: opts?.logIndexWithinTx ?? 0,
+  };
+  if (includeEffects) {
+    return {
+      ...base,
+      noteHashes: opts?.noteHashes ?? [Fr.random(), Fr.random()],
+      nullifiers: opts?.nullifiers ?? [Fr.random()],
+    };
+  }
+  return base;
+}
+
+/** Creates a random {@link LogResult} with public-log-shaped data. `includeEffects` populates `noteHashes` + `nullifiers`. */
+export async function randomPublicLogResult(opts?: {
+  txHash?: TxHash;
+  blockNumber?: number;
+  blockHash?: BlockHash;
+  blockTimestamp?: bigint;
+  txIndexWithinBlock?: number;
+  logIndexWithinTx?: number;
+  noteHashes?: Fr[];
+  nullifiers?: Fr[];
+  includeEffects?: boolean;
+}): Promise<LogResult> {
+  const log = await PublicLog.random();
+  const includeEffects = opts?.includeEffects ?? (opts?.noteHashes !== undefined || opts?.nullifiers !== undefined);
+  const base: LogResult = {
+    logData: log.getEmittedFields(),
+    blockNumber: BlockNumber(opts?.blockNumber ?? 1),
+    blockHash: opts?.blockHash ?? BlockHash.random(),
+    blockTimestamp: opts?.blockTimestamp ?? 1n,
+    txHash: opts?.txHash ?? TxHash.random(),
+    txIndexWithinBlock: opts?.txIndexWithinBlock ?? 0,
+    logIndexWithinTx: opts?.logIndexWithinTx ?? 0,
+  };
+  if (includeEffects) {
+    return {
+      ...base,
+      noteHashes: opts?.noteHashes ?? [Fr.random(), Fr.random()],
+      nullifiers: opts?.nullifiers ?? [Fr.random()],
+    };
+  }
+  return base;
+}
+
+/**
+ * Creates L2Tips with all tips pointing to the same block number.
+ * Useful for mocking aztecNode.getL2Tips() in tests.
+ * @param blockNumber - The block number to use for all tips.
+ * @param hash - Optional hash for the block (defaults to empty string).
+ * @param checkpointNumber - Optional checkpoint number (defaults to blockNumber).
+ * @param checkpointHash - Optional checkpoint hash (defaults to block hash).
+ * @returns L2Tips object with all tips at the same block.
+ */
+export function makeL2Tips(
+  blockNumber: number | BlockNumber,
+  hash = '',
+  checkpointNumber?: number | CheckpointNumber,
+  checkpointHash?: string,
+): L2Tips {
+  const bn = typeof blockNumber === 'number' ? BlockNumber(blockNumber) : blockNumber;
+  const cpn =
+    checkpointNumber !== undefined
+      ? typeof checkpointNumber === 'number'
+        ? CheckpointNumber(checkpointNumber)
+        : checkpointNumber
+      : CheckpointNumber.fromBlockNumber(bn);
+  const cph = checkpointHash ?? hash;
+  return {
+    proposed: { number: bn, hash },
+    checkpointed: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    proven: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+    finalized: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
+  };
+}
+
+export async function randomAppTaggingSecret(kind: AppTaggingSecretKind): Promise<AppTaggingSecret> {
+  const resolvedApp = await AztecAddress.random();
+  return new AppTaggingSecret(Fr.random(), resolvedApp, kind);
+}