@aztec/simulator 0.0.1-commit.d3ec352c → 0.0.1-commit.fcb71a6

package/src/public/fixtures/custom_bytecode_tests.ts

@@ -2,7 +2,7 @@ import { strict as assert } from 'assert';
 
 import { TypeTag } from '../avm/avm_memory_types.js';
 import { Addressing, AddressingMode } from '../avm/opcodes/addressing_mode.js';
-import { CalldataCopy, Jump, Return, Set } from '../avm/opcodes/index.js';
+import { Add, CalldataCopy, Jump, Return, Set } from '../avm/opcodes/index.js';
 import { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
 import {
   MAX_OPCODE_VALUE,
@@ -10,7 +10,7 @@ import {
   OperandType,
   getOperandSize,
 } from '../avm/serialization/instruction_serialization.js';
-import { testCustomBytecode } from './custom_bytecode_tester.js';
+import { deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
 import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
 
 // First instruction resolved a base address (offset 0) which is uninitialized and therefore
@@ -28,7 +28,91 @@ export async function addressingWithBaseTagIssueTest(isIndirect: boolean, tester
   ]);
 
   const txLabel = isIndirect ? 'AddressingWithBaseTagInvalidIndirect' : 'AddressingWithBaseTagInvalidDirect';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  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: PublicTxSimulationTester) {
+  // Set a U64 value at offset 0 - this will be used as an indirect address
+  const addressingMode = Addressing.fromModes([
+    AddressingMode.INDIRECT, // First operand (cdOffset) uses indirect addressing
+    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: PublicTxSimulationTester) {
+  const addressingMode = Addressing.fromModes([
+    AddressingMode.INDIRECT, // First operand (aOffset) uses indirect addressing, no relative
+    AddressingMode.RELATIVE, // Second operand (bOffset) uses relative addressing
+    AddressingMode.DIRECT, // Third operand (dstOffset) uses direct addressing
+  ]);
+
+  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: PublicTxSimulationTester) {
+  const addressingMode = Addressing.fromModes([
+    AddressingMode.INDIRECT_RELATIVE, // First operand (aOffset) uses both indirect and relative addressing
+    AddressingMode.INDIRECT, // Second operand (bOffset) uses indirect addressing only
+    AddressingMode.DIRECT, // Third operand (dstOffset) uses direct addressing
+  ]);
+
+  // 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: PublicTxSimulationTester) {
@@ -38,7 +122,7 @@ export async function pcOutOfRangeTest(tester: PublicTxSimulationTester) {
   ]);
 
   const txLabel = 'PcOutOfRange';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 export async function invalidOpcodeTest(tester: PublicTxSimulationTester) {
@@ -57,7 +141,7 @@ export async function invalidOpcodeTest(tester: PublicTxSimulationTester) {
   bytecode[offsetReturnOpcodeByte] = MAX_OPCODE_VALUE + 1; // opcode is invalid.
 
   const txLabel = 'InvalidOpcode';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 // Single invalid byte in the bytecode.
@@ -67,7 +151,7 @@ export async function invalidByteTest(tester: PublicTxSimulationTester) {
   const bytecode = Buffer.from([invalidOpcode]);
 
   const txLabel = 'InvalidByte';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 // Truncate the last instruction in the bytecode.
@@ -80,7 +164,7 @@ export async function instructionTruncatedTest(tester: PublicTxSimulationTester)
   bytecode = bytecode.subarray(0, -1);
 
   const txLabel = 'InstructionTruncated';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 // Invalid tag value byte in an instruction.
@@ -95,7 +179,7 @@ export async function invalidTagValueTest(tester: PublicTxSimulationTester) {
   bytecode[tagOffset] = TypeTag.INVALID;
 
   const txLabel = 'InvalidTagValue';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 // Combine an invalid tag in the last instruction that is truncated.
@@ -112,7 +196,7 @@ export async function invalidTagValueAndInstructionTruncatedTest(tester: PublicT
   bytecode[tagOffset] = 0x6f; // Invalid tag value.
 
   const txLabel = 'InvalidTagValueAndInstructionTruncated';
-  return await testCustomBytecode(bytecode, tester, txLabel);
+  return await deployAndExecuteCustomBytecode(bytecode, tester, txLabel);
 }
 
 /**

package/src/public/fixtures/index.ts

@@ -1,9 +1,15 @@
 export * from './public_tx_simulation_tester.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
-export { readAvmMinimalPublicTxInputsFromFile, executeAvmMinimalPublicTx } from './minimal_public_tx.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/src/public/fixtures/minimal_public_tx.ts

@@ -1,12 +1,11 @@
-import { AvmCircuitInputs, type PublicTxResult } from '@aztec/stdlib/avm';
+import type { PublicTxResult } from '@aztec/stdlib/avm';
 import { ProtocolContracts } from '@aztec/stdlib/tx';
 
-import avmMinimalCircuitInputsJson from '../../../artifacts/avm_minimal_inputs.json' with { type: 'json' };
 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 { testCustomBytecode } from './custom_bytecode_tester.js';
+import { deployAndExecuteCustomBytecode } from './custom_bytecode_tester.js';
 import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
 
 export async function executeAvmMinimalPublicTx(tester: PublicTxSimulationTester): Promise<PublicTxResult> {
@@ -17,19 +16,11 @@ export async function executeAvmMinimalPublicTx(tester: PublicTxSimulationTester
     new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 2),
   ]);
 
-  const result = await testCustomBytecode(minimalBytecode, tester, 'MinimalTx', 'AvmMinimalContract');
+  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();
+  result.publicInputs!.protocolContracts = ProtocolContracts.empty();
 
   return result;
 }
-
-/**
- * Reads the AVM circuit inputs for the minimal public tx from a pre-generated JSON file.
- * @returns The AvmCircuitInputs for the minimal public tx.
- */
-export function readAvmMinimalPublicTxInputsFromFile(): AvmCircuitInputs {
-  return AvmCircuitInputs.schema.parse(avmMinimalCircuitInputsJson);
-}