@aztec/stdlib 0.77.0-testnet-ignition.17

package/dest/tests/factories.js

@@ -0,0 +1,914 @@
+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 { compact } from '@aztec/foundation/collection';
+import { SchnorrSignature, poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+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 { 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 { Gas, GasFees, GasSettings } from '../gas/index.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 { 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 { PublicKeys, computeAddress } from '../keys/index.js';
+import { ContractClassLog } from '../logs/contract_class_log.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 { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { RootParityInput } from '../parity/root_parity_input.js';
+import { RootParityInputs } from '../parity/root_parity_inputs.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 { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { 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 { 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 { TxRequest } from '../tx/tx_request.js';
+import { RollupTypes, Vector } from '../types/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);
+}
+function makeScopedLogHash(seed) {
+    return new ScopedLogHash(makeLogHash(seed), makeAztecAddress(seed + 3));
+}
+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));
+}
+function makePrivateLog(seed) {
+    return new PrivateLog(makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, fr, seed));
+}
+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));
+}
+/**
+ * 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 = 1) {
+    // @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.default({
+        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) {
+    return new FunctionSelector(seed);
+}
+function makeReadRequest(n) {
+    return new ReadRequest(new Fr(BigInt(n)), n + 1);
+}
+/**
+ * Creates arbitrary KeyValidationRequest from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequest.
+ * @returns A KeyValidationRequest.
+ */ function makeKeyValidationRequests(seed) {
+    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));
+}
+function makePublicDataWrite(seed = 1) {
+    return new PublicDataWrite(fr(seed), fr(seed + 1));
+}
+/**
+ * Creates arbitrary public data read.
+ * @param seed - The seed to use for generating the public data read.
+ * @returns A public data read.
+ */ export function makePublicDataRead(seed = 1) {
+    return new PublicDataRead(fr(seed), fr(seed + 1), 0);
+}
+/**
+ * Creates empty public data read.
+ * @returns An empty public data read.
+ */ export function makeEmptyPublicDataRead() {
+    return new PublicDataRead(fr(0), fr(0), 0);
+}
+/**
+ * Creates arbitrary contract storage update request.
+ * @param seed - The seed to use for generating the contract storage update request.
+ * @returns A contract storage update request.
+ */ export function makeContractStorageUpdateRequest(seed = 1) {
+    return new ContractStorageUpdateRequest(fr(seed), fr(seed + 1), seed + 2);
+}
+/**
+ * Creates arbitrary contract storage read.
+ * @param seed - The seed to use for generating the contract storage read.
+ * @returns A contract storage read.
+ */ 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));
+}
+export function makeCombinedConstantData(seed = 1) {
+    return new CombinedConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201), makeGlobalVariables(seed + 0x300));
+}
+/**
+ * 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 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));
+}
+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), makeTuple(MAX_PUBLIC_LOGS_PER_TX, makePublicLog, seed + 0x300), makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, makePublicDataWrite, seed + 0x400));
+}
+export function makeGas(seed = 1) {
+    return new Gas(seed, seed + 1);
+}
+/**
+ * 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 = {}) {
+    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) {
+    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);
+}
+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));
+}
+/**
+ * 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));
+}
+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);
+}
+function makeSiblingPath(seed, size) {
+    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(size, start) {
+    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) {
+    return VerificationKeyAsFields.makeFake(size);
+}
+/**
+ * Creates arbitrary/mocked verification key.
+ * @returns A verification key object
+ */ export function makeVerificationKey() {
+    return VerificationKey.makeFake();
+}
+/**
+ * Creates an arbitrary point in a curve.
+ * @param seed - Seed to generate the point values.
+ * @returns A point.
+ */ export function makePoint(seed = 1) {
+    return new Point(fr(seed), fr(seed + 1), false);
+}
+/**
+ * Creates an arbitrary grumpkin scalar.
+ * @param seed - Seed to generate the values.
+ * @returns A GrumpkinScalar.
+ */ export function makeGrumpkinScalar(seed = 1) {
+    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) {
+    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));
+}
+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) {
+    return TxRequest.from({
+        origin: makeAztecAddress(seed),
+        functionData: new FunctionData(makeSelector(seed + 0x100), /*isPrivate=*/ true),
+        argsHash: fr(seed + 0x200),
+        txContext: makeTxContext(seed + 0x400)
+    });
+}
+/**
+ * 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)),
+        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),
+        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),
+        startSideEffectCounter: fr(seed + 0x849),
+        endSideEffectCounter: fr(seed + 0x850),
+        historicalHeader: makeHeader(seed + 0xd00, undefined),
+        txContext: makeTxContext(seed + 0x1400),
+        isFeePayer: false
+    });
+}
+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),
+        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)),
+        ...compact(overrides)
+    });
+}
+export function makeGasFees(seed = 1) {
+    return new GasFees(fr(seed), fr(seed + 1));
+}
+export 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);
+}
+/**
+ * Makes arbitrary eth address.
+ * @param seed - The seed to use for generating the eth address.
+ * @returns An eth address.
+ */ export function makeEthAddress(seed = 1) {
+    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) {
+    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) {
+    return AztecAddress.fromField(fr(seed));
+}
+/**
+ * Makes arbitrary Schnorr signature.
+ * @param seed - The seed to use for generating the Schnorr signature.
+ * @returns A Schnorr signature.
+ */ export function makeSchnorrSignature(seed = 1) {
+    return new SchnorrSignature(Buffer.alloc(SchnorrSignature.SIZE, seed));
+}
+/**
+ * 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));
+}
+/**
+ * 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));
+}
+/**
+ * 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 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 makeRootParityInputs(seed = 0) {
+    return new RootParityInputs(makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, ()=>makeRootParityInput(RECURSIVE_PROOF_LENGTH), seed + 0x4100));
+}
+/**
+ * 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) {
+    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));
+}
+/**
+ * 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));
+}
+/**
+ * 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));
+}
+function makeTreeSnapshots(seed = 0) {
+    return new TreeSnapshots(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 0x10), makeAppendOnlyTreeSnapshot(seed + 0x20), makeAppendOnlyTreeSnapshot(seed + 0x30));
+}
+/**
+ * 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) {
+    const recipient = EthAddress.fromField(new Fr(seed));
+    const content = new Fr(seed + 1);
+    return new L2ToL1Message(recipient, content, seed + 2);
+}
+/**
+ * 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));
+}
+/**
+ * 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)
+    ]);
+}
+/**
+ * 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)
+    ]);
+}
+/**
+ * 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) {
+    return new PublicDataTreeLeaf(new Fr(seed), new Fr(seed + 1));
+}
+/**
+ * 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));
+}
+/**
+ * Creates an instance of PrivateBaseStateDiffHints 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);
+    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);
+}
+function makeVkWitnessData(seed = 1) {
+    return new VkWitnessData(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));
+}
+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();
+    return PrivateBaseRollupHints.from({
+        start,
+        startSpongeBlob,
+        stateDiffHints,
+        feePayerFeeJuiceBalanceReadHint,
+        archiveRootMembershipWitness,
+        contractClassLogsPreimages,
+        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
+    });
+}
+export function makePrivateBaseRollupInputs(seed = 0) {
+    const tubeData = makePrivateTubeData(seed);
+    const hints = makePrivateBaseRollupHints(seed + 0x100);
+    return PrivateBaseRollupInputs.from({
+        tubeData,
+        hints
+    });
+}
+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);
+    const hints = makePublicBaseRollupHints(seed + 0x200);
+    return PublicBaseRollupInputs.from({
+        tubeData,
+        avmProofData,
+        hints
+    });
+}
+export function makeExecutablePrivateFunctionWithMembershipProof(seed = 0) {
+    return {
+        selector: makeSelector(seed),
+        bytecode: makeBytes(100, seed + 1),
+        artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
+        artifactTreeLeafIndex: seed + 2,
+        privateFunctionTreeSiblingPath: makeTuple(3, fr, seed + 3),
+        privateFunctionTreeLeafIndex: seed + 3,
+        artifactMetadataHash: fr(seed + 4),
+        functionMetadataHash: fr(seed + 5),
+        unconstrainedFunctionsArtifactTreeRoot: fr(seed + 6),
+        vkHash: fr(seed + 7)
+    };
+}
+export function makeUnconstrainedFunctionWithMembershipProof(seed = 0) {
+    return {
+        selector: makeSelector(seed),
+        bytecode: makeBytes(100, seed + 1),
+        artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
+        artifactTreeLeafIndex: seed + 2,
+        artifactMetadataHash: fr(seed + 4),
+        functionMetadataHash: fr(seed + 5),
+        privateFunctionsArtifactTreeRoot: fr(seed + 6)
+    };
+}
+export async function makeContractClassPublic(seed = 0, publicDispatchFunction) {
+    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 publicBytecodeCommitment = await computePublicBytecodeCommitment(packedBytecode);
+    const id = await computeContractClassId({
+        artifactHash,
+        privateFunctionsRoot,
+        publicBytecodeCommitment
+    });
+    return {
+        id,
+        artifactHash,
+        packedBytecode,
+        privateFunctionsRoot,
+        publicFunctions,
+        privateFunctions: [],
+        unconstrainedFunctions: [],
+        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 {
+        selector: FunctionSelector.fromField(fr(seed + 1)),
+        vkHash: fr(seed + 2)
+    };
+}
+export function makeArray(length, fn, offset = 0) {
+    return Array.from({
+        length
+    }, (_, i)=>fn(i + offset));
+}
+export function makeArrayAsync(length, fn, offset = 0) {
+    return Promise.all(Array(length).fill(0).map((_, i)=>fn(i + offset)));
+}
+export function makeVector(length, fn, offset = 0) {
+    return new Vector(makeArray(length, fn, offset));
+}
+export async function makeVectorAsync(length, fn, offset = 0) {
+    return new Vector(await makeArrayAsync(length, fn, offset));
+}
+export function makeMap(size, fn, offset = 0) {
+    return new Map(makeArray(size, (i)=>fn(i + offset)));
+}
+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 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 saltedInitializationHash = await poseidon2HashWithSeparator([
+        salt,
+        initializationHash,
+        deployer
+    ], GeneratorIndex.PARTIAL_ADDRESS);
+    const partialAddress = await poseidon2HashWithSeparator([
+        classId,
+        saltedInitializationHash
+    ], GeneratorIndex.PARTIAL_ADDRESS);
+    const address = await computeAddress(publicKeys, partialAddress);
+    return new SerializableContractInstance({
+        version: 1,
+        salt,
+        deployer,
+        currentContractClassId: overrides?.currentClassId ?? classId,
+        originalContractClassId: classId,
+        initializationHash,
+        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 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 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 makeAvmNullifierInsertionTreeHints(seed = 0) {
+    return new AvmNullifierWriteTreeHint(makeAvmNullifierReadTreeHints(seed), makeArray(20, (i)=>new Fr(i), seed + 0x1000));
+}
+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 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));
+}
+/**
+ * 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));
+}
+/* Makes arbitrary AvmContractClassHint.
+ * @param seed - The seed to use for generating the state reference.
+ * @returns AvmContractClassHint.
+ */ export async 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);
+}
+export function makeAvmEnqueuedCallHint(seed = 0) {
+    return AvmEnqueuedCallHint.from({
+        contractAddress: new AztecAddress(new Fr(seed)),
+        calldata: makeVector(seed % 20 + 4, (i)=>new Fr(i), seed + 0x1000)
+    });
+}
+/**
+ * Creates arbitrary AvmExecutionHints.
+ * @param seed - The seed to use for generating the hints.
+ * @returns the execution hints.
+ */ export async function makeAvmExecutionHints(seed = 0, overrides = {}) {
+    const lengthOffset = 10;
+    const lengthSeedMod = 10;
+    const baseLength = lengthOffset + seed % lengthSeedMod;
+    return AvmExecutionHints.from({
+        enqueuedCalls: makeVector(baseLength, makeAvmEnqueuedCallHint, seed + 0x4100),
+        contractInstances: makeVector(baseLength + 5, makeAvmContractInstanceHint, seed + 0x4700),
+        contractClasses: await makeVectorAsync(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
+        publicDataReads: makeVector(baseLength + 7, makeAvmStorageReadTreeHints, seed + 0x4900),
+        publicDataWrites: makeVector(baseLength + 8, makeAvmStorageUpdateTreeHints, seed + 0x4a00),
+        nullifierReads: makeVector(baseLength + 9, makeAvmNullifierReadTreeHints, seed + 0x4b00),
+        nullifierWrites: makeVector(baseLength + 10, makeAvmNullifierInsertionTreeHints, seed + 0x4c00),
+        noteHashReads: makeVector(baseLength + 11, makeAvmTreeHints, seed + 0x4d00),
+        noteHashWrites: makeVector(baseLength + 12, makeAvmTreeHints, seed + 0x4e00),
+        l1ToL2MessageReads: makeVector(baseLength + 13, makeAvmTreeHints, seed + 0x4f00),
+        ...overrides
+    });
+}
+/**
+ * Creates arbitrary AvmCircuitInputs.
+ * @param seed - The seed to use for generating the hints.
+ * @returns the execution hints.
+ */ export async function makeAvmCircuitInputs(seed = 0, overrides = {}) {
+    return AvmCircuitInputs.from({
+        functionName: `function${seed}`,
+        calldata: makeArray(seed % 100 + 10, (i)=>new Fr(i), seed + 0x1000),
+        avmHints: await makeAvmExecutionHints(seed + 0x3000),
+        publicInputs: makeAvmCircuitPublicInputs(seed + 0x4000),
+        ...overrides
+    });
+}
+/**
+ * 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) {
+    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 = new AvmCircuitInputs('', [], AvmExecutionHints.empty(), 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());
+}