@aztec/end-to-end 0.82.2-alpha-testnet.5 → 0.82.3-nightly.20250330

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -0,0 +1,331 @@
+import { EcdsaRAccountContractArtifact, getEcdsaRAccount } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWallet } from '@aztec/accounts/schnorr';
+import {
+  type AccountWallet,
+  AztecAddress,
+  type AztecNode,
+  FeeJuicePaymentMethodWithClaim,
+  type Logger,
+  type PXE,
+  createLogger,
+} from '@aztec/aztec.js';
+import { CheatCodes } from '@aztec/aztec.js/testing';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import { type DeployL1ContractsArgs, RollupContract, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { ChainMonitor } from '@aztec/ethereum/test';
+import { randomBytes } from '@aztec/foundation/crypto';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
+import { TestERC20Bytecode } from '@aztec/l1-artifacts/TestERC20Bytecode';
+import { AMMContract } from '@aztec/noir-contracts.js/AMM';
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
+import { TokenContract as BananaCoin, TokenContract } from '@aztec/noir-contracts.js/Token';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
+import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+
+import { MNEMONIC } from '../../fixtures/fixtures.js';
+import {
+  type ISnapshotManager,
+  type SubsystemsContext,
+  createSnapshotManager,
+  deployAccounts,
+} from '../../fixtures/snapshot_manager.js';
+import { mintTokensToPrivate } from '../../fixtures/token_utils.js';
+import { type SetupOptions, setupCanonicalFeeJuice } from '../../fixtures/utils.js';
+import { CrossChainTestHarness } from '../../shared/cross_chain_test_harness.js';
+import {
+  FeeJuicePortalTestingHarnessFactory,
+  type GasBridgingTestHarness,
+} from '../../shared/gas_portal_test_harness.js';
+
+const { E2E_DATA_PATH: dataPath } = process.env;
+
+export type AccountType = 'ecdsar1' | 'schnorr';
+
+export class ClientFlowsBenchmark {
+  private snapshotManager: ISnapshotManager;
+
+  public logger: Logger;
+  public pxe!: PXE;
+  public aztecNode!: AztecNode;
+  public cheatCodes!: CheatCodes;
+  public context!: SubsystemsContext;
+  public chainMonitor!: ChainMonitor;
+  public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
+
+  // The admin that aids in the setup of the test
+  public adminWallet!: AccountWallet;
+  public adminAddress!: AztecAddress;
+
+  // Aztec Node config
+  public sequencerAddress!: AztecAddress;
+  public coinbase!: EthAddress;
+
+  // Contracts
+  public feeJuiceContract!: FeeJuiceContract;
+  // Asset in which fees are paid via FPC
+  public bananaCoin!: BananaCoin;
+  public bananaFPC!: FPCContract;
+  // Random asset we want to trade
+  public candyBarCoin!: TokenContract;
+  // AMM contract
+  public amm!: AMMContract;
+  // Liquidity token for AMM
+  public liquidityToken!: TokenContract;
+
+  // PXE used by the benchmarking user. It can be set up with client-side proving enabled
+  public userPXE!: PXE;
+
+  constructor(testName?: string, setupOptions: Partial<SetupOptions & DeployL1ContractsArgs> = {}) {
+    this.logger = createLogger(`bench:client_flows${testName ? `:${testName}` : ''}`);
+    this.snapshotManager = createSnapshotManager(
+      `bench_client_flows${testName ? `/${testName}` : ''}`,
+      dataPath,
+      { startProverNode: true, ...setupOptions },
+      { ...setupOptions },
+    );
+  }
+
+  async setup() {
+    const context = await this.snapshotManager.setup();
+    await context.aztecNode.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
+
+    const rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
+    this.chainMonitor = new ChainMonitor(rollupContract, this.logger, 200).start();
+
+    return this;
+  }
+
+  async teardown() {
+    this.chainMonitor.stop();
+    await this.snapshotManager.teardown();
+  }
+
+  async mintAndBridgeFeeJuice(address: AztecAddress, amount: bigint) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, address);
+    const { claimSecret: secret, messageLeafIndex: index } = claim;
+    await this.feeJuiceContract.methods.claim(address, amount, secret, index).send().wait();
+  }
+
+  /** 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();
+
+    await mintTokensToPrivate(this.bananaCoin, this.adminWallet, address, amount);
+
+    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate();
+    expect(balanceAfter).toEqual(balanceBefore + amount);
+  }
+
+  async createBenchmarkingAccountManager(type: 'ecdsar1' | 'schnorr') {
+    const benchysSecretKey = Fr.random();
+    const salt = Fr.random();
+
+    let benchysPrivateSigningKey;
+    let benchysAccountManager;
+    if (type === 'schnorr') {
+      benchysPrivateSigningKey = deriveSigningKey(benchysSecretKey);
+      benchysAccountManager = await getSchnorrAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+    } else if (type === 'ecdsar1') {
+      benchysPrivateSigningKey = randomBytes(32);
+      benchysAccountManager = await getEcdsaRAccount(this.userPXE, benchysSecretKey, benchysPrivateSigningKey, salt);
+    } else {
+      throw new Error(`Unknown account type: ${type}`);
+    }
+    await benchysAccountManager.register();
+    return benchysAccountManager;
+  }
+
+  public async applyBaseSnapshots() {
+    await this.applyInitialAccountsSnapshot();
+    await this.applySetupFeeJuiceSnapshot();
+  }
+
+  async applyInitialAccountsSnapshot() {
+    await this.snapshotManager.snapshot(
+      'initial_accounts',
+      deployAccounts(2, this.logger),
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
+        this.pxe = pxe;
+
+        this.aztecNode = aztecNode;
+        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+
+        const deployedWallets = await Promise.all(
+          deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)),
+        );
+        [this.adminWallet] = deployedWallets;
+        this.adminAddress = this.adminWallet.getAddress();
+        this.sequencerAddress = deployedWallets[1].getAddress();
+
+        const canonicalFeeJuice = await getCanonicalFeeJuice();
+        this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
+        this.coinbase = EthAddress.random();
+
+        const userPXEConfig = getPXEServiceConfig();
+        const l1Contracts = await aztecNode.getL1ContractAddresses();
+        const userPXEConfigWithContracts = {
+          ...userPXEConfig,
+          proverEnabled: ['true', '1'].includes(process.env.REAL_PROOFS ?? ''),
+          l1Contracts,
+        } as PXEServiceConfig;
+
+        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, 'pxe-user');
+      },
+    );
+  }
+
+  async applySetupFeeJuiceSnapshot() {
+    await this.snapshotManager.snapshot(
+      'setup_fee_juice',
+      async context => {
+        await setupCanonicalFeeJuice(context.pxe);
+      },
+      async (_data, context) => {
+        this.context = context;
+
+        this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.adminWallet);
+
+        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
+          aztecNode: context.aztecNode,
+          aztecNodeAdmin: context.aztecNode,
+          pxeService: context.pxe,
+          publicClient: context.deployL1ContractsValues.publicClient,
+          walletClient: context.deployL1ContractsValues.walletClient,
+          wallet: this.adminWallet,
+          logger: this.logger,
+        });
+      },
+    );
+  }
+
+  async applyDeployBananaTokenSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_banana_token',
+      async () => {
+        const bananaCoin = await BananaCoin.deploy(this.adminWallet, this.adminAddress, 'BC', 'BC', 18n)
+          .send()
+          .deployed();
+        this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
+        return { bananaCoinAddress: bananaCoin.address };
+      },
+      async ({ bananaCoinAddress }) => {
+        this.bananaCoin = await BananaCoin.at(bananaCoinAddress, this.adminWallet);
+      },
+    );
+  }
+
+  async applyDeployCandyBarTokenSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_candy_bar_token',
+      async () => {
+        const candyBarCoin = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'CBC', 'CBC', 18n)
+          .send()
+          .deployed();
+        this.logger.info(`CandyBarCoin deployed at ${candyBarCoin.address}`);
+        return { candyBarCoinAddress: candyBarCoin.address };
+      },
+      async ({ candyBarCoinAddress }) => {
+        this.candyBarCoin = await TokenContract.at(candyBarCoinAddress, this.adminWallet);
+      },
+    );
+  }
+
+  public async applyFPCSetupSnapshot() {
+    await this.snapshotManager.snapshot(
+      'fpc_setup',
+      async context => {
+        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
+
+        const bananaCoin = this.bananaCoin;
+        const bananaFPC = await FPCContract.deploy(this.adminWallet, bananaCoin.address, this.adminAddress)
+          .send()
+          .deployed();
+
+        this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
+
+        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(FEE_FUNDING_FOR_TESTER_ACCOUNT, bananaFPC.address);
+
+        return { bananaFPCAddress: bananaFPC.address };
+      },
+      async data => {
+        this.bananaFPC = await FPCContract.at(data.bananaFPCAddress, this.adminWallet);
+      },
+    );
+  }
+
+  public async createCrossChainTestHarness(owner: AccountWallet) {
+    const { publicClient, walletClient } = createL1Clients(this.context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+
+    const underlyingERC20Address = await deployL1Contract(walletClient, publicClient, TestERC20Abi, TestERC20Bytecode, [
+      'Underlying',
+      'UND',
+      walletClient.account.address,
+    ]).then(({ address }) => address);
+
+    this.logger.verbose(`Setting up cross chain harness...`);
+    const crossChainTestHarness = await CrossChainTestHarness.new(
+      this.aztecNode,
+      this.pxe,
+      publicClient,
+      walletClient,
+      owner,
+      this.logger,
+      underlyingERC20Address,
+    );
+
+    this.logger.verbose(`L2 token deployed to: ${crossChainTestHarness.l2Token.address}`);
+
+    return crossChainTestHarness;
+  }
+
+  public async createAndFundBenchmarkingWallet(accountType: AccountType) {
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(accountType);
+    const benchysWallet = await benchysAccountManager.getWallet();
+    const benchysAddress = benchysAccountManager.getAddress();
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(
+      FEE_FUNDING_FOR_TESTER_ACCOUNT,
+      benchysAddress,
+    );
+    const paymentMethod = new FeeJuicePaymentMethodWithClaim(benchysWallet, claim);
+    await benchysAccountManager.deploy({ fee: { paymentMethod } }).wait();
+    // Register benchy on admin's PXE so we can check its balances
+    await this.pxe.registerContract({
+      instance: benchysAccountManager.getInstance(),
+      artifact: accountType === 'ecdsar1' ? EcdsaRAccountContractArtifact : SchnorrAccountContractArtifact,
+    });
+    await this.pxe.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
+    return benchysWallet;
+  }
+
+  public async applyDeployAmmSnapshot() {
+    await this.snapshotManager.snapshot(
+      'deploy_amm',
+      async () => {
+        const liquidityToken = await TokenContract.deploy(this.adminWallet, this.adminAddress, 'LPT', 'LPT', 18n)
+          .send()
+          .deployed();
+        const amm = await AMMContract.deploy(
+          this.adminWallet,
+          this.bananaCoin.address,
+          this.candyBarCoin.address,
+          liquidityToken.address,
+        )
+          .send()
+          .deployed();
+        this.logger.info(`AMM deployed at ${amm.address}`);
+        await liquidityToken.methods.set_minter(amm.address, true).send().wait();
+        return { ammAddress: amm.address, liquidityTokenAddress: liquidityToken.address };
+      },
+      async ({ ammAddress, liquidityTokenAddress }) => {
+        this.liquidityToken = await TokenContract.at(liquidityTokenAddress, this.adminWallet);
+        this.amm = await AMMContract.at(ammAddress, this.adminWallet);
+      },
+    );
+  }
+}

package/src/bench/client_flows/data_extractor.ts

@@ -0,0 +1,217 @@
+import type { Logger } from '@aztec/aztec.js';
+import { BBNativePrivateKernelProver } from '@aztec/bb-prover';
+import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/wasm/bundle';
+import { createLogger, logger } from '@aztec/foundation/log';
+import { WASMSimulator } from '@aztec/simulator/client';
+import type { PrivateExecutionStep } from '@aztec/stdlib/kernel';
+
+import { decode } from '@msgpack/msgpack';
+import assert from 'node:assert';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const logLevel = ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const;
+type LogLevel = (typeof logLevel)[number];
+
+type Log = {
+  type: LogLevel;
+  timestamp: number;
+  prefix: string;
+  message: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: any;
+};
+
+const GATE_TYPES = [
+  'ecc_op',
+  'busread',
+  'lookup',
+  'pub_inputs',
+  'arithmetic',
+  'delta_range',
+  'elliptic',
+  'aux',
+  'poseidon2_external',
+  'poseidon2_internal',
+  'overflow',
+] as const;
+
+type GateType = (typeof GATE_TYPES)[number];
+
+type StructuredTrace = {
+  [k in GateType]: number;
+};
+
+export class ProxyLogger {
+  private static instance: ProxyLogger;
+  private logs: Log[] = [];
+
+  private constructor() {}
+
+  static create() {
+    ProxyLogger.instance = new ProxyLogger();
+  }
+
+  static getInstance() {
+    return ProxyLogger.instance;
+  }
+
+  createLogger(prefix: string): Logger {
+    return new Proxy(createLogger(prefix), {
+      get: (target: Logger, prop: keyof Logger) => {
+        if (logLevel.includes(prop as (typeof logLevel)[number])) {
+          return function (this: Logger, ...data: Parameters<Logger[LogLevel]>) {
+            const loggingFn = prop as LogLevel;
+            const args = [loggingFn, prefix, ...data] as Parameters<ProxyLogger['handleLog']>;
+            ProxyLogger.getInstance().handleLog(...args);
+            target[loggingFn].call(this, ...[data[0], data[1]]);
+          };
+        } else {
+          return target[prop];
+        }
+      },
+    });
+  }
+
+  private handleLog(type: (typeof logLevel)[number], prefix: string, message: string, data: any) {
+    this.logs.unshift({ type, prefix, message, data, timestamp: Date.now() });
+  }
+
+  public flushLogs() {
+    this.logs = [];
+  }
+
+  public getLogs() {
+    return this.logs;
+  }
+}
+
+type NativeProverConfig = { bbBinaryPath?: string; bbWorkingDirectory?: string };
+
+type ProverType = 'wasm' | 'native';
+
+type Step = { fnName: string; gateCount: number; accGateCount?: number };
+
+async function createProver(config: NativeProverConfig = {}, log: Logger) {
+  const simulationProvider = new WASMSimulator();
+  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
+    return { prover: new BBWASMBundlePrivateKernelProver(simulationProvider, 16, log), type: 'wasm' as ProverType };
+  } else {
+    const bbConfig = config as Required<NativeProverConfig>;
+    return {
+      prover: await BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, simulationProvider, log),
+      type: 'native' as ProverType,
+    };
+  }
+}
+
+function getMinimumTrace(logs: Log[], proverType: ProverType): StructuredTrace {
+  const minimumMessage = 'Minimum required block sizes for structured trace:';
+  const minimumMessageIndex = logs.findIndex(log => log.message.includes(minimumMessage));
+  const candidateLogs = logs.slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex);
+  const traceLogs =
+    proverType === 'wasm'
+      ? candidateLogs.map(log => log.message)
+      : logs
+          .slice(minimumMessageIndex - GATE_TYPES.length, minimumMessageIndex)
+          .filter(log => GATE_TYPES.some(type => log.message.includes(`bb - ${type}`)))
+          .map(log => log.message.split('\n'))
+          .flat();
+  const traceSizes = traceLogs.map(log => {
+    const [gateType, gateSizeStr] = log
+      .replace(/\n.*\)$/, '')
+      .replace(/bb - /, '')
+      .split(':')
+      .map(s => s.trim());
+    const gateSize = parseInt(gateSizeStr);
+    assert(GATE_TYPES.includes(gateType as GateType), `Gate type ${gateType} is not recognized`);
+    return { [gateType]: gateSize };
+  });
+  assert(traceSizes.length === GATE_TYPES.length, 'Decoded trace sizes do not match expected amount of gate types');
+  return traceSizes.reduce((acc, curr) => ({ ...acc, ...curr }), {}) as StructuredTrace;
+}
+
+async function main() {
+  ProxyLogger.create();
+  const proxyLogger = ProxyLogger.getInstance();
+  const ivcFolder = process.env.CAPTURE_IVC_FOLDER;
+  if (!ivcFolder) {
+    throw new Error('CAPTURE_IVC_FOLDER is not set');
+  }
+  const flows = await readdir(ivcFolder);
+  logger.info(`Flows in ${ivcFolder}: \n${flows.map(flowName => `\t- ${flowName}`).join('\n')}`);
+  const { prover, type: proverType } = await createProver(
+    { bbBinaryPath: process.env.BB_BINARY_PATH, bbWorkingDirectory: process.env.BB_WORKING_DIRECTORY },
+    proxyLogger.createLogger('bb:prover'),
+  );
+
+  const userLog = createLogger('client_ivc_flows:data_processor');
+
+  for (const flow of flows) {
+    userLog.info(`Processing flow ${flow}`);
+    const bytecode = await readFile(join(ivcFolder, flow, 'acir.msgpack'));
+    const acirStack = decode(bytecode) as Buffer[];
+    const witnesses = await readFile(join(ivcFolder, flow, 'witnesses.json'));
+    const witnessStack = JSON.parse(witnesses.toString()).map((witnessMap: Record<string, string>) => {
+      return new Map<number, string>(Object.entries(witnessMap).map(([k, v]) => [Number(k), v]));
+    });
+    const stepsFile = await readFile(join(ivcFolder, flow, 'steps.json'));
+    const executionSteps = JSON.parse(stepsFile.toString()) as { fnName: string; gateCount: number }[];
+    const privateExecutionSteps: PrivateExecutionStep[] = executionSteps.map((step, i) => ({
+      functionName: step.fnName,
+      gateCount: step.gateCount,
+      bytecode: acirStack[i],
+      witness: witnessStack[i],
+    }));
+    let minimumTrace: StructuredTrace | undefined;
+    let stats: { duration: number; eventName: string; proofSize: number } | undefined;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let error: any | undefined;
+    let currentLogs: Log[] = [];
+    try {
+      await prover.createClientIvcProof(privateExecutionSteps);
+    } catch (e) {
+      userLog.error(`Failed to generate client ivc proof for ${flow}`, e);
+      error = (e as Error).message;
+    }
+    // Extract logs from this run from the proxy and write them to disk unconditionally
+    currentLogs = proxyLogger.getLogs();
+    await writeFile(join(ivcFolder, flow, 'logs.json'), JSON.stringify(currentLogs, null, 2));
+
+    if (!error) {
+      minimumTrace = getMinimumTrace(currentLogs, proverType);
+      stats = currentLogs[0].data as { duration: number; eventName: string; proofSize: number };
+    }
+
+    const steps = executionSteps.reduce<Step[]>((acc, step, i) => {
+      const previousAccGateCount = i === 0 ? 0 : acc[i - 1].accGateCount!;
+      return [
+        ...acc,
+        {
+          fnName: step.fnName,
+          gateCount: step.gateCount,
+          accGateCount: previousAccGateCount + step.gateCount,
+        },
+      ];
+    }, []);
+    const totalGateCount = steps[steps.length - 1].accGateCount;
+    const benchmark = {
+      proverType,
+      minimumTrace: minimumTrace,
+      totalGateCount,
+      stats,
+      steps,
+      error,
+    };
+    await writeFile(join(ivcFolder, flow, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
+    proxyLogger.flushLogs();
+  }
+}
+
+try {
+  await main();
+} catch (e) {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exit(1);
+}

package/src/bench/utils.ts

@@ -1,16 +1,12 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { type AztecNode, BatchCall, INITIAL_L2_BLOCK_NUM, type SentTx, type WaitOpts } from '@aztec/aztec.js';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
-import { randomInt } from '@aztec/foundation/crypto';
 import { BenchmarkingContract } from '@aztec/noir-contracts.js/Benchmarking';
 import { type PXEService, type PXEServiceConfig, createPXEService } from '@aztec/pxe/server';
 import type { MetricsType } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
 import { writeFileSync } from 'fs';
-import { mkdirpSync } from 'fs-extra';
-import { globSync } from 'glob';
-import { join } from 'path';
 
 import { type EndToEndContext, type SetupOptions, setup } from '../fixtures/utils.js';
 
@@ -94,30 +90,6 @@ function getMetricValues(points: BenchmarkDataPoint[]) {
   }
 }
 
-/**
- * Creates and returns a directory with the current job name and a random number.
- * @param index - Index to merge into the dir path.
- * @returns A path to a created dir.
- */
-export function makeDataDirectory(index: number) {
-  const testName = expect.getState().currentTestName!.split(' ')[0].replaceAll('/', '_');
-  const db = join('data', testName, index.toString(), `${randomInt(99)}`);
-  mkdirpSync(db);
-  return db;
-}
-
-/**
- * Returns the size in disk of a folder.
- * @param path - Path to the folder.
- * @returns Size in bytes.
- */
-export function getFolderSize(path: string): number {
-  return globSync('**', { stat: true, cwd: path, nodir: true, withFileTypes: true }).reduce(
-    (accum, file) => accum + (file as any as { /** Size */ size: number }).size,
-    0,
-  );
-}
-
 /**
  * Returns a call to the benchmark contract. Each call has a private execution (account entrypoint),
  * a nested private call (create_note), a public call (increment_balance), and a nested public

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -132,7 +132,7 @@ export class CrossChainMessagingTest {
 
         this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
 
-        return this.toCrossChainContext();
+        return this.crossChainTestHarness.toCrossChainContext();
       },
       async crossChainContext => {
         this.l2Token = await TokenContract.at(crossChainContext.l2Token, this.user1Wallet);
@@ -177,28 +177,4 @@ export class CrossChainMessagingTest {
       },
     );
   }
-
-  toCrossChainContext(): CrossChainContext {
-    return {
-      l2Token: this.crossChainTestHarness.l2Token.address,
-      l2Bridge: this.crossChainTestHarness.l2Bridge.address,
-      tokenPortal: this.crossChainTestHarness.tokenPortalAddress,
-      underlying: this.crossChainTestHarness.underlyingERC20Address,
-      ethAccount: this.crossChainTestHarness.ethAccount,
-      ownerAddress: this.crossChainTestHarness.ownerAddress,
-      inbox: this.crossChainTestHarness.l1ContractAddresses.inboxAddress,
-      outbox: this.crossChainTestHarness.l1ContractAddresses.outboxAddress,
-    };
-  }
 }
-
-type CrossChainContext = {
-  l2Token: AztecAddress;
-  l2Bridge: AztecAddress;
-  tokenPortal: EthAddress;
-  underlying: EthAddress;
-  ethAccount: EthAddress;
-  ownerAddress: AztecAddress;
-  inbox: EthAddress;
-  outbox: EthAddress;
-};

package/src/e2e_fees/fees_test.ts

@@ -168,7 +168,7 @@ export class FeesTest {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig, deployL1ContractsValues }) => {
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
         this.pxe = pxe;
 
         this.aztecNode = aztecNode;
@@ -185,16 +185,6 @@ export class FeesTest {
         const canonicalFeeJuice = await getCanonicalFeeJuice();
         this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.aliceWallet);
         this.coinbase = EthAddress.random();
-
-        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-          aztecNode,
-          aztecNodeAdmin: aztecNode,
-          pxeService: pxe,
-          publicClient: deployL1ContractsValues.publicClient,
-          walletClient: deployL1ContractsValues.walletClient,
-          wallet: this.aliceWallet,
-          logger: this.logger,
-        });
       },
     );
   }