@aztec-labs/simulator 6.0.0-nightly.20260829

package/src/public/fixtures/token_test.ts

@@ -0,0 +1,148 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Logger } from '@aztec-labs/foundation/log';
+import { Timer } from '@aztec-labs/foundation/timer';
+import type { ContractArtifact } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+
+export type TokenTestOptions = {
+  /** Skip return value assertions in balance checks (useful for benchmarking with collectCallMetadata=false) */
+  skipReturnValueAssertions?: boolean;
+};
+
+export async function tokenTest(
+  tester: PublicTxSimulationTester,
+  logger: Logger,
+  tokenArtifact: ContractArtifact,
+  expectToBeTrue: (x: boolean) => void,
+  options: TokenTestOptions = {},
+) {
+  const timer = new Timer();
+
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
+  const receiver = AztecAddress.fromNumberUnsafe(222);
+
+  const token = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue);
+
+  const mintAmount = 100n;
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const mintResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'Token/mint_to_public',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'mint_to_public',
+        args: [/*to=*/ sender, mintAmount],
+      },
+    ],
+  );
+  expectToBeTrue(mintResult.revertCode.isOK());
+  await checkBalance(tester, token, sender, sender, mintAmount, expectToBeTrue, options);
+
+  const authwitNonce = new Fr(0);
+  const transferAmount = 50n;
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const transferResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'Token/transfer_in_public',
+    /*sender=*/ sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'transfer_in_public',
+        args: [/*from=*/ sender, /*to=*/ receiver, transferAmount, authwitNonce],
+      },
+    ],
+  );
+  expectToBeTrue(transferResult.revertCode.isOK());
+  await checkBalance(tester, token, sender, sender, mintAmount - transferAmount, expectToBeTrue, options);
+  await checkBalance(tester, token, sender, receiver, transferAmount, expectToBeTrue, options);
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const burnResult = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'Token/burn_public',
+    /*sender=*/ receiver,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'burn_public',
+        args: [/*from=*/ receiver, transferAmount, authwitNonce],
+      },
+    ],
+  );
+  expectToBeTrue(burnResult.revertCode.isOK());
+  await checkBalance(tester, token, sender, receiver, 0n, expectToBeTrue, options);
+
+  logger.info(`TokenContract test took ${timer.ms()}ms\n`);
+}
+
+export async function setUpToken(
+  tester: PublicTxSimulationTester,
+  tokenArtifact: ContractArtifact,
+  admin: AztecAddress,
+  expectToBeTrue: (x: boolean) => void,
+  seed = 0,
+) {
+  const constructorArgs = [admin, /*name=*/ 'Token', /*symbol=*/ 'TOK', /*decimals=*/ new Fr(18)];
+  const token = await tester.registerAndDeployContract(
+    constructorArgs,
+    /*deployer=*/ admin,
+    tokenArtifact,
+    /*skipNullifierInsertion=*/ false,
+    seed,
+  );
+
+  // EXECUTE! This means that if using AvmProvingTester subclass, it will PROVE the transaction!
+  const result = await tester.executeTxWithLabel(
+    /*txLabel=*/ 'Token/constructor',
+    /*sender=*/ admin,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        fnName: 'constructor',
+        args: constructorArgs,
+        address: token.address,
+      },
+    ],
+  );
+  expectToBeTrue(result.revertCode.isOK());
+  return token;
+}
+
+async function checkBalance(
+  tester: PublicTxSimulationTester,
+  token: ContractInstanceWithAddress,
+  sender: AztecAddress,
+  account: AztecAddress,
+  expectedBalance: bigint,
+  expectToBeTrue: (x: boolean) => void,
+  options: TokenTestOptions = {},
+) {
+  // Strictly simulate this! No need to "execute" (aka prove if using AvmProvingTester subclass).
+  const balResult = await tester.simulateTxWithLabel(
+    /*txLabel=*/ 'Token/balance_of_public',
+    sender,
+    /*setupCalls=*/ [],
+    /*appCalls=*/ [
+      {
+        address: token.address,
+        fnName: 'balance_of_public',
+        args: [/*owner=*/ account],
+        isStaticCall: true,
+      },
+    ],
+  );
+  expectToBeTrue(balResult.revertCode.isOK());
+  if (!options.skipReturnValueAssertions) {
+    // should be 1 call with 1 return value that is expectedBalance
+    const appLogicReturnValues = balResult.getAppLogicReturnValues();
+    expectToBeTrue(appLogicReturnValues.length === 1);
+    expectToBeTrue(appLogicReturnValues[0].values?.[0]?.toBigInt() === expectedBalance);
+  }
+}

