@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.0b941701

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("@aztec/stdlib/avm").PublicTxResult>;
+export declare function addressingWithIndirectTagIssueTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function addressingWithIndirectThenRelativeTagIssueTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function addressingWithRelativeOverflowAndIndirectTagIssueTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function pcOutOfRangeTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function invalidOpcodeTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function invalidByteTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function instructionTruncatedTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function invalidTagValueTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+export declare function invalidTagValueAndInstructionTruncatedTest(tester: PublicTxSimulationTester): Promise<import("@aztec/stdlib/avm").PublicTxResult>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tX2J5dGVjb2RlX3Rlc3RzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcHVibGljL2ZpeHR1cmVzL2N1c3RvbV9ieXRlY29kZV90ZXN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUk1RSx3QkFBc0IsOEJBQThCLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsd0JBQXdCLHVEQWN6RztBQUtELHdCQUFzQixrQ0FBa0MsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLHVEQXNCeEY7QUFPRCx3QkFBc0IsOENBQThDLENBQUMsTUFBTSxFQUFFLHdCQUF3Qix1REF3QnBHO0FBT0Qsd0JBQXNCLHFEQUFxRCxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsdURBeUIzRztBQUVELHdCQUFzQixnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLHVEQVF0RTtBQUVELHdCQUFzQixpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsd0JBQXdCLHVEQWlCdkU7QUFHRCx3QkFBc0IsZUFBZSxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsdURBT3JFO0FBR0Qsd0JBQXNCLHdCQUF3QixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsdURBVTlFO0FBR0Qsd0JBQXNCLG1CQUFtQixDQUFDLE1BQU0sRUFBRSx3QkFBd0IsdURBWXpFO0FBR0Qsd0JBQXNCLDBDQUEwQyxDQUFDLE1BQU0sRUFBRSx3QkFBd0IsdURBaUJoRyJ9

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,uDAczG;AAKD,wBAAsB,kCAAkC,CAAC,MAAM,EAAE,wBAAwB,uDAsBxF;AAOD,wBAAsB,8CAA8C,CAAC,MAAM,EAAE,wBAAwB,uDAwBpG;AAOD,wBAAsB,qDAAqD,CAAC,MAAM,EAAE,wBAAwB,uDAyB3G;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,wBAAwB,uDAQtE;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,uDAiBvE;AAGD,wBAAsB,eAAe,CAAC,MAAM,EAAE,wBAAwB,uDAOrE;AAGD,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,uDAU9E;AAGD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,wBAAwB,uDAYzE;AAGD,wBAAsB,0CAA0C,CAAC,MAAM,EAAE,wBAAwB,uDAiBhG"}

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(/*addressing_mode=*/ addressingMode.toWire(), /*copySize=*/ 1, /*cdOffset=*/ 0, /*dstOffset=*/ 0),
+        new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 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(/*addressing_mode=*/ addressingMode.toWire(), /*copySize=*/ 1, /*cdOffset=*/ 0, /*dstOffset=*/ 1),
+        new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 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(/*addressing_mode=*/ addressingMode.toWire(), /*aOffset=*/ 1, /*bOffset=*/ 2, /*dstOffset=*/ 3).as(Opcode.ADD_16, Add.wireFormat16),
+        new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ UINT32_MAX).as(Opcode.SET_32, Set.wireFormat32),
+        new Add(/*addressing_mode=*/ addressingMode.toWire(), /*aOffset=*/ 1, /*bOffset=*/ 2, /*dstOffset=*/ 3).as(Opcode.ADD_8, Add.wireFormat8),
+        new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0)
+    ]);
+    const txLabel = 'PcOutOfRange';
+    return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
+}
+export async function invalidOpcodeTest(tester) {
+    let bytecode = encodeToBytecode([
+        new Set(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8)
+    ]);
+    const offsetReturnOpcodeByte = bytecode.length;
+    bytecode = Buffer.concat([
+        bytecode,
+        encodeToBytecode([
+            new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 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(/*addressing_mode=*/ 0, /*dstOffset=*/ 0, TypeTag.UINT32, /*value=*/ 0).as(Opcode.SET_8, Set.wireFormat8),
+        new Return(/*addressing_mode=*/ 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(/*addressing_mode=*/ 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(/*addressing_mode=*/ 0, /*aOffset=*/ 0, /*bOffset=*/ 1, /*dstOffset=*/ 2).as(Opcode.ADD_8, Add.wireFormat8),
+        new Return(/*addressing_mode=*/ 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;
+}

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

@@ -0,0 +1,123 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { Bufferable } from '@aztec/foundation/serialize';
+import { type PublicTxResult } from '@aztec/stdlib/avm';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { type MemoryValue } from '../avm/avm_memory_types.js';
+import { Opcode } from '../avm/serialization/instruction_serialization.js';
+import type { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+/**
+ * Memory cell to initialize before spamming.
+ */
+interface MemSetup {
+    offset: number;
+    value: MemoryValue;
+}
+/**
+ * Some setup action to take before spamming.
+ * Either a memory cell to initialize, or some instruction generator.
+ */
+type SetupItem = MemSetup | (() => Bufferable[]);
+/**
+ * Everything needed to spam an opcode.
+ */
+export interface SpamConfig {
+    /** Memory cells to initialize */
+    setup: SetupItem[];
+    /** Factory to create target instruction(s) to spam */
+    targetInstructions: () => Bufferable[];
+    /** Instructions to run after target spam (e.g., REVERT) */
+    cleanupInstructions?: () => Bufferable[];
+    /**
+     * Per-TX limit for the target opcode (for side-effect-limited opcodes)
+     * If set:
+     *   1. makes nested CALL
+     *   2. executes target opcode #limit times in a nested call
+     *   3. REVERT
+     *   4. CALL again to repeat
+     */
+    limit?: number;
+    /** Optional label for this config variant (e.g., UINT8 or MAXSIZE) */
+    label?: string;
+    /** Whether to pass the contract address as calldata[0] */
+    addressAsCalldata?: boolean;
+}
+/**
+ * An object containing opcode name and its SpamConfigs
+ * Useful when ready to iterate over all opcodes and test them.
+ */
+export interface SpamConfigsForOpcode {
+    /** Opcode name (e.g., "ADD_8") */
+    opcode: string;
+    /** All spam configs for this opcode (one or more) */
+    configs: SpamConfig[];
+}
+/**
+ * Constants for "warm" tree reads - these values are inserted into the trees
+ * before running the spammer so that existence checks can find them.
+ */
+export declare const WARM_NOTE_HASH: Fr;
+export declare const WARM_L1_TO_L2_MSG: Fr;
+/** Warm nullifier constants - uses a fixed address since NULLIFIEREXISTS takes address as parameter */
+export declare const WARM_NULLIFIER: Fr;
+export declare const WARM_NULLIFIER_ADDRESS: AztecAddress;
+/** Warm storage constants - storage is inserted for the deployed contract's address */
+export declare const WARM_STORAGE_SLOT: Fr;
+export declare const WARM_STORAGE_VALUE: Fr;
+/**
+ * Leaf indices inserted to by insertWarmTreeEntries().
+ * Ideally we'd getTreeInfo and set dynamically, but that doesn't
+ * work easily with static spam configs, so we assume intial index 0.
+ */
+export declare const WARM_NOTE_HASH_LEAF_INDEX = 0n;
+export declare const WARM_L1_TO_L2_MSG_LEAF_INDEX = 0n;
+/**
+ * Insert entries into the trees so that "warm" configs can find them with existence checks.
+ * Call this before running the opcode spammer to enable warm tree reads.
+ *
+ * Inserts:
+ * - Note hash into NOTE_HASH_TREE
+ * - L1 to L2 message into L1_TO_L2_MESSAGE_TREE
+ * - Siloed nullifier into NULLIFIER_TREE (for NULLIFIEREXISTS warm check)
+ * - Storage value into PUBLIC_DATA_TREE (for SLOAD warm check)
+ */
+export declare function insertWarmTreeEntries(merkleTrees: MerkleTreeWriteOperations, contractAddress: AztecAddress): Promise<void>;
+/**
+ * A SpamConfig for to make external CALLs to an address specified in calldata[0].
+ */
+export declare const EXTERNAL_CALL_CONFIG: SpamConfig;
+/**
+ * Opcode spammer configs for ~all opcodes.
+ * Each opcode maps to an array of configs (usually one, but can be multiple for type variants, etc.)
+ * Uses smallest wire format (_8) for maximum instruction density.
+ */
+export declare const SPAM_CONFIGS: Partial<Record<Opcode, SpamConfig[]>>;
+/**
+ * Get all spam test cases grouped by opcode.
+ * This is the main entry point for tests - it handles all the complexity of
+ * type variants, multiple configs, etc.
+ *
+ * Returns hierarchical structure for nested describe blocks in tests.
+ *
+ * @param maxConfigsPerOpcode - Maximum number of configs to include per opcode.
+ *                              Defaults to Infinity (no limit). Useful for quick
+ *                              smoke tests where testing all type variants is too slow,
+ *                              or for proving tests that are inherently slower.
+ */
+export declare function getSpamConfigsPerOpcode(maxConfigsPerOpcode?: number): SpamConfigsForOpcode[];
+/**
+ * Generate basic opcode spam bytecode from a SpamConfig.
+ * Spams the target instruction(s) in an infinite loop until out-of-gas.
+ */
+export declare function createOpcodeSpamBytecode(config: SpamConfig): Buffer;
+/**
+ * Generate a bytecode that spams a side-effect limited opcode #limit times
+ * NOT in a loop, but inline/unrolled. Then revert.
+ *
+ * @param config - the side-effect limited spam config to use
+ * @returns the bytecode for the side-effect limited spam
+ */
+export declare function createSideEffectSpamBytecode(config: SpamConfig): Buffer;
+export declare function testOpcodeSpamCase(tester: PublicTxSimulationTester, config: SpamConfig, expectToBeTrue?: (x: boolean) => void): Promise<PublicTxResult>;
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"opcode_spammer.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/opcode_spammer.ts"],"names":[],"mappings":"AAkKA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAA2C,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAKjF,OAAO,EAAS,KAAK,WAAW,EAAgD,MAAM,4BAA4B,CAAC;AAkDnH,OAAO,EAAE,MAAM,EAAE,MAAM,mDAAmD,CAAC;AAE3E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAMjF;;GAEG;AACH,UAAU,QAAQ;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;CACpB;AAED;;;GAGG;AACH,KAAK,SAAS,GAAG,QAAQ,GAAG,CAAC,MAAM,UAAU,EAAE,CAAC,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iCAAiC;IACjC,KAAK,EAAE,SAAS,EAAE,CAAC;IAEnB,sDAAsD;IACtD,kBAAkB,EAAE,MAAM,UAAU,EAAE,CAAC;IAEvC,2DAA2D;IAC3D,mBAAmB,CAAC,EAAE,MAAM,UAAU,EAAE,CAAC;IAEzC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,0DAA0D;IAC1D,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IAEf,qDAAqD;IACrD,OAAO,EAAE,UAAU,EAAE,CAAC;CACvB;AAMD;;;GAGG;AACH,eAAO,MAAM,cAAc,IAAsB,CAAC;AAClD,eAAO,MAAM,iBAAiB,IAA8B,CAAC;AAE7D,uGAAuG;AACvG,eAAO,MAAM,cAAc,IAA0B,CAAC;AACtD,eAAO,MAAM,sBAAsB,cAAkC,CAAC;AAEtE,uFAAuF;AACvF,eAAO,MAAM,iBAAiB,IAA0B,CAAC;AACzD,eAAO,MAAM,kBAAkB,IAA0B,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAC5C,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAE/C;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,yBAAyB,EACtC,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,IAAI,CAAC,CAef;AAmGD;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,UA0BlC,CAAC;AAkCF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAy+B9D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,mBAAmB,GAAE,MAAiB,GAAG,oBAAoB,EAAE,CAsBtG;AA4FD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAenE;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAmBvE;AA4DD,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,wBAAwB,EAChC,MAAM,EAAE,UAAU,EAClB,cAAc,GAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAe,GAC9C,OAAO,CAAC,cAAc,CAAC,CAKzB"}