@aztec/end-to-end 0.0.1-commit.5daedc8 → 0.0.1-commit.6201a7b05

package/src/bench/utils.ts

@@ -1,8 +1,11 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, NO_WAIT, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { waitForTx } from '@aztec/aztec.js/node';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
 import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
-import type { MetricsType } from '@aztec/telemetry-client';
+import type { TxHash } from '@aztec/stdlib/tx';
+import type { MetricDefinition } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
 import { mkdirSync, writeFileSync } from 'fs';
@@ -15,17 +18,17 @@ import { type EndToEndContext, type SetupOptions, setup } from '../fixtures/util
  */
 export async function benchmarkSetup(
   opts: Partial<SetupOptions> & {
-    /** What metrics to export */ metrics: (MetricsType | MetricFilter)[];
+    /** What metrics to export */ metrics: (MetricDefinition | MetricFilter)[];
     /** Where to output the benchmark data (defaults to BENCH_OUTPUT or bench.json) */
     benchOutput?: string;
   },
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
   const defaultAccountAddress = context.accounts[0];
-  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress }).deployed();
+  const { contract } = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress });
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
-  const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
+  const telemetry = context.telemetryClient as BenchmarkTelemetryClient;
   context.logger.warn(`Cleared benchmark data points from setup`);
   telemetry.clear();
   const origTeardown = context.teardown.bind(context);
