@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/dest/public/fixtures/public_tx_simulation_tester.js

@@ -1,93 +1,118 @@
-import { PUBLIC_DISPATCH_SELECTOR } from '@aztec/constants';
+import { asyncMap } from '@aztec/foundation/async-map';
 import { Fr } from '@aztec/foundation/fields';
-import { FunctionSelector, encodeArguments } from '@aztec/stdlib/abi';
-import { GasFees } from '@aztec/stdlib/gas';
-import { PublicExecutionRequest } from '@aztec/stdlib/tx';
-import { CallContext, GlobalVariables } from '@aztec/stdlib/tx';
-import { NativeWorldStateService } from '@aztec/world-state';
+import { encodeArguments } from '@aztec/stdlib/abi';
+import { Gas, GasFees } from '@aztec/stdlib/gas';
+import { PublicCallRequest } from '@aztec/stdlib/kernel';
+import { GlobalVariables, PublicCallRequestWithCalldata } from '@aztec/stdlib/tx';
 import { BaseAvmSimulationTester } from '../avm/fixtures/base_avm_simulation_tester.js';
-import { getContractFunctionArtifact, getFunctionSelector } from '../avm/fixtures/index.js';
-import { SimpleContractDataSource } from '../avm/fixtures/simple_contract_data_source.js';
-import { WorldStateDB } from '../public_db_sources.js';
-import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
-import { createTxForPublicCalls } from './index.js';
-const TIMESTAMP = new Fr(99833);
+import { DEFAULT_BLOCK_NUMBER, DEFAULT_TIMESTAMP, getContractFunctionAbi, getFunctionSelector } from '../avm/fixtures/utils.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { MeasuredCppPublicTxSimulatorHintedDbs } from '../public_tx_simulator/cpp_public_tx_simulator.js';
+import { MeasuredPublicTxSimulator } from '../public_tx_simulator/measured_public_tx_simulator.js';
+import { TestExecutorMetrics } from '../test_executor_metrics.js';
+import { SimpleContractDataSource } from './simple_contract_data_source.js';
+import { createTxForPublicCalls } from './utils.js';
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
-export const DEFAULT_BLOCK_NUMBER = 42;
 /**
  * A test class that extends the BaseAvmSimulationTester to enable real-app testing of the PublicTxSimulator.
  * It provides an interface for simulating one transaction at a time and maintains state between subsequent
  * transactions.
  */ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
-    worldStateDB;
+    metrics;
     txCount;