package/src/public/fixtures/utils.ts

@@ -0,0 +1,269 @@
+import {
+  CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE,
+  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
+  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
+  MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT,
+  MAX_PROCESSABLE_L2_GAS,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+} from '@aztec-labs/constants';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG } from '@aztec-labs/protocol-contracts';
+import { bufferAsFields } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec-labs/stdlib/contract';
+import { Gas, GasFees, GasSettings } from '@aztec-labs/stdlib/gas';
+import { siloNullifier } from '@aztec-labs/stdlib/hash';
+import {
+  LogHash,
+  PartialPrivateTailPublicInputsForPublic,
+  PartialPrivateTailPublicInputsForRollup,
+  PrivateKernelTailCircuitPublicInputs,
+  countAccumulatedItems,
+} from '@aztec-labs/stdlib/kernel';
+import { ContractClassLogFields, PrivateLog } from '@aztec-labs/stdlib/logs';
+import type { ScopedL2ToL1Message } from '@aztec-labs/stdlib/messaging';
+import { ChonkProof } from '@aztec-labs/stdlib/proofs';
+import {
+  BlockHeader,
+  GlobalVariables,
+  HashedValues,
+  PublicCallRequestWithCalldata,
+  Tx,
+  TxConstantData,
+  TxContext,
+} from '@aztec-labs/stdlib/tx';
+import { strict as assert } from 'assert';
+
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
+
+export type TestPrivateInsertions = {
+  revertible?: {
+    nullifiers?: Fr[];
+    noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
+  };
+  nonRevertible?: {
+    nullifiers?: Fr[];
+    noteHashes?: Fr[];
+    l2ToL1Msgs?: ScopedL2ToL1Message[];
+  };
+};
+
+/**
+ * Craft a carrier transaction for some public calls for simulation by PublicTxSimulator.
+ */
+export async function createTxForPublicCalls(
+  privateInsertions: TestPrivateInsertions,
+  setupCallRequests: PublicCallRequestWithCalldata[],
+  appCallRequests: PublicCallRequestWithCalldata[],
+  teardownCallRequest?: PublicCallRequestWithCalldata,
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = Gas.empty(),
+  globals: GlobalVariables = GlobalVariables.empty(),
+  gasLimits?: Gas,
+): Promise<Tx> {
+  assert(
+    setupCallRequests.length > 0 || appCallRequests.length > 0 || teardownCallRequest !== undefined,
+    "Can't create public tx with no enqueued calls",
+  );
+  // use max limits
+  gasLimits = gasLimits ?? new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
+
+  const forPublic = PartialPrivateTailPublicInputsForPublic.empty();
+
+  // Non revertible private insertions
+  if (!privateInsertions.nonRevertible?.nullifiers?.length) {
+    throw new Error('At least one non-revertible nullifier is required');
+  }
+
+  for (let i = 0; i < privateInsertions.nonRevertible.nullifiers.length; i++) {
+    assert(i < forPublic.nonRevertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+    forPublic.nonRevertibleAccumulatedData.nullifiers[i] = privateInsertions.nonRevertible.nullifiers[i];
+  }
+  if (privateInsertions.nonRevertible.noteHashes) {
+    for (let i = 0; i < privateInsertions.nonRevertible.noteHashes.length; i++) {
+      assert(i < forPublic.nonRevertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+      forPublic.nonRevertibleAccumulatedData.noteHashes[i] = privateInsertions.nonRevertible.noteHashes[i];
+    }
+  }
+  if (privateInsertions.nonRevertible.l2ToL1Msgs) {
+    for (let i = 0; i < privateInsertions.nonRevertible.l2ToL1Msgs.length; i++) {
+      assert(i < forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+      forPublic.nonRevertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.nonRevertible.l2ToL1Msgs[i];
+    }
+  }
+
+  // Revertible private insertions
+  if (privateInsertions.revertible) {
+    if (privateInsertions.revertible.noteHashes) {
+      for (let i = 0; i < privateInsertions.revertible.noteHashes.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.noteHashes.length, 'Note hash index out of bounds');
+        forPublic.revertibleAccumulatedData.noteHashes[i] = privateInsertions.revertible.noteHashes[i];
+      }
+    }
+    if (privateInsertions.revertible.nullifiers) {
+      for (let i = 0; i < privateInsertions.revertible.nullifiers.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.nullifiers.length, 'Nullifier index out of bounds');
+        forPublic.revertibleAccumulatedData.nullifiers[i] = privateInsertions.revertible.nullifiers[i];
+      }
+    }
+    if (privateInsertions.revertible.l2ToL1Msgs) {
+      for (let i = 0; i < privateInsertions.revertible.l2ToL1Msgs.length; i++) {
+        assert(i < forPublic.revertibleAccumulatedData.l2ToL1Msgs.length, 'L2 to L1 message index out of bounds');
+        forPublic.revertibleAccumulatedData.l2ToL1Msgs[i] = privateInsertions.revertible.l2ToL1Msgs[i];
+      }
+    }
+  }
+
+  for (let i = 0; i < setupCallRequests.length; i++) {
+    forPublic.nonRevertibleAccumulatedData.publicCallRequests[i] = setupCallRequests[i].request;
+  }
+  for (let i = 0; i < appCallRequests.length; i++) {
+    forPublic.revertibleAccumulatedData.publicCallRequests[i] = appCallRequests[i].request;
+  }
+  if (teardownCallRequest) {
+    forPublic.publicTeardownCallRequest = teardownCallRequest.request;
+  }
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const teardownGasLimits = teardownCallRequest ? new Gas(TEARDOWN_DA_GAS_LIMIT, TEARDOWN_L2_GAS_LIMIT) : Gas.empty();
+  const gasSettings = new GasSettings(gasLimits, teardownGasLimits, maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const header = BlockHeader.empty({ globalVariables: globals });
+  const constantData = new TxConstantData(header, txContext, Fr.zero(), Fr.zero());
+  const expirationTimestamp = 0n; // Not used in the simulator.
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    expirationTimestamp,
+    forPublic,
+  );
+
+  const calldata = [
+    ...setupCallRequests,
+    ...appCallRequests,
+    ...(teardownCallRequest ? [teardownCallRequest] : []),
+  ].map(r => new HashedValues(r.calldata, r.request.calldataHash));
+
+  return await Tx.create({
+    data: txData,
+    chonkProof: ChonkProof.random(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: calldata,
+  });
+}
+
+export async function createTxForPrivateOnly(
+  feePayer = AztecAddress.zero(),
+  gasUsedByPrivate: Gas = new Gas(10, 10),
+): Promise<Tx> {
+  // use max limits
+  const gasLimits = new Gas(MAX_PROCESSABLE_DA_GAS_PER_CHECKPOINT, MAX_PROCESSABLE_L2_GAS);
+
+  const forRollup = PartialPrivateTailPublicInputsForRollup.empty();
+
+  const maxFeesPerGas = feePayer.isZero() ? GasFees.empty() : new GasFees(10, 10);
+  const gasSettings = new GasSettings(gasLimits, Gas.empty(), maxFeesPerGas, GasFees.empty());
+  const txContext = new TxContext(Fr.zero(), Fr.zero(), gasSettings);
+  const constantData = new TxConstantData(BlockHeader.empty(), txContext, Fr.zero(), Fr.zero());
+  const expirationTimestamp = 0n; // Not used in the simulator.
+
+  const txData = new PrivateKernelTailCircuitPublicInputs(
+    constantData,
+    /*gasUsed=*/ gasUsedByPrivate,
+    feePayer,
+    expirationTimestamp,
+    /*forPublic=*/ undefined,
+    forRollup,
+  );
+  return await Tx.create({
+    data: txData,
+    chonkProof: ChonkProof.empty(),
+    contractClassLogFields: [],
+    publicFunctionCalldata: [],
+  });
+}
+
+export async function addNewContractClassToTx(
+  tx: Tx,
+  contractClass: ContractClassPublic,
+  skipNullifierInsertion = false,
+) {
+  const contractClassLogFields = [
+    new Fr(CONTRACT_CLASS_PUBLISHED_MAGIC_VALUE),
+    contractClass.id,
+    new Fr(contractClass.version),
+    new Fr(contractClass.artifactHash),
+    new Fr(contractClass.privateFunctionsRoot),
+    ...bufferAsFields(contractClass.packedBytecode, Math.ceil(contractClass.packedBytecode.length / 31) + 1),
+  ];
+  const contractAddress = new AztecAddress(new Fr(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS));
+  const emittedLength = contractClassLogFields.length;
+  const logFields = ContractClassLogFields.fromEmittedFields(contractClassLogFields);
+
+  const contractClassLogHash = LogHash.from({
+    value: await logFields.hash(),
+    length: emittedLength,
+  }).scope(contractAddress);
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractClass.id;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.contractClassLogsHashes);
+  accumulatedData.contractClassLogsHashes[nextLogIndex] = contractClassLogHash;
+
+  tx.contractClassLogFields.push(logFields);
+}
+
+export async function addNewContractInstanceToTx(
+  tx: Tx,
+  contractInstance: ContractInstanceWithAddress,
+  skipNullifierInsertion = false,
+) {
+  // Only ivpk_m is broadcast as a point (x, y); the other five keys are hashes.
+  const publicKeysAsFields = [
+    contractInstance.publicKeys.npkMHash,
+    contractInstance.publicKeys.ivpkM.x,
+    contractInstance.publicKeys.ivpkM.y,
+    contractInstance.publicKeys.ovpkMHash,
+    contractInstance.publicKeys.tpkMHash,
+    contractInstance.publicKeys.mspkMHash,
+    contractInstance.publicKeys.fbpkMHash,
+  ];
+  const logFields = [
+    CONTRACT_INSTANCE_PUBLISHED_EVENT_TAG,
+    contractInstance.address.toField(),
+    new Fr(contractInstance.version),
+    new Fr(contractInstance.salt),
+    contractInstance.currentContractClassId,
+    contractInstance.initializationHash,
+    contractInstance.immutablesHash,
+    ...publicKeysAsFields,
+    contractInstance.deployer.toField(),
+  ];
+  const contractInstanceLog = new PrivateLog(
+    padArrayEnd(logFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS),
+    logFields.length,
+  );
+
+  const contractAddressNullifier = await siloNullifier(
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    contractInstance.address.toField(),
+  );
+
+  const accumulatedData = tx.data.forPublic ? tx.data.forPublic!.revertibleAccumulatedData : tx.data.forRollup!.end;
+  if (!skipNullifierInsertion) {
+    const nextNullifierIndex = countAccumulatedItems(accumulatedData.nullifiers);
+    accumulatedData.nullifiers[nextNullifierIndex] = contractAddressNullifier;
+  }
+
+  const nextLogIndex = countAccumulatedItems(accumulatedData.privateLogs);
+  accumulatedData.privateLogs[nextLogIndex] = contractInstanceLog;
+}