@@ -46,7 +49,7 @@ export async function benchmarkSetup(
 }
 
 type MetricFilter = {
-  source: MetricsType;
+  source: MetricDefinition;
   transform: (value: number) => number;
   name: string;
   unit?: string;
@@ -61,17 +64,21 @@ export type GithubActionBenchmarkResult = {
   extra?: string;
 };
 
+function isMetricDefinition(f: MetricDefinition | MetricFilter): f is MetricDefinition {
+  return 'description' in f;
+}
+
 function formatMetricsForGithubBenchmarkAction(
   data: BenchmarkMetricsType,
-  filter: (MetricsType | MetricFilter)[],
+  filter: (MetricDefinition | MetricFilter)[],
 ): GithubActionBenchmarkResult[] {
   const allFilters: MetricFilter[] = filter.map(f =>
-    typeof f === 'string' ? { name: f, source: f, transform: (x: number) => x, unit: undefined } : f,
+    isMetricDefinition(f) ? { name: f.name, source: f, transform: (x: number) => x, unit: f.unit } : f,
   );
   return data.flatMap(meter => {
     return meter.metrics
-      .filter(metric => allFilters.map(f => f.source).includes(metric.name as MetricsType))
-      .map(metric => [metric, allFilters.find(f => f.source === metric.name)!] as const)
+      .filter(metric => allFilters.map(f => f.source.name).includes(metric.name))
+      .map(metric => [metric, allFilters.find(f => f.source.name === metric.name)!] as const)
       .map(([metric, filter]) => ({
         name: `${meter.name}/${filter.name}`,
         unit: filter.unit ?? metric.unit ?? 'unknown',
@@ -103,19 +110,22 @@ function getMetricValues(points: BenchmarkDataPoint[]) {
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns A BatchCall instance.
  */
-function makeCall(
+async function makeCall(
   index: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean,
 ) {
-  const [owner] = context.accounts;
   if (heavyPublicCompute) {
     return new BatchCall(context.wallet, [contract.methods.sha256_hash_1024(randomBytesAsBigInts(1024))]);
   } else {
+    // We use random address for the new note owner because we can emit at most UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN
+    // logs for a given sender-recipient-contract tuple.
+    const ownerOfNewNote = await AztecAddress.random();
+    const [ownerOfBalance] = context.accounts;
     return new BatchCall(context.wallet, [
-      contract.methods.create_note(owner, index + 1),
-      contract.methods.increment_balance(owner, index + 1),
+      contract.methods.create_note(ownerOfNewNote, index + 1),
+      contract.methods.increment_balance(ownerOfBalance, index + 1),
     ]);
   }
 }
@@ -129,23 +139,28 @@ function makeCall(
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns Array of sent txs.
  */
-export function sendTxs(
+export async function sendTxs(
   txCount: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): SentTx[] {
-  const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
+): Promise<TxHash[]> {
+  const calls = await Promise.all(times(txCount, index => makeCall(index, context, contract, heavyPublicCompute)));
   context.logger.info(`Creating ${txCount} txs`);
   const [from] = context.accounts;
   context.logger.info(`Sending ${txCount} txs`);
-  return calls.map(call => call.send({ from }));
+  return Promise.all(
+    calls.map(async call => {
+      const { txHash } = await call.send({ from, wait: NO_WAIT });
+      return txHash;
+    }),
+  );
 }
 
-export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
+export async function waitTxs(txs: TxHash[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
   context.logger.info(`Awaiting ${txs.length} txs to be mined`);
-  await Promise.all(txs.map(tx => tx.wait(txWaitOpts)));
-  context.logger.info(`All ${txs.length} txs have been mined`);
+  await Promise.all(txs.map(txHash => waitForTx(context.aztecNode, txHash, txWaitOpts)));
+  context.logger.info(`${txs.length} txs have been mined`);
 }
 
 function randomBytesAsBigInts(length: number): bigint[] {

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -7,22 +7,16 @@ import type { TxHash } from '@aztec/aztec.js/tx';
 import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
+import { GenericProxyContract } from '@aztec/noir-test-contracts.js/GenericProxy';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { AztecNodeDebug } from '@aztec/stdlib/interfaces/client';
 
 import { jest } from '@jest/globals';
 
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-  publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
+import { type EndToEndContext, deployAccounts, publicDeployAccounts, setup, teardown } from '../fixtures/setup.js';
 import { TokenSimulator } from '../simulators/token_simulator.js';
-
-const { E2E_DATA_PATH: dataPath } = process.env;
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 
 export class Role {
   private isAdmin = false;
@@ -55,15 +49,16 @@ export class BlacklistTokenContractTest {
   // This value MUST match the same value that we have in the contract
   static CHANGE_ROLES_DELAY = 86400;
 
-  private snapshotManager: ISnapshotManager;
+  context!: EndToEndContext;
   logger: Logger;
   wallet!: TestWallet;
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
+  authwitProxy!: GenericProxyContract;
   cheatCodes!: CheatCodes;
   sequencer!: SequencerClient;
-  aztecNode!: AztecNode;
+  aztecNode!: AztecNode & AztecNodeDebug;
 
   adminAddress!: AztecAddress;
   otherAddress!: AztecAddress;
@@ -71,98 +66,90 @@ export class BlacklistTokenContractTest {
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_blacklist_token_contract/${testName}`, dataPath);
   }
 
   async crossTimestampOfChange() {
-    await this.cheatCodes.warpL2TimeAtLeastBy(
-      this.sequencer,
-      this.aztecNode,
-      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
-    );
+    await this.cheatCodes.warpL2TimeAtLeastBy(this.aztecNode, BlacklistTokenContractTest.CHANGE_ROLES_DELAY);
   }
 
   /**
-   * Adds two state shifts to snapshot manager.
+   * Applies base setup:
    * 1. Add 3 accounts.
    * 2. Publicly deploy accounts, deploy token contract and a "bad account".
    */
-  async applyBaseSnapshots() {
+  async applyBaseSetup() {
     // Adding a timeout of 2 minutes in here such that it is propagated to the underlying tests
     jest.setTimeout(120_000);
 
-    await this.snapshotManager.snapshot(
-      '3_accounts',
-      deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { cheatCodes, aztecNode, sequencer, wallet }) => {
-        this.cheatCodes = cheatCodes;
-        this.aztecNode = aztecNode;
-        this.sequencer = sequencer;
-        this.wallet = wallet;
-        this.adminAddress = deployedAccounts[0].address;
-        this.otherAddress = deployedAccounts[1].address;
-        this.blacklistedAddress = deployedAccounts[2].address;
-        return Promise.resolve();
-      },
+    this.logger.info('Deploying 3 accounts');
+    const { deployedAccounts } = await deployAccounts(
+      3,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+
+    this.cheatCodes = this.context.cheatCodes;
+    this.aztecNode = this.context.aztecNodeService;
+    this.sequencer = this.context.sequencer!;
+    this.wallet = this.context.wallet;
+    this.adminAddress = deployedAccounts[0].address;
+    this.otherAddress = deployedAccounts[1].address;
+    this.blacklistedAddress = deployedAccounts[2].address;
+
+    this.logger.info('Setting up blacklist token contract');
+    // Create the token contract state.
+    this.logger.verbose(`Public deploy accounts...`);
+    await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
+
+    this.logger.verbose(`Deploying TokenContract...`);
+    ({ contract: this.asset } = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Token deployed to ${this.asset.address}`);
+
+    this.logger.verbose(`Deploying bad account...`);
+    ({ contract: this.badAccount } = await InvalidAccountContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
+
+    // Deploy a proxy contract for "on behalf of other" tests. The note owner must be the tx sender
+    // (so their notes are in scope), but msg_sender in the target must differ from the note owner
+    // to trigger authwit validation. The proxy forwards calls so that msg_sender != tx sender.
+    this.logger.verbose(`Deploying generic proxy...`);
+    ({ contract: this.authwitProxy } = await GenericProxyContract.deploy(this.wallet).send({
+      from: this.adminAddress,
+    }));
+    this.logger.verbose(`Deployed to ${this.authwitProxy.address}.`);
+
+    await this.crossTimestampOfChange();
+
+    this.tokenSim = new TokenSimulator(
+      this.asset as unknown as TokenContract,
+      this.wallet,
+      this.adminAddress,
+      this.logger,
+      [this.adminAddress, this.otherAddress, this.blacklistedAddress],
     );
 
-    await this.snapshotManager.snapshot(
-      'e2e_blacklist_token_contract',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
-
-        this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress)
-          .send({ from: this.adminAddress })
-          .deployed();
-        this.logger.verbose(`Token deployed to ${this.asset.address}`);
-
-        this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
-        this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
-
-        await this.crossTimestampOfChange();
-
-        return { tokenContractAddress: this.asset.address, badAccountAddress: this.badAccount.address };
-      },
-      async ({ tokenContractAddress, badAccountAddress }) => {
-        // Restore the token contract state.
-        this.asset = TokenBlacklistContract.at(tokenContractAddress, this.wallet);
-        this.logger.verbose(`Token contract address: ${this.asset.address}`);
-
-        this.tokenSim = new TokenSimulator(
-          this.asset as unknown as TokenContract,
-          this.wallet,
-          this.adminAddress,
-          this.logger,
-          [this.adminAddress, this.otherAddress, this.blacklistedAddress],
-        );
-
-        this.badAccount = InvalidAccountContract.at(badAccountAddress, this.wallet);
-        this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
-
-        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-          new Role().withAdmin().toNoirStruct(),
-        );
-      },
-    );
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(new Role().withAdmin().toNoirStruct());
   }
 
   async setup() {
-    await this.snapshotManager.setup();
+    this.logger.info('Setting up fresh context');
+    this.context = await setup(0, {
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
+    await this.applyBaseSetup();
   }
 
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
-
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
   async addPendingShieldNoteToPXE(
@@ -174,7 +161,7 @@ export class BlacklistTokenContractTest {
   ) {
     const txEffects = await this.aztecNode.getTxEffect(txHash);
     await contract.methods
-      .deliver_transparent_note(
+      .process_transparent_note(
         contract.address,
         amount,
         secretHash,
@@ -186,71 +173,56 @@ export class BlacklistTokenContractTest {
       .simulate({ from: recipient });
   }
 
-  async applyMintSnapshot() {
-    await this.snapshotManager.snapshot(
-      'mint',
-      async () => {
-        const { asset } = this;
-        const amount = 10000n;
-
-        const adminMinterRole = new Role().withAdmin().withMinter();
-        await this.asset.methods
-          .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
-          .send({ from: this.adminAddress })
-          .wait();
-
-        const blacklistRole = new Role().withBlacklisted();
-        await this.asset.methods
-          .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
-          .send({ from: this.adminAddress })
-          .wait();
-
-        await this.crossTimestampOfChange();
-
-        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-          adminMinterRole.toNoirStruct(),
-        );
-
-        this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress }).wait();
-
-        this.logger.verbose(`Minting ${amount} privately...`);
-        const secret = Fr.random();
-        const secretHash = await computeSecretHash(secret);
-        const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress }).wait();
-
-        await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
-        const txClaim = asset.methods
-          .redeem_shield(this.adminAddress, amount, secret)
-          .send({ from: this.adminAddress });
-        await txClaim.wait();
-        this.logger.verbose(`Minting complete.`);
-
-        return { amount };
-      },
-      async ({ amount }) => {
-        const { asset, tokenSim } = this;
-        tokenSim.mintPublic(this.adminAddress, amount);
-
-        const publicBalance = await asset.methods
-          .balance_of_public(this.adminAddress)
-          .simulate({ from: this.adminAddress });
-        this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
-
-        tokenSim.mintPrivate(this.adminAddress, amount);
-        const privateBalance = await asset.methods
-          .balance_of_private(this.adminAddress)
-          .simulate({ from: this.adminAddress });
-        this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
-
-        const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
-        this.logger.verbose(`Total supply: ${totalSupply}`);
-        expect(totalSupply).toEqual(tokenSim.totalSupply);
-
-        return Promise.resolve();
-      },
-    );
+  async applyMint() {
+    this.logger.info('Applying mint setup');
+    const { asset, tokenSim } = this;
+    const amount = 10000n;
+
+    const adminMinterRole = new Role().withAdmin().withMinter();
+    await this.asset.methods
+      .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
+      .send({ from: this.adminAddress });
+
+    const blacklistRole = new Role().withBlacklisted();
+    await this.asset.methods
+      .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
+      .send({ from: this.adminAddress });
+
+    await this.crossTimestampOfChange();
+
+    expect(
+      (await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).result,
+    ).toEqual(adminMinterRole.toNoirStruct());
+
+    this.logger.verbose(`Minting ${amount} publicly...`);
+    await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress });
+
+    this.logger.verbose(`Minting ${amount} privately...`);
+    const secret = Fr.random();
+    const secretHash = await computeSecretHash(secret);
+    const { receipt } = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress });
+
+    await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
+    await asset.methods.redeem_shield(this.adminAddress, amount, secret).send({ from: this.adminAddress });
+    this.logger.verbose(`Minting complete.`);
+
+    tokenSim.mintPublic(this.adminAddress, amount);
+
+    const { result: publicBalance } = await asset.methods
+      .balance_of_public(this.adminAddress)
+      .simulate({ from: this.adminAddress });
+    this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+    expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
+
+    tokenSim.mintPrivate(this.adminAddress, amount);
+    const { result: privateBalance } = await asset.methods
+      .balance_of_private(this.adminAddress)
+      .simulate({ from: this.adminAddress });
+    this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+    expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
+
+    const { result: totalSupply } = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+    this.logger.verbose(`Total supply: ${totalSupply}`);
+    expect(totalSupply).toEqual(tokenSim.totalSupply);
   }
 }