@aztec/simulator 0.0.0-test.0 → 0.0.1-fake-c83136db25

package/src/public/fixtures/bulk_test.ts

@@ -0,0 +1,169 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export async function bulkTest(
+  tester: PublicTxSimulationTester,
+  logger: Logger,
+  avmTestContractArtifact: ContractArtifact,
+) {
+  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: PublicTxSimulationTester,
+  logger: Logger,
+  avmTestContractArtifact: ContractArtifact,
+) {
+  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: Fr[]) => [
+    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) },
+      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField6) },
+      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField7) },
+      { address: avmTestContract.address, fnName: 'bulk_testing', args: genArgs(argsField8) },
+    ],
+    /*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/src/public/fixtures/custom_bytecode_tester.ts

@@ -0,0 +1,49 @@
+import { FunctionType, emptyContractArtifact, emptyFunctionArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+import type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+/**
+ *
+ * Test custom bytecode (simulation or proving) with the provided bytecode.
+ * @param bytecode - The bytecode buffer to use
+ * @param tester - The tester to use (simulation or proving)
+ * @param txLabel - The label of the transaction
+ * @param contractName - The name of the contract (default: 'CustomBytecodeContract')
+ */
+export async function testCustomBytecode(
+  bytecode: Buffer,
+  tester: PublicTxSimulationTester,
+  txLabel: string,
+  contractName: string = 'CustomBytecodeContract',
+): Promise<PublicTxResult> {
+  const deployer = AztecAddress.fromNumber(42);
+
+  const contractArtifact = emptyContractArtifact();
+  contractArtifact.name = contractName;
+  contractArtifact.functions = [emptyFunctionArtifact()];
+  contractArtifact.functions[0].name = 'public_dispatch';
+  contractArtifact.functions[0].functionType = FunctionType.PUBLIC;
+  contractArtifact.functions[0].bytecode = bytecode;
+
+  const testContract = await tester.registerAndDeployContract(
+    /*constructorArgs=*/ [],
+    deployer,
+    /*contractArtifact=*/ contractArtifact,
+  );
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  return await tester.executeTxWithLabel(
+    /*txLabel=*/ txLabel,
+    /*sender=*/ deployer,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: testContract.address,
+        fnName: 'public_dispatch',
+        args: [],
+      },
+    ],
+  );
+}

package/src/public/fixtures/custom_bytecode_tests.ts

@@ -0,0 +1,135 @@
+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 { encodeToBytecode } from '../avm/serialization/bytecode_serialization.js';
+import {
+  MAX_OPCODE_VALUE,
+  Opcode,
+  OperandType,
+  getOperandSize,
+} from '../avm/serialization/instruction_serialization.js';
+import { testCustomBytecode } 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
+// of invalid tag (FF). This will trigger an exceptional halt.
+export async function addressingWithBaseTagIssueTest(isIndirect: boolean, tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(bytecode, tester, txLabel);
+}
+
+export async function pcOutOfRangeTest(tester: PublicTxSimulationTester) {
+  const bytecode = encodeToBytecode([
+    new Jump(/*jumpOffset=*/ 123), // Jump to out-of-range pc offset.
+    new Return(/*indirect=*/ 0, /*copySizeOffset=*/ 0, /*returnOffset=*/ 0),
+  ]);
+
+  const txLabel = 'PcOutOfRange';
+  return await testCustomBytecode(bytecode, tester, txLabel);
+}
+
+export async function invalidOpcodeTest(tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Single invalid byte in the bytecode.
+export async function invalidByteTest(tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Truncate the last instruction in the bytecode.
+export async function instructionTruncatedTest(tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Invalid tag value byte in an instruction.
+export async function invalidTagValueTest(tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(bytecode, tester, txLabel);
+}
+
+// Combine an invalid tag in the last instruction that is truncated.
+export async function invalidTagValueAndInstructionTruncatedTest(tester: PublicTxSimulationTester) {
+  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 testCustomBytecode(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: OperandType[]): number {
+  let offset = 0;
+  for (const operand of wireFormat) {
+    if (operand === OperandType.TAG) {
+      break;
+    }
+    offset += getOperandSize(operand);
+  }
+  return offset;
+}

package/src/public/fixtures/index.ts

@@ -1,2 +1,9 @@
 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 { 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';

package/src/public/fixtures/minimal_public_tx.ts

@@ -0,0 +1,36 @@
+import { AvmCircuitInputs } 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 type { PublicTxResult } from '../public_tx_simulator/public_tx_simulator.js';
+import { testCustomBytecode } from './custom_bytecode_tester.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export async function executeAvmMinimalPublicTx(tester: PublicTxSimulationTester): Promise<PublicTxResult> {
+  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 testCustomBytecode(minimalBytecode, tester, 'MinimalTx', 'AvmMinimalContract');
+
+  // Modify the protocol contracts to be all zeros
+  result.avmProvingRequest.inputs.hints.protocolContracts = ProtocolContracts.empty();
+  result.avmProvingRequest.inputs.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);
+}