@aztec/simulator 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/public/fixtures/bulk_test.js

@@ -0,0 +1,278 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Timer } from '@aztec/foundation/timer';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export async function bulkTest(tester, logger, avmTestContractArtifact) {
+    const timer = new Timer();
+    const deployer = AztecAddress.fromNumber(42);
+    const avmTestContract = await tester.registerAndDeployContract(/*constructorArgs=*/ [], deployer, avmTestContractArtifact);
+    // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
+    await tester.registerFeeJuiceContract();
+    // Register multiple different protocol contracts (to ensure we don't dedup bytecode hashing events):
+    await tester.registerAuthContract();
+    await tester.registerInstanceRegistryContract();
+    // Get a deployed contract instance to pass to the contract
+    // for it to use as "expected" values when testing contract instance retrieval.
+    const expectContractInstance = avmTestContract;
+    const argsField = [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsU8 = [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8
+    ].map((x)=>new Fr(x));
+    argsU8.push(new Fr(2n ** 128n + 9n)); // Trigger truncation from large (> 128 bits) value (canonical decomposition event)
+    argsU8.push(new Fr(2n ** 125n + 10n)); // Trigger truncation from small (< 128 bits) value (no canonical decomposition event)
+    const args = [
+        argsField,
+        argsU8,
+        /*getInstanceForAddress=*/ expectContractInstance.address,
+        /*expectedDeployer=*/ expectContractInstance.deployer,
+        /*expectedClassId=*/ expectContractInstance.currentContractClassId,
+        /*expectedInitializationHash=*/ expectContractInstance.initializationHash,
+        /*skip_strictly_limited_side_effects=*/ false
+    ];
+    const bulkResult = await tester.executeTxWithLabel(/*txLabel=*/ 'AvmTest/bulk_testing', /*sender=*/ deployer, /*setupCalls=*/ [], /*appCalls=*/ [
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args
+        },
+        // 3 calls creating calldata + asserting calldata copy:
+        {
+            address: avmTestContract.address,
+            fnName: 'assert_calldata_copy_large',
+            args: [
+                Array.from({
+                    length: 300
+                }, ()=>Fr.random()),
+                /* with_selector: */ true
+            ]
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'assert_calldata_copy',
+            args: [
+                argsField.slice(3),
+                /* with_selector: */ true
+            ]
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'assert_calldata_copy_large',
+            args: [
+                Array.from({
+                    length: 300
+                }, ()=>Fr.random()),
+                /* with_selector: */ true
+            ]
+        },
+        // 3 calls to external contracts
+        {
+            address: avmTestContract.address,
+            fnName: 'call_fee_juice',
+            args: []
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'call_auth_registry',
+            args: []
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'call_instance_registry',
+            args: []
+        }
+    ], /*teardownCall=*/ undefined, /*feePayer*/ undefined, /*privateInsertions=*/ {
+        nonRevertible: {
+            nullifiers: [
+                new Fr(420000)
+            ],
+            noteHashes: [
+                new Fr(420001)
+            ]
+        },
+        revertible: {
+            nullifiers: [
+                new Fr(420002)
+            ],
+            noteHashes: [
+                new Fr(420003)
+            ]
+        }
+    });
+    logger.info(`Bulk test took ${timer.ms()}ms\n`);
+    return bulkResult;
+}
+export async function megaBulkTest(tester, logger, avmTestContractArtifact) {
+    const timer = new Timer();
+    const deployer = AztecAddress.fromNumber(42);
+    const avmTestContract = await tester.registerAndDeployContract(/*constructorArgs=*/ [], deployer, avmTestContractArtifact);
+    // Needed since we invoke the Fee Juice Contract in the bulk test.registerFeeJuiceContract
+    await tester.registerFeeJuiceContract();
+    // Get a deployed contract instance to pass to the contract
+    // for it to use as "expected" values when testing contract instance retrieval.
+    const expectContractInstance = avmTestContract;
+    const argsField0 = [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsField1 = [
+        3,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsField2 = [
+        5,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsField3 = [
+        7,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsField4 = [
+        9,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const argsField5 = [
+        11,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    //const argsField6 = [13, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+    //const argsField7 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+    //const argsField8 = [17, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+    const argsU8 = [
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10
+    ].map((x)=>new Fr(x));
+    const genArgs = (argsField)=>[
+            argsField,
+            argsU8,
+            /*getInstanceForAddress=*/ expectContractInstance.address.toField(),
+            /*expectedDeployer=*/ expectContractInstance.deployer.toField(),
+            /*expectedClassId=*/ expectContractInstance.currentContractClassId.toField(),
+            /*expectedInitializationHash=*/ expectContractInstance.initializationHash.toField(),
+            // Must skip strictly limited side effects (logs, messages) so we can spam the bulk test several times.
+            /*skip_strictly_limited_side_effects=*/ true
+        ];
+    const bulkResult = await tester.executeTxWithLabel(/*txLabel=*/ 'AvmTest/mega_bulk_testing', /*sender=*/ deployer, /*setupCalls=*/ [], /*appCalls=*/ [
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField0)
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField1)
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField2)
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField3)
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField4)
+        },
+        {
+            address: avmTestContract.address,
+            fnName: 'bulk_testing',
+            args: genArgs(argsField5)
+        }
+    ], /*teardownCall=*/ undefined, /*feePayer*/ undefined, /*privateInsertions=*/ {
+        nonRevertible: {
+            nullifiers: [
+                new Fr(420000)
+            ],
+            noteHashes: [
+                new Fr(420001)
+            ]
+        },
+        revertible: {
+            nullifiers: [
+                new Fr(420002)
+            ],
+            noteHashes: [
+                new Fr(420003)
+            ]
+        }
+    });
+    logger.info(`Mega bulk test took ${timer.ms()}ms\n`);
+    return bulkResult;
+}