-    constructor(worldStateDB, contractDataSource, merkleTrees){
-        super(contractDataSource, merkleTrees), this.worldStateDB = worldStateDB, this.txCount = 0;
+    simulator;
+    metricsPrefix;
+    constructor(merkleTree, contractDataSource, globals = defaultGlobals(), metrics = new TestExecutorMetrics(), useCppSimulator = false){
+        super(contractDataSource, merkleTree), this.metrics = metrics, this.txCount = 0;
+        const contractsDB = new PublicContractsDB(contractDataSource);
+        const config = {
+            doMerkleOperations: true,
+            skipFeeEnforcement: false,
+            clientInitiatedSimulation: true
+        };
+        this.simulator = useCppSimulator ? new MeasuredCppPublicTxSimulatorHintedDbs(merkleTree, contractsDB, globals, this.metrics, config) : new MeasuredPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
     }
-    static async create() {
+    static async create(worldStateService, globals = defaultGlobals(), metrics = new TestExecutorMetrics(), useCppSimulator = false) {
         const contractDataSource = new SimpleContractDataSource();
-        const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-        const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
-        return new PublicTxSimulationTester(worldStateDB, contractDataSource, merkleTrees);
+        const merkleTree = await worldStateService.fork();
+        return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, useCppSimulator);
     }
-    async createTx(sender, setupCalls = [], appCalls = [], teardownCall, feePayer = sender, /* need some unique first nullifier for note-nonce computations */ firstNullifier = new Fr(420000 + this.txCount++)) {
-        const setupExecutionRequests = [];
-        for(let i = 0; i < setupCalls.length; i++){
-            const address = setupCalls[i].address;
-            const contractArtifact = setupCalls[i].contractArtifact || await this.contractDataSource.getContractArtifact(address);
-            if (!contractArtifact) {
-                throw new Error(`Contract artifact not found for address: ${address}`);
-            }
-            const req = await executionRequestForCall(contractArtifact, sender, address, setupCalls[i].fnName, setupCalls[i].args, setupCalls[i].isStaticCall);
-            setupExecutionRequests.push(req);
-        }
-        const appExecutionRequests = [];
-        for(let i = 0; i < appCalls.length; i++){
-            const address = appCalls[i].address;
-            const contractArtifact = appCalls[i].contractArtifact || await this.contractDataSource.getContractArtifact(address);
-            if (!contractArtifact) {
-                throw new Error(`Contract artifact not found for address: ${address}`);
-            }
-            const req = await executionRequestForCall(contractArtifact, sender, address, appCalls[i].fnName, appCalls[i].args, appCalls[i].isStaticCall);
-            appExecutionRequests.push(req);
-        }
-        let teardownExecutionRequest = undefined;
-        if (teardownCall) {
-            const address = teardownCall.address;
-            const contractArtifact = teardownCall.contractArtifact || await this.contractDataSource.getContractArtifact(address);
-            if (!contractArtifact) {
-                throw new Error(`Contract artifact not found for address: ${address}`);
-            }
-            teardownExecutionRequest = await executionRequestForCall(contractArtifact, sender, address, teardownCall.fnName, teardownCall.args, teardownCall.isStaticCall);
+    setMetricsPrefix(prefix) {
+        this.metricsPrefix = prefix;
+    }
+    async createTx(sender, setupCalls = [], appCalls = [], teardownCall, feePayer = sender, /* need some unique first nullifier for note-nonce computations */ privateInsertions = {
+        nonRevertible: {
+            nullifiers: [
+                new Fr(420000 + this.txCount)
+            ]
         }
-        return await createTxForPublicCalls(firstNullifier, setupExecutionRequests, appExecutionRequests, teardownExecutionRequest, feePayer);
+    }) {
+        const setupCallRequests = await asyncMap(setupCalls, (call)=>this.#createPubicCallRequestForCall(call, call.sender ?? sender));
+        const appCallRequests = await asyncMap(appCalls, (call)=>this.#createPubicCallRequestForCall(call, call.sender ?? sender));
+        const teardownCallRequest = teardownCall ? await this.#createPubicCallRequestForCall(teardownCall, teardownCall.sender ?? sender) : undefined;
+        this.txCount++;
+        return createTxForPublicCalls(privateInsertions, setupCallRequests, appCallRequests, teardownCallRequest, feePayer, /*gasUsedByPrivate*/ Gas.empty(), defaultGlobals());
     }
-    async simulateTx(sender, setupCalls = [], appCalls = [], teardownCall, feePayer = sender, /* need some unique first nullifier for note-nonce computations */ firstNullifier = new Fr(420000 + this.txCount++), globals = defaultGlobals()) {
-        const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, firstNullifier);
+    async simulateTx(sender, setupCalls = [], appCalls = [], teardownCall, feePayer = sender, /* need some unique first nullifier for note-nonce computations */ privateInsertions, txLabel = 'unlabeledTx') {
+        const tx = await this.createTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions);
         await this.setFeePayerBalance(feePayer);
-        const simulator = new PublicTxSimulator(this.merkleTrees, this.worldStateDB, globals, /*doMerkleOperations=*/ true);
-        const startTime = performance.now();
-        const avmResult = await simulator.simulate(tx);
-        const endTime = performance.now();
-        this.logger.debug(`Public transaction simulation took ${endTime - startTime}ms`);
+        const txLabelWithCount = `${txLabel}/${this.txCount - 1}`;
+        const fullTxLabel = this.metricsPrefix ? `${this.metricsPrefix}/${txLabelWithCount}` : txLabelWithCount;
+        const avmResult = await this.simulator.simulate(tx, fullTxLabel);
+        // Something like this is often useful for debugging:
+        //if (avmResult.revertReason) {
+        //  // resolve / enrich revert reason
+        //  const lastAppCall = appCalls[appCalls.length - 1];
+        //  const contractArtifact =
+        //    lastAppCall.contractArtifact || (await this.contractDataSource.getContractArtifact(lastAppCall.address));
+        //  const fnAbi = getContractFunctionAbi(lastAppCall.fnName, contractArtifact!);
+        //  const revertReason = resolveAssertionMessageFromRevertData(avmResult.revertReason.revertData, fnAbi!);
+        //  this.logger.debug(`Revert reason: ${revertReason}`);
+        //}
         return avmResult;
     }
+    /**
+   * Just simulate the transaction and return the result.
+   *
+   * This wrapper around simulation allows for easy labeling of a TX
+   * which is especially useful when reporting benchmarks or metrics.
+   */ async simulateTxWithLabel(txLabel, sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions) {
+        return await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, txLabel);
+    }
+    /**
+   * Execute a transaction and return the result.
+   *
+   * This function can be (it is) overridden by a subclass (AvmProvingTester)
+   * to do more work (like prove and verify) while still reusing existing
+   * test fixtures (like amm_test). That is why it is not named "simulate*".
+   */ async executeTxWithLabel(txLabel, sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions) {
+        return await this.simulateTxWithLabel(txLabel, sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions);
+    }
+    prettyPrintMetrics() {
+        this.metrics.prettyPrint();
+    }
+    async #createPubicCallRequestForCall(call, sender) {
+        const address = call.address;
+        const contractArtifact = call.contractArtifact || await this.contractDataSource.getContractArtifact(address);
+        if (!contractArtifact) {
+            throw new Error(`Contract artifact not found for address: ${address}`);
+        }
+        const fnSelector = await getFunctionSelector(call.fnName, contractArtifact);
+        const fnAbi = getContractFunctionAbi(call.fnName, contractArtifact);
+        const encodedArgs = encodeArguments(fnAbi, call.args);
+        const calldata = [
+            fnSelector.toField(),
+            ...encodedArgs
+        ];
+        const isStaticCall = call.isStaticCall ?? false;
+        const request = await PublicCallRequest.fromCalldata(sender, address, isStaticCall, calldata);
+        return new PublicCallRequestWithCalldata(request, calldata);
+    }
 }
-async function executionRequestForCall(contractArtifact, sender, address, fnName, args = [], isStaticCall = false) {
-    const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
-    const encodedArgs = encodeArguments(fnAbi, args);
-    const calldata = [
-        fnSelector.toField(),
-        ...encodedArgs
-    ];
-    const callContext = new CallContext(sender, address, /*selector=*/ new FunctionSelector(PUBLIC_DISPATCH_SELECTOR), isStaticCall);
-    return new PublicExecutionRequest(callContext, calldata);
-}
-function defaultGlobals() {
+export function defaultGlobals() {
     const globals = GlobalVariables.empty();
-    globals.timestamp = TIMESTAMP;
+    globals.timestamp = DEFAULT_TIMESTAMP;
     globals.gasFees = DEFAULT_GAS_FEES; // apply some nonzero default gas fees
-    globals.blockNumber = new Fr(DEFAULT_BLOCK_NUMBER);
+    globals.blockNumber = DEFAULT_BLOCK_NUMBER;
     return globals;
 }

package/dest/public/{avm/fixtures → fixtures}/simple_contract_data_source.d.ts

@@ -1,7 +1,7 @@
 import type { Fr } from '@aztec/foundation/fields';
-import { type ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
+import type { ContractArtifact, FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress, PublicFunction } from '@aztec/stdlib/contract';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 /**
  * This class is used during public/avm testing to function as a database of
  * contract contract classes and instances. Tests can populate it with classes
@@ -14,21 +14,21 @@ export declare class SimpleContractDataSource implements ContractDataSource {
     private contractClasses;
     private contractInstances;
     private contractArtifacts;
+    private debugFunctionName;
     /**
      * Derive the contract class and instance with some seed.
      * Add both to the contract data source along with the contract artifact.
      */
     addNewContract(contractArtifact: ContractArtifact, contractClass: ContractClassPublic, contractInstance: ContractInstanceWithAddress): Promise<void>;
-    addContractArtifact(classId: Fr, artifact: ContractArtifact): void;
-    getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction>;
+    addContractArtifact(classId: Fr, artifact: ContractArtifact): Promise<void>;
     getBlockNumber(): Promise<number>;
     getContractClass(id: Fr): Promise<ContractClassPublic | undefined>;
     getBytecodeCommitment(_id: Fr): Promise<Fr | undefined>;
     getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
     getContractClassIds(): Promise<Fr[]>;
     getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined>;
-    getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string>;
-    registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string>;
+    registerContractFunctionSignatures(_signatures: string[]): Promise<void>;
     addContractClass(contractClass: ContractClassPublic): Promise<void>;
     addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void>;
 }

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

@@ -0,0 +1 @@
+{"version":3,"file":"simple_contract_data_source.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/simple_contract_data_source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAInH;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,kBAAkB;IAC1D,MAAM,yCAA+C;IAG5D,OAAO,CAAC,eAAe,CAA+C;IAEtE,OAAO,CAAC,iBAAiB,CAAuD;IAEhF,OAAO,CAAC,iBAAiB,CAA4C;IAErE,OAAO,CAAC,iBAAiB,CAAkC;IAI3D;;;OAGG;IACG,cAAc,CAClB,gBAAgB,EAAE,gBAAgB,EAClC,aAAa,EAAE,mBAAmB,EAClC,gBAAgB,EAAE,2BAA2B;IAOzC,mBAAmB,CAAC,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB;IAkBjE,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAIjC,gBAAgB,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC;IAIlE,qBAAqB,CAAC,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAIvD,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC;IAIpF,mBAAmB,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAI9B,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAWjF,oBAAoB,CAAC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB9F,kCAAkC,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIxE,gBAAgB,CAAC,aAAa,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnE,mBAAmB,CAAC,gBAAgB,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;CAIlF"}

package/dest/public/{avm/fixtures → fixtures}/simple_contract_data_source.js

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
+import { getFunctionSelector } from '../avm/fixtures/utils.js';
 /**
  * This class is used during public/avm testing to function as a database of
  * contract contract classes and instances. Tests can populate it with classes
@@ -14,24 +14,34 @@ import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
     contractInstances = new Map();
     // maps contract instance address to address
     contractArtifacts = new Map();
+    // maps `${classID}:${fnSelector}` to name
+    debugFunctionName = new Map();
     /////////////////////////////////////////////////////////////
     // Helper functions not in the contract data source interface
     /**
    * Derive the contract class and instance with some seed.
    * Add both to the contract data source along with the contract artifact.
    */ async addNewContract(contractArtifact, contractClass, contractInstance) {
-        this.addContractArtifact(contractClass.id, contractArtifact);
+        await this.addContractArtifact(contractClass.id, contractArtifact);
         await this.addContractClass(contractClass);
         await this.addContractInstance(contractInstance);
     }
-    addContractArtifact(classId, artifact) {
+    async addContractArtifact(classId, artifact) {
         this.contractArtifacts.set(classId.toString(), artifact);
+        const classIdStr = classId.toString();
+        const publicFns = artifact.nonDispatchPublicFunctions;
+        if (publicFns.length !== 0) {
+            for (const fn of publicFns){
+                const actualFnName = `${fn.name}`;
+                const fnSelector = await getFunctionSelector(actualFnName, artifact);
+                const key = `${classIdStr}:${fnSelector.toString()}`;
+                const longFnName = `${artifact.name}.${actualFnName}`;
+                this.debugFunctionName.set(key, longFnName);
+            }
+        }
     }
     /////////////////////////////////////////////////////////////
     // ContractDataSource function implementations
-    getPublicFunction(_address, _selector) {
-        throw new Error('Method not implemented.');
-    }
     getBlockNumber() {
         throw new Error('Method not implemented.');
     }
@@ -55,12 +65,23 @@ import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
         }
         this.logger.debug(`Retrieved contract artifact for address: ${address}`);
         this.logger.debug(`Contract class ID: ${contractInstance.currentContractClassId}`);
-        return Promise.resolve(this.contractArtifacts.get(contractInstance.currentContractClassId.toString()));
+        return this.contractArtifacts.get(contractInstance.currentContractClassId.toString());
     }
-    getContractFunctionName(_address, _selector) {
-        return Promise.resolve(PUBLIC_DISPATCH_FN_NAME);
+    async getDebugFunctionName(address, selector) {
+        const contractInstance = await this.getContract(address);
+        if (!contractInstance) {
+            this.logger.warn(`Couldn't get fn name for debugging. Contract not in tester's ContractDataSource. Using selector:${selector} instead...`);
+            return `selector:${selector.toString()}`;
+        }
+        const key = `${contractInstance.currentContractClassId.toString()}:${selector.toString()}`;
+        const fnName = this.debugFunctionName.get(key);
+        if (!fnName) {
+            this.logger.warn(`Couldn't get fn name for debugging. Using selector:${selector} instead...`);
+            return selector.toString();
+        }
+        return fnName;
     }
-    registerContractFunctionSignatures(_address, _signatures) {
+    registerContractFunctionSignatures(_signatures) {
         return Promise.resolve();
     }
     addContractClass(contractClass) {

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

@@ -0,0 +1,8 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { ContractArtifact } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+export declare function tokenTest(tester: PublicTxSimulationTester, logger: Logger, tokenArtifact: ContractArtifact, expectToBeTrue: (x: boolean) => void): Promise<void>;
+export declare function setUpToken(tester: PublicTxSimulationTester, tokenArtifact: ContractArtifact, admin: AztecAddress, expectToBeTrue: (x: boolean) => void, seed?: number): Promise<ContractInstanceWithAddress>;
+//# sourceMappingURL=token_test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"token_test.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/token_test.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,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,wBAAsB,SAAS,CAC7B,MAAM,EAAE,wBAAwB,EAChC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,gBAAgB,EAC/B,cAAc,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,iBA+DrC;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,wBAAwB,EAChC,aAAa,EAAE,gBAAgB,EAC/B,KAAK,EAAE,YAAY,EACnB,cAAc,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,EACpC,IAAI,SAAI,wCA0BT"}

package/dest/public/fixtures/token_test.js

@@ -0,0 +1,95 @@
+import { Fr } from '@aztec/foundation/fields';
+import { Timer } from '@aztec/foundation/timer';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+export async function tokenTest(tester, logger, tokenArtifact, expectToBeTrue) {
+    const timer = new Timer();
+    const admin = AztecAddress.fromNumber(42);
+    const sender = AztecAddress.fromNumber(111);
+    const receiver = AztecAddress.fromNumber(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);
+    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, receiver, mintAmount - transferAmount, expectToBeTrue);
+    await checkBalance(tester, token, sender, receiver, transferAmount, expectToBeTrue);
+    // 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);
+    logger.info(`TokenContract test took ${timer.ms()}ms\n`);
+}
+export async function setUpToken(tester, tokenArtifact, admin, expectToBeTrue, 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, token, sender, account, expectedBalance, expectToBeTrue) {
+    // 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());
+    // should be 1 call with 1 return value that is expectedBalance
+    expectToBeTrue(balResult.processedPhases.length == 1);
+    expectToBeTrue(balResult.processedPhases[0].returnValues.length == 1);
+    expectToBeTrue(balResult.processedPhases[0].returnValues[0].values.length == 1);
+    expectToBeTrue(balResult.processedPhases[0].returnValues[0].values[0].toBigInt() == expectedBalance);
+}

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

@@ -2,12 +2,25 @@ import { Fr } from '@aztec/foundation/fields';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublic, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { Gas } from '@aztec/stdlib/gas';
-import { type PublicExecutionRequest, Tx } from '@aztec/stdlib/tx';
+import type { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
+import { GlobalVariables, PublicCallRequestWithCalldata, Tx } from '@aztec/stdlib/tx';
+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 declare function createTxForPublicCalls(firstNullifier: Fr, setupExecutionRequests: PublicExecutionRequest[], appExecutionRequests: PublicExecutionRequest[], teardownExecutionRequest?: PublicExecutionRequest, feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Promise<Tx>;
-export declare function createTxForPrivateOnly(feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Tx;
+export declare function createTxForPublicCalls(privateInsertions: TestPrivateInsertions, setupCallRequests: PublicCallRequestWithCalldata[], appCallRequests: PublicCallRequestWithCalldata[], teardownCallRequest?: PublicCallRequestWithCalldata, feePayer?: AztecAddress, gasUsedByPrivate?: Gas, globals?: GlobalVariables): Promise<Tx>;
+export declare function createTxForPrivateOnly(feePayer?: AztecAddress, gasUsedByPrivate?: Gas): Promise<Tx>;
 export declare function addNewContractClassToTx(tx: Tx, contractClass: ContractClassPublic, skipNullifierInsertion?: boolean): Promise<void>;
 export declare function addNewContractInstanceToTx(tx: Tx, contractInstance: ContractInstanceWithAddress, skipNullifierInsertion?: boolean): Promise<void>;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,GAAG,EAAwB,MAAM,mBAAmB,CAAC;AAW9D,OAAO,EAAE,KAAK,sBAAsB,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAKnE;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,EAAE,EAClB,sBAAsB,EAAE,sBAAsB,EAAE,EAChD,oBAAoB,EAAE,sBAAsB,EAAE,EAC9C,wBAAwB,CAAC,EAAE,sBAAsB,EACjD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,GAClC,OAAO,CAAC,EAAE,CAAC,CAkDb;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,eAAsB,EAAE,gBAAgB,GAAE,GAAqB,GAAG,EAAE,CAoBlH;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBAiC/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBA0C/B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/public/fixtures/utils.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,GAAG,EAAwB,MAAM,mBAAmB,CAAC;AAU9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAEL,eAAe,EAEf,6BAA6B,EAC7B,EAAE,EAGH,MAAM,kBAAkB,CAAC;AAI1B,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,CAAC,EAAE;QACX,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;IACF,aAAa,CAAC,EAAE;QACd,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC;QAClB,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;KACpC,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,iBAAiB,EAAE,qBAAqB,EACxC,iBAAiB,EAAE,6BAA6B,EAAE,EAClD,eAAe,EAAE,6BAA6B,EAAE,EAChD,mBAAmB,CAAC,EAAE,6BAA6B,EACnD,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAiB,EACnC,OAAO,GAAE,eAAyC,GACjD,OAAO,CAAC,EAAE,CAAC,CA+Fb;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,eAAsB,EAC9B,gBAAgB,GAAE,GAAqB,GACtC,OAAO,CAAC,EAAE,CAAC,CA0Bb;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,EAAE,EACN,aAAa,EAAE,mBAAmB,EAClC,sBAAsB,UAAQ,iBA6B/B;AAED,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,EAAE,EACN,gBAAgB,EAAE,2BAA2B,EAC7C,sBAAsB,UAAQ,iBA0C/B"}