@aztec/end-to-end 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -26,38 +26,31 @@ import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../../fixtures/fixtures.js';
-import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
-  deployAccounts,
-} from '../../fixtures/snapshot_manager.js';
+import { type EndToEndContext, type SetupOptions, deployAccounts, setup, teardown } from '../../fixtures/setup.js';
 import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
-import { type SetupOptions, setupSponsoredFPC } from '../../fixtures/utils.js';
+import { setupSponsoredFPC } from '../../fixtures/utils.js';
 import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
 import {
   FeeJuicePortalTestingHarnessFactory,
   type GasBridgingTestHarness,
 } from '../../shared/gas_portal_test_harness.js';
+import { TestWallet } from '../../test-wallet/test_wallet.js';
 import { ProxyLogger } from './benchmark.js';
 import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './config.js';
 
-const { E2E_DATA_PATH: dataPath, BENCHMARK_CONFIG } = process.env;
+const { BENCHMARK_CONFIG } = process.env;
 
 export type AccountType = 'ecdsar1' | 'schnorr';
 export type FeePaymentMethodGetter = (wallet: Wallet, sender: AztecAddress) => Promise<FeePaymentMethod | undefined>;
 export type BenchmarkingFeePaymentMethod = 'bridged_fee_juice' | 'private_fpc' | 'sponsored_fpc' | 'fee_juice';
 
 export class ClientFlowsBenchmark {
-  private snapshotManager: ISnapshotManager;
-
   public logger: Logger;
   public aztecNode!: AztecNode;
   public cheatCodes!: CheatCodes;
-  public context!: SubsystemsContext;
+  public context!: EndToEndContext;
   public chainMonitor!: ChainMonitor;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
   public adminWallet!: TestWallet;
@@ -125,33 +118,37 @@ export class ClientFlowsBenchmark {
   public config: ClientFlowsConfig;
 
   private proxyLogger: ProxyLogger;
+  private setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs>;
 
   constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {}) {
     this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
-    this.snapshotManager = createSnapshotManager(
-      `bench_client_flows${testName ? `/${testName}` : ''}`,
-      dataPath,
-      { startProverNode: true, ...setupOptions },
-      { ...setupOptions },
-    );
+    this.setupOptions = { startProverNode: true, ...setupOptions };
     this.config = BENCHMARK_CONFIG === 'key_flows' ? KEY_FLOWS_CONFIG : FULL_FLOWS_CONFIG;
     ProxyLogger.create();
     this.proxyLogger = ProxyLogger.getInstance();
   }
 
   async setup() {
-    const context = await this.snapshotManager.setup();
-    await context.aztecNode.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+    this.logger.info('Setting up subsystems from fresh');
+    this.context = await setup(0, {
+      ...this.setupOptions,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+      l1ContractsArgs: this.setupOptions,
+    });
+    await this.applyBaseSetup();
+
+    await this.context.aztecNodeService.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
 
-    const rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
-    this.chainMonitor = new ChainMonitor(rollupContract, context.dateProvider, this.logger, 200).start();
+    const rollupContract = RollupContract.getFromConfig(this.context.config);
+    this.chainMonitor = new ChainMonitor(rollupContract, this.context.dateProvider, this.logger, 200).start();
 
     return this;
   }
 
   async teardown() {
     await this.chainMonitor.stop();
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
   async mintAndBridgeFeeJuice(address: AztecAddress) {
@@ -159,21 +156,16 @@ export class ClientFlowsBenchmark {
     const { claimSecret: secret, messageLeafIndex: index } = claim;
     await this.feeJuiceContract.methods
       .claim(address, claim.claimAmount, secret, index)
-      .send({ from: this.adminAddress })
-      .wait();
+      .send({ from: this.adminAddress });
   }
 
   /** Admin mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods
-      .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+    const balanceBefore = await this.bananaCoin.methods.balance_of_private(address).simulate({ from: address });
 
     await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods
-      .balance_of_private(address)
-      .simulate({ from: this.adminAddress });
+    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate({ from: address });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -193,161 +185,118 @@ export class ClientFlowsBenchmark {
     }
   }
 
-  public async applyBaseSnapshots() {
-    await this.applyInitialAccountsSnapshot();
-    await this.applySetupFeeJuiceSnapshot();
+  public async applyBaseSetup() {
+    await this.applyInitialAccounts();
+    await this.applySetupFeeJuice();
   }
 
-  async applyInitialAccountsSnapshot() {
-    await this.snapshotManager.snapshot(
-      'initial_accounts',
-      deployAccounts(2, this.logger),
-      async (
-        { deployedAccounts: [{ address: adminAddress }, { address: sequencerAddress }] },
-        { wallet, aztecNode, cheatCodes },
-      ) => {
-        this.adminWallet = wallet;
-        this.aztecNode = aztecNode;
-        this.cheatCodes = cheatCodes;
-
-        this.adminAddress = adminAddress;
-        this.sequencerAddress = sequencerAddress;
-
-        const canonicalFeeJuice = await getCanonicalFeeJuice();
-        this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
-        this.coinbase = EthAddress.random();
-
-        const userPXEConfig = getPXEConfig();
-        const userPXEConfigWithContracts = {
-          ...userPXEConfig,
-          proverEnabled: this.realProofs,
-        } as PXEConfig;
-
-        this.userWallet = await TestWallet.create(this.aztecNode, userPXEConfigWithContracts, {
-          loggers: {
-            prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
-          },
-        });
+  async applyInitialAccounts() {
+    this.logger.info('Applying initial accounts setup');
+    const { deployedAccounts } = await deployAccounts(
+      2,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+
+    const [{ address: adminAddress }, { address: sequencerAddress }] = deployedAccounts;
+
+    this.adminWallet = this.context.wallet;
+    this.aztecNode = this.context.aztecNodeService;
+    this.cheatCodes = this.context.cheatCodes;
+
+    this.adminAddress = adminAddress;
+    this.sequencerAddress = sequencerAddress;
+
+    const canonicalFeeJuice = await getCanonicalFeeJuice();
+    this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
+    this.coinbase = EthAddress.random();
+
+    const userPXEConfig = getPXEConfig();
+    const userPXEConfigWithContracts = {
+      ...userPXEConfig,
+      proverEnabled: this.realProofs,
+    } as PXEConfig;
+
+    this.userWallet = await TestWallet.create(this.aztecNode, userPXEConfigWithContracts, {
+      loggers: {
+        prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
       },
-    );
+    });
   }
 
-  async applySetupFeeJuiceSnapshot() {
-    await this.snapshotManager.snapshot(
-      'setup_fee_juice',
-      async () => {},
-      async (_data, context) => {
-        this.context = context;
-
-        this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
-
-        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-          aztecNode: context.aztecNode,
-          aztecNodeAdmin: context.aztecNode,
-          l1Client: context.deployL1ContractsValues.l1Client,
-          wallet: this.adminWallet,
-          logger: this.logger,
-        });
-      },
-    );
+  async applySetupFeeJuice() {
+    this.logger.info('Applying fee juice setup');
+    this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
+
+    this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
+      aztecNode: this.context.aztecNodeService,
+      aztecNodeAdmin: this.context.aztecNodeService,
+      l1Client: this.context.deployL1ContractsValues.l1Client,
+      wallet: this.adminWallet,
+      logger: this.logger,
+    });
   }
 
-  async applyDeployBananaTokenSnapshot() {
-    await this.snapshotManager.snapshot(
-      'deploy_banana_token',
-      async () => {
-        const { contract: bananaCoin, instance: bananaCoinInstance } = await BananaCoin.deploy(
-          this.adminWallet,
-          this.adminAddress,
-          'BC',
-          'BC',
-          18n,
-        )
-          .send({ from: this.adminAddress })
-          .wait();
-        this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
-        return { bananaCoinAddress: bananaCoin.address, bananaCoinInstance };
-      },
-      ({ bananaCoinAddress, bananaCoinInstance }) => {
-        this.bananaCoin = BananaCoin.at(bananaCoinAddress, this.adminWallet);
-        this.bananaCoinInstance = bananaCoinInstance;
-        return Promise.resolve();
-      },
-    );
+  async applyDeployBananaToken() {
+    this.logger.info('Applying banana token deployment');
+    const { contract: bananaCoin, instance: bananaCoinInstance } = await BananaCoin.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'BC',
+      'BC',
+      18n,
+    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+    this.bananaCoin = bananaCoin;
+    this.bananaCoinInstance = bananaCoinInstance;
   }
 
-  async applyDeployCandyBarTokenSnapshot() {
-    await this.snapshotManager.snapshot(
-      'deploy_candy_bar_token',
-      async () => {
-        const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TokenContract.deploy(
-          this.adminWallet,
-          this.adminAddress,
-          'CBC',
-          'CBC',
-          18n,
-        )
-          .send({ from: this.adminAddress })
-          .wait();
-        this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
-        return { candyBarCoinAddress: candyBarCoin.address, candyBarCoinInstance };
-      },
-      ({ candyBarCoinAddress, candyBarCoinInstance }) => {
-        this.candyBarCoin = TokenContract.at(candyBarCoinAddress, this.adminWallet);
-        this.candyBarCoinInstance = candyBarCoinInstance;
-        return Promise.resolve();
-      },
-    );
+  async applyDeployCandyBarToken() {
+    this.logger.info('Applying candy bar token deployment');
+    const { contract: candyBarCoin, instance: candyBarCoinInstance } = await TokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'CBC',
+      'CBC',
+      18n,
+    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
+    this.candyBarCoin = candyBarCoin;
+    this.candyBarCoinInstance = candyBarCoinInstance;
   }
 
-  public async applyFPCSetupSnapshot() {
-    await this.snapshotManager.snapshot(
-      'fpc_setup',
-      async context => {
-        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+  public async applyFPCSetup() {
+    this.logger.info('Applying FPC setup');
+    const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+    expect((await this.context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
-        const bananaCoin = this.bananaCoin;
-        const { contract: bananaFPC, instance: bananaFPCInstance } = await FPCContract.deploy(
-          this.adminWallet,
-          bananaCoin.address,
-          this.adminAddress,
-        )
-          .send({ from: this.adminAddress })
-          .wait();
+    const bananaCoin = this.bananaCoin;
+    const { contract: bananaFPC, instance: bananaFPCInstance } = await FPCContract.deploy(
+      this.adminWallet,
+      bananaCoin.address,
+      this.adminAddress,
+    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
 
-        this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+    this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
-        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.adminAddress);
+    await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.adminAddress);
 
-        return { bananaFPCAddress: bananaFPC.address, bananaFPCInstance };
-      },
-      data => {
-        this.bananaFPC = FPCContract.at(data.bananaFPCAddress, this.adminWallet);
-        this.bananaFPCInstance = data.bananaFPCInstance;
-        return Promise.resolve();
-      },
-    );
+    this.bananaFPC = bananaFPC;
+    this.bananaFPCInstance = bananaFPCInstance;
   }
 
-  async applyDeploySponsoredFPCSnapshot() {
-    await this.snapshotManager.snapshot(
-      'deploy_sponsored_fpc',
-      async () => {
-        const sponsoredFPCInstance = await setupSponsoredFPC(this.adminWallet);
-        this.logger.info(`SponsoredFPC at ${sponsoredFPCInstance.address}`);
-        return { sponsoredFPCAddress: sponsoredFPCInstance.address, sponsoredFPCInstance };
-      },
-      ({ sponsoredFPCAddress, sponsoredFPCInstance }) => {
-        this.sponsoredFPC = SponsoredFPCContract.at(sponsoredFPCAddress, this.adminWallet);
-        this.sponsoredFPCInstance = sponsoredFPCInstance;
-        return Promise.resolve();
-      },
-    );
+  async applyDeploySponsoredFPC() {
+    this.logger.info('Applying sponsored FPC deployment');
+    const sponsoredFPCInstance = await setupSponsoredFPC(this.adminWallet);
+    this.logger.info(`SponsoredFPC at ${sponsoredFPCInstance.address}`);
+    this.sponsoredFPC = SponsoredFPCContract.at(sponsoredFPCInstance.address, this.adminWallet);
+    this.sponsoredFPCInstance = sponsoredFPCInstance;
   }
 
   public async createCrossChainTestHarness(owner: AztecAddress) {
-    const l1Client = createExtendedL1Client(this.context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+    const l1Client = createExtendedL1Client(this.context.config.l1RpcUrls, MNEMONIC);
 
     const underlyingERC20Address = await deployL1Contract(l1Client, TestERC20Abi, TestERC20Bytecode, [
       'Underlying',
@@ -376,12 +325,10 @@ export class ClientFlowsBenchmark {
     const benchysAddress = benchysAccountManager.address;
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
     const behchysDeployMethod = await benchysAccountManager.getDeployMethod();
-    await behchysDeployMethod
-      .send({
-        from: AztecAddress.ZERO,
-        fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
-      })
-      .wait();
+    await behchysDeployMethod.send({
+      from: AztecAddress.ZERO,
+      fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
+    });
     // Register benchy on the user's Wallet, where we're going to be interacting from
     const accountManager = await this.userWallet.createAccount({
       secret: benchysAccount.getSecretKey(),
@@ -391,44 +338,27 @@ export class ClientFlowsBenchmark {
     return accountManager.address;
   }
 
-  public async applyDeployAmmSnapshot() {
-    await this.snapshotManager.snapshot(
-      'deploy_amm',
-      async () => {
-        const { contract: liquidityToken, instance: liquidityTokenInstance } = await TokenContract.deploy(
-          this.adminWallet,
-          this.adminAddress,
-          'LPT',
-          'LPT',
-          18n,
-        )
-          .send({ from: this.adminAddress })
-          .wait();
-        const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
-          this.adminWallet,
-          this.bananaCoin.address,
-          this.candyBarCoin.address,
-          liquidityToken.address,
-        )
-          .send({ from: this.adminAddress })
-          .wait();
-        this.logger.info(`AMM deployed at ${amm.address}`);
-        await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress }).wait();
-        return {
-          ammAddress: amm.address,
-          ammInstance,
-          liquidityTokenAddress: liquidityToken.address,
-          liquidityTokenInstance,
-        };
-      },
-      ({ ammAddress, ammInstance, liquidityTokenAddress, liquidityTokenInstance }) => {
-        this.liquidityToken = TokenContract.at(liquidityTokenAddress, this.adminWallet);
-        this.liquidityTokenInstance = liquidityTokenInstance;
-        this.amm = AMMContract.at(ammAddress, this.adminWallet);
-        this.ammInstance = ammInstance;
-        return Promise.resolve();
-      },
-    );
+  public async applyDeployAmm() {
+    this.logger.info('Applying AMM deployment');
+    const { contract: liquidityToken, instance: liquidityTokenInstance } = await TokenContract.deploy(
+      this.adminWallet,
+      this.adminAddress,
+      'LPT',
+      'LPT',
+      18n,
+    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    const { contract: amm, instance: ammInstance } = await AMMContract.deploy(
+      this.adminWallet,
+      this.bananaCoin.address,
+      this.candyBarCoin.address,
+      liquidityToken.address,
+    ).send({ from: this.adminAddress, wait: { returnReceipt: true } });
+    this.logger.info(`AMM deployed at ${amm.address}`);
+    await liquidityToken.methods.set_minter(amm.address, true).send({ from: this.adminAddress });
+    this.liquidityToken = liquidityToken;
+    this.liquidityTokenInstance = liquidityTokenInstance;
+    this.amm = amm;
+    this.ammInstance = ammInstance;
   }
 
   public async getBridgedFeeJuicePaymentMethodForWallet(_wallet: Wallet, sender: AztecAddress) {
@@ -439,7 +369,7 @@ export class ClientFlowsBenchmark {
   public async getPrivateFPCPaymentMethodForWallet(wallet: Wallet, sender: AztecAddress) {
     // The private fee paying method assembled on the app side requires knowledge of the maximum
     // fee the user is willing to pay
-    const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1.5);
+    const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1.5);
     const gasSettings = GasSettings.default({ maxFeesPerGas });
     return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
   }

package/src/bench/client_flows/config.ts

@@ -6,7 +6,7 @@ export type ClientFlowConfig = {
   recursions?: number[];
 };
 
-type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm';
+type ClientFlows = 'accountDeployments' | 'deployments' | 'transfers' | 'bridging' | 'amm' | 'storageProof';
 
 export type ClientFlowsConfig = {
   [key in ClientFlows]: ClientFlowConfig;
@@ -34,6 +34,10 @@ export const KEY_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1],
   },
+  storageProof: {
+    accounts: ['ecdsar1'],
+    feePaymentMethods: ['sponsored_fpc'],
+  },
 };
 
 export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
@@ -58,4 +62,8 @@ export const FULL_FLOWS_CONFIG: ClientFlowsConfig = {
     feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
     recursions: [0, 1, 2],
   },
+  storageProof: {
+    accounts: ['ecdsar1', 'schnorr'],
+    feePaymentMethods: ['sponsored_fpc', 'private_fpc'],
+  },
 };

package/src/bench/client_flows/data_extractor.ts

@@ -22,7 +22,7 @@ async function main() {
   logger.info(`Flows in ${ivcFolder}: \n${flows.map(flowName => `\t- ${flowName}`).join('\n')}`);
   const simulator = new WASMSimulator();
   const log = proxyLogger.createLogger('bb:prover');
-  const prover = new BBBundlePrivateKernelProver(simulator, log);
+  const prover = new BBBundlePrivateKernelProver(simulator, { logger: log });
 
   const userLog = createLogger('chonk_flows:data_processor');
 

package/src/bench/utils.ts

@@ -1,9 +1,11 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
+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';
@@ -16,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);
@@ -47,7 +49,7 @@ export async function benchmarkSetup(
 }
 
 type MetricFilter = {
-  source: MetricsType;
+  source: MetricDefinition;
   transform: (value: number) => number;
   name: string;
   unit?: string;
@@ -62,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',
@@ -138,18 +144,18 @@ export async function sendTxs(
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): Promise<SentTx[]> {
+): 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(call => call.send({ from, wait: NO_WAIT })));
 }
 
-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[] {