package/dest/public/fixtures/custom_bytecode_tester.d.ts

@@ -0,0 +1,34 @@
+import type { PublicTxResult } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+/**
+ * Deploy a contract with the provided bytecode.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @returns The deployed contract instance
+ */
+export declare function deployCustomBytecode(bytecode: Buffer, tester: PublicTxSimulationTester, contractName?: string, deployer?: AztecAddress): Promise<ContractInstanceWithAddress>;
+/**
+ * Execute a custom bytecode contract.
+ * @param contract - The contract instance to execute
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */
+export declare function executeCustomBytecode(contract: ContractInstanceWithAddress, tester: PublicTxSimulationTester, txLabel?: string, calldata?: any[]): Promise<PublicTxResult>;
+/**
+ * Deploy and execute a custom bytecode contract.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */
+export declare function deployAndExecuteCustomBytecode(bytecode: Buffer, tester: PublicTxSimulationTester, txLabel?: string, contractName?: string, deployer?: AztecAddress, calldata?: any[]): Promise<PublicTxResult>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tX2J5dGVjb2RlX3Rlc3Rlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3B1YmxpYy9maXh0dXJlcy9jdXN0b21fYnl0ZWNvZGVfdGVzdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRTFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsWUFBWSxHQUFFLE1BQWlDLEVBQy9DLFFBQVEsR0FBRSxZQUEwQyxHQUNuRCxPQUFPLENBQUMsMkJBQTJCLENBQUMsQ0FpQnRDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsUUFBUSxFQUFFLDJCQUEyQixFQUNyQyxNQUFNLEVBQUUsd0JBQXdCLEVBQ2hDLE9BQU8sR0FBRSxNQUE2QixFQUN0QyxRQUFRLEdBQUUsR0FBRyxFQUFPLEdBQ25CLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0FRekI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsOEJBQThCLENBQ2xELFFBQVEsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sRUFBRSx3QkFBd0IsRUFDaEMsT0FBTyxHQUFFLE1BQTZCLEVBQ3RDLFlBQVksR0FBRSxNQUFpQyxFQUMvQyxRQUFRLEdBQUUsWUFBMEMsRUFDcEQsUUFBUSxHQUFFLEdBQUcsRUFBTyxHQUNuQixPQUFPLENBQUMsY0FBYyxDQUFDLENBR3pCIn0=

package/dest/public/fixtures/custom_bytecode_tester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom_bytecode_tester.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/custom_bytecode_tester.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,wBAAwB,EAChC,YAAY,GAAE,MAAiC,EAC/C,QAAQ,GAAE,YAA0C,GACnD,OAAO,CAAC,2BAA2B,CAAC,CAiBtC;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,2BAA2B,EACrC,MAAM,EAAE,wBAAwB,EAChC,OAAO,GAAE,MAA6B,EACtC,QAAQ,GAAE,GAAG,EAAO,GACnB,OAAO,CAAC,cAAc,CAAC,CAQzB;AAED;;;;;;;;;GASG;AACH,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,wBAAwB,EAChC,OAAO,GAAE,MAA6B,EACtC,YAAY,GAAE,MAAiC,EAC/C,QAAQ,GAAE,YAA0C,EACpD,QAAQ,GAAE,GAAG,EAAO,GACnB,OAAO,CAAC,cAAc,CAAC,CAGzB"}

package/dest/public/fixtures/custom_bytecode_tester.js

@@ -0,0 +1,53 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Deploy a contract with the provided bytecode.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @returns The deployed contract instance
+ */ export async function deployCustomBytecode(bytecode, tester, contractName = 'CustomBytecodeContract', deployer = AztecAddress.fromNumber(42)) {
+    const contractArtifact = emptyContractArtifact();
+    contractArtifact.name = contractName;
+    contractArtifact.functions = [
+        emptyFunctionArtifact()
+    ];
+    // We use name 'public_dispatch' since that is what is expected
+    // in a ContractArtifact. But function selectors are not required
+    // when executing since the custom bytecode likely has no dispatch.
+    contractArtifact.functions[0].name = 'public_dispatch';
+    contractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+    contractArtifact.functions[0].bytecode = bytecode;
+    // return the contract instance
+    return await tester.registerAndDeployContract(/*constructorArgs=*/ [], deployer, /*contractArtifact=*/ contractArtifact);
+}
+/**
+ * Execute a custom bytecode contract.
+ * @param contract - The contract instance to execute
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */ export async function executeCustomBytecode(contract, tester, txLabel = 'CustomBytecodeTest', calldata = []) {
+    // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+    return await tester.executeTxWithLabel(/*txLabel=*/ txLabel, /*sender=*/ contract.deployer, /*setupCalls=*/ [], /*appCalls=*/ [
+        {
+            address: contract.address,
+            args: calldata
+        }
+    ]);
+}
+/**
+ * Deploy and execute a custom bytecode contract.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract
+ * @param deployer - The deployer address
+ * @param calldata - The calldata to use
+ * @returns The execution result
+ */ export async function deployAndExecuteCustomBytecode(bytecode, tester, txLabel = 'CustomBytecodeTest', contractName = 'CustomBytecodeContract', deployer = AztecAddress.fromNumber(42), calldata = []) {
+    const testContract = await deployCustomBytecode(bytecode, tester, contractName, deployer);
+    return await executeCustomBytecode(testContract, tester, txLabel, calldata);
+}

package/dest/public/fixtures/custom_bytecode_tests.d.ts

@@ -0,0 +1,12 @@
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+export declare function addressingWithBaseTagIssueTest(isIndirect: boolean, tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function addressingWithIndirectTagIssueTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function addressingWithIndirectThenRelativeTagIssueTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function addressingWithRelativeOverflowAndIndirectTagIssueTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function pcOutOfRangeTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function invalidOpcodeTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function invalidByteTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function instructionTruncatedTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function invalidTagValueTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+export declare function invalidTagValueAndInstructionTruncatedTest(tester: PublicTxSimulationTester): Promise<import("../index.js").PublicTxResult>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tX2J5dGVjb2RlX3Rlc3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL2ZpeHR1cmVzL2N1c3RvbV9ieXRlY29kZV90ZXN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUk1RSx3QkFBc0IsOEJBQThCLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsd0JBQXdCLGlEQWN6RztBQUtELHdCQUFzQixrQ0FBa0MsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLGlEQW1CeEY7QUFPRCx3QkFBc0IsOENBQThDLENBQUMsTUFBTSxFQUFFLHdCQUF3QixpREFxQnBHO0FBT0Qsd0JBQXNCLHFEQUFxRCxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsaURBeUIzRztBQUVELHdCQUFzQixnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLGlEQVF0RTtBQUVELHdCQUFzQixpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLGlEQWlCdkU7QUFHRCx3QkFBc0IsZUFBZSxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsaURBT3JFO0FBR0Qsd0JBQXNCLHdCQUF3QixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsaURBVTlFO0FBR0Qsd0JBQXNCLG1CQUFtQixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsaURBWXpFO0FBR0Qsd0JBQXNCLDBDQUEwQyxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsaURBY2hHIn0=

package/dest/public/fixtures/custom_bytecode_tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom_bytecode_tests.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/custom_bytecode_tests.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAI5E,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,wBAAwB,iDAczG;AAKD,wBAAsB,kCAAkC,CAAC,MAAM,EAAE,wBAAwB,iDAmBxF;AAOD,wBAAsB,8CAA8C,CAAC,MAAM,EAAE,wBAAwB,iDAqBpG;AAOD,wBAAsB,qDAAqD,CAAC,MAAM,EAAE,wBAAwB,iDAyB3G;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,wBAAwB,iDAQtE;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,iDAiBvE;AAGD,wBAAsB,eAAe,CAAC,MAAM,EAAE,wBAAwB,iDAOrE;AAGD,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,iDAU9E;AAGD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,wBAAwB,iDAYzE;AAGD,wBAAsB,0CAA0C,CAAC,MAAM,EAAE,wBAAwB,iDAchG"}

package/dest/public/fixtures/custom_bytecode_tests.js

@@ -0,0 +1,174 @@
+import { strict as assert } from 'assert';
+import { TypeTag } from '../avm/avm_memory_types.js';
+import { Addressing, AddressingMode } from '../avm/opcodes/addressing_mode.js';
+import { Add, CalldataCopy, Jump, Return, Set } from '../avm/opcodes/index.js';
+import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import { MAX_OPCODE_VALUE, Opcode, OperandType, getOperandSize } from '../avm/serialization/instruction_serialization.js';
+import { deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
+// First instruction resolved a base address (offset 0) which is uninitialized and therefore
+// of invalid tag (FF). This will trigger an exceptional halt.
+export async function addressingWithBaseTagIssueTest(isIndirect, tester) {
+    const addressingMode = Addressing.fromModes([
+        isIndirect ? AddressingMode.INDIRECT_RELATIVE : AddressingMode.RELATIVE,
+        AddressingMode.DIRECT,
+        AddressingMode.DIRECT
+    ]);
+    const bytecode = encodeToBytecode([
+        new CalldataCopy(/*indirect=*/ addressingMode.toWire(), /*copySize=*/ 1, /*cdOffset=*/ 0, /*dstOffset=*/ 0),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = isIndirect ? 'AddressingWithBaseTagInvalidIndirect' : 'AddressingWithBaseTagInvalidDirect';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// First instruction sets a value with tag U64 at offset 0. Then a CalldataCopy instruction
+// uses INDIRECT addressing to read from offset 0, which should fail because the value at
+// offset 0 has tag U64 (not U32), making it an invalid address tag.
+export async function addressingWithIndirectTagIssueTest(tester) {
+    // Set a U64 value at offset 0 - this will be used as an indirect address
+    const addressingMode = Addressing.fromModes([
+        AddressingMode.INDIRECT,
+        AddressingMode.DIRECT,
+        AddressingMode.DIRECT
+    ]);
+    const bytecode = encodeToBytecode([
+        // Set a U64 value at offset 0 - this has the wrong tag for an address (should be U32)
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT64, /*value=*/ 100n).as(Opcode.SET_64, Set.wireFormat64),
+        // Try to use indirect addressing: read from offset 0, which contains a U64 value
+        // This should fail because U64 is not a valid address tag (must be U32)
+        new CalldataCopy(/*indirect=*/ addressingMode.toWire(), /*copySize=*/ 1, /*cdOffset=*/ 0, /*dstOffset=*/ 1),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = 'AddressingWithIndirectTagInvalid';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// First instruction sets a value 10 with tag U32 at offset 1 (direct, no relative).
+// Then an ADD_16 instruction uses INDIRECT addressing for the first operand (offset 1)
+// and RELATIVE addressing for the second operand (offset 2). The indirect addressing
+// succeeds (reads U32 value 10 from offset 1, uses it as address), but the relative
+// addressing fails because the base address at offset 0 has the wrong tag (uninitialized/invalid).
+export async function addressingWithIndirectThenRelativeTagIssueTest(tester) {
+    const addressingMode = Addressing.fromModes([
+        AddressingMode.INDIRECT,
+        AddressingMode.RELATIVE,
+        AddressingMode.DIRECT
+    ]);
+    const bytecode = encodeToBytecode([
+        // Set a U32 value 10 at offset 1 - this will be used as an indirect address
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 1, TypeTag.UINT32, /*value=*/ 10).as(Opcode.SET_32, Set.wireFormat32),
+        // ADD_16: first operand uses indirect addressing (reads from offset 1, gets value 10, uses as address - succeeds)
+        //         second operand uses relative addressing (tries to read base from offset 0, but offset 0 has wrong tag - fails)
+        new Add(/*indirect=*/ addressingMode.toWire(), /*aOffset=*/ 1, /*bOffset=*/ 2, /*dstOffset=*/ 3).as(Opcode.ADD_16, Add.wireFormat16),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = 'AddressingWithIndirectThenRelativeTagInvalid';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// First instruction sets UINT32_MAX at offset 0 (base address) with tag U32.
+// Then an ADD_8 instruction uses INDIRECT_RELATIVE addressing for the first operand (offset 1)
+// and INDIRECT addressing for the second operand (offset 2). The relative addressing
+// for the first operand will overflow (UINT32_MAX + 1 >= MAX_MEMORY_SIZE), causing the instruction to fail.
+// The second operand will also fail (indirect addressing from offset 2 which is uninitialized with tag FF).
+export async function addressingWithRelativeOverflowAndIndirectTagIssueTest(tester) {
+    const addressingMode = Addressing.fromModes([
+        AddressingMode.INDIRECT_RELATIVE,
+        AddressingMode.INDIRECT,
+        AddressingMode.DIRECT
+    ]);
+    // UINT32_MAX = 2^32 - 1 = 4294967295
+    const UINT32_MAX = 0xffffffff;
+    const bytecode = encodeToBytecode([
+        // Set UINT32_MAX at offset 0 as base address - this will cause overflow when adding relative offset 1
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ UINT32_MAX).as(Opcode.SET_32, Set.wireFormat32),
+        new Add(/*indirect=*/ addressingMode.toWire(), /*aOffset=*/ 1, /*bOffset=*/ 2, /*dstOffset=*/ 3).as(Opcode.ADD_8, Add.wireFormat8),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = 'AddressingWithRelativeOverflowAndIndirectTagInvalid';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+export async function pcOutOfRangeTest(tester) {
+    const bytecode = encodeToBytecode([
+        new Jump(/*jumpOffset=*/ 123),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = 'PcOutOfRange';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+export async function invalidOpcodeTest(tester) {
+    let bytecode = encodeToBytecode([
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8)
+    ]);
+    const offsetReturnOpcodeByte = bytecode.length;
+    bytecode = Buffer.concat([
+        bytecode,
+        encodeToBytecode([
+            new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+        ])
+    ]);
+    // Manipulate the Return opcode to make the opcode invalid (out of range).
+    bytecode[offsetReturnOpcodeByte] = MAX_OPCODE_VALUE + 1; // opcode is invalid.
+    const txLabel = 'InvalidOpcode';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// Single invalid byte in the bytecode.
+export async function invalidByteTest(tester) {
+    const invalidOpcode = MAX_OPCODE_VALUE + 7;
+    assert(invalidOpcode < 256, 'Invalid opcode must fit in a single byte');
+    const bytecode = Buffer.from([
+        invalidOpcode
+    ]);
+    const txLabel = 'InvalidByte';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// Truncate the last instruction in the bytecode.
+export async function instructionTruncatedTest(tester) {
+    let bytecode = encodeToBytecode([
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8)
+    ]);
+    // Truncate the bytecode.
+    bytecode = bytecode.subarray(0, -1);
+    const txLabel = 'InstructionTruncated';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// Invalid tag value byte in an instruction.
+export async function invalidTagValueTest(tester) {
+    const bytecode = encodeToBytecode([
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const tagOffset = getTagOffsetInInstruction(Set.wireFormat8);
+    assert(bytecode[tagOffset].valueOf() == TypeTag.UINT32.valueOf(), 'Set instruction tag should be UINT32 in test');
+    bytecode[tagOffset] = TypeTag.INVALID;
+    const txLabel = 'InvalidTagValue';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+// Combine an invalid tag in the last instruction that is truncated.
+export async function invalidTagValueAndInstructionTruncatedTest(tester) {
+    let bytecode = encodeToBytecode([
+        // Important: value argument must be a bigint otherwise a type error will be thrown.
+        new Set(/*indirect=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT128, /*value=*/ 0n).as(Opcode.SET_128, Set.wireFormat128)
+    ]);
+    // Truncate the bytecode.
+    bytecode = bytecode.subarray(0, -5);
+    const tagOffset = getTagOffsetInInstruction(Set.wireFormat128);
+    assert(bytecode[tagOffset].valueOf() == TypeTag.UINT128.valueOf(), 'Set instruction tag should be UINT128 in test');
+    bytecode[tagOffset] = 0x6f; // Invalid tag value.
+    const txLabel = 'InvalidTagValueAndInstructionTruncated';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+/**
+ * Returns the offset of the tag in an instruction.
+ * @details Loops over the wire format operand type entries until it finds the tag.
+ * Returns the byte offset of the tag based on each operand size that is passed.
+ *
+ * @param wireFormat array of operand types
+ * @returns byte offset of the tag
+ */ function getTagOffsetInInstruction(wireFormat) {
+    let offset = 0;
+    for (const operand of wireFormat){
+        if (operand === OperandType.TAG) {
+            break;
+        }
+        offset += getOperandSize(operand);
+    }
+    return offset;
+}

package/dest/public/fixtures/index.d.ts

@@ -1,3 +1,12 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './simple_contract_data_source.js';
+export { executeAvmMinimalPublicTx } from './minimal_public_tx.js';
+export { TestExecutorMetrics } from '../test_executor_metrics.js';
+export { ammTest } from './amm_test.js';
+export { bulkTest, megaBulkTest } from './bulk_test.js';
+export { tokenTest } from './token_test.js';
+export * from './custom_bytecode_tests.js';
+export { deployCustomBytecode, executeCustomBytecode, deployAndExecuteCustomBytecode, } from './custom_bytecode_tester.js';
+export { getSpamConfigsPerOpcode, testOpcodeSpamCase } from './opcode_spammer.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZml4dHVyZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ25FLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDeEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDNUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxPQUFPLEVBQ0wsb0JBQW9CLEVBQ3BCLHFCQUFxQixFQUNyQiw4QkFBOEIsR0FDL0IsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQyJ9

package/dest/public/fixtures/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,YAAY,CAAC;AAC3B,cAAc,kCAAkC,CAAC;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,8BAA8B,GAC/B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC"}

package/dest/public/fixtures/index.js

@@ -1,2 +1,11 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
+export * from './simple_contract_data_source.js';
+export { executeAvmMinimalPublicTx } from './minimal_public_tx.js';
+export { TestExecutorMetrics } from '../test_executor_metrics.js';
+export { ammTest } from './amm_test.js';
+export { bulkTest, megaBulkTest } from './bulk_test.js';
+export { tokenTest } from './token_test.js';
+export * from './custom_bytecode_tests.js';
+export { deployCustomBytecode, executeCustomBytecode, deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
+export { getSpamConfigsPerOpcode, testOpcodeSpamCase } from './opcode_spammer.js';

package/dest/public/fixtures/minimal_public_tx.d.ts

@@ -0,0 +1,4 @@
+import type { PublicTxResult } from '@aztec/stdlib/avm';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+export declare function executeAvmMinimalPublicTx(tester: PublicTxSimulationTester): Promise<PublicTxResult>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWluaW1hbF9wdWJsaWNfdHguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wdWJsaWMvZml4dHVyZXMvbWluaW1hbF9wdWJsaWNfdHgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFReEQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFNUUsd0JBQXNCLHlCQUF5QixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLENBZXpHIn0=

package/dest/public/fixtures/minimal_public_tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimal_public_tx.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/minimal_public_tx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAE5E,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,cAAc,CAAC,CAezG"}

package/dest/public/fixtures/minimal_public_tx.js

@@ -0,0 +1,19 @@
+import { ProtocolContracts } from '@aztec/stdlib/tx';
+import { TypeTag } from '../avm/avm_memory_types.js';
+import { Add, Return, Set } from '../avm/opcodes/index.js';
+import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import { Opcode } from '../avm/serialization/instruction_serialization.js';
+import { deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
+export async function executeAvmMinimalPublicTx(tester) {
+    const minimalBytecode = encodeToBytecode([
+        new Set(/*indirect*/ 0, /*dstOffset*/ 0, TypeTag.UINT32, /*value*/ 1).as(Opcode.SET_8, Set.wireFormat8),
+        new Set(/*indirect*/ 0, /*dstOffset*/ 1, TypeTag.UINT32, /*value*/ 2).as(Opcode.SET_8, Set.wireFormat8),
+        new Add(/*indirect=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 2).as(Opcode.ADD_8, Add.wireFormat8),
+        new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 2)
+    ]);
+    const result = await deployAndExecuteCustomBytecode(minimalBytecode, tester, 'MinimalTx', 'AvmMinimalContract');
+    // Modify the protocol contracts to be all zeros
+    result.hints.protocolContracts = ProtocolContracts.empty();
+    result.publicInputs.protocolContracts = ProtocolContracts.empty();
+    return result;
+}