@aztec/end-to-end 0.0.1-commit.5476d83 → 0.0.1-commit.59e663cd

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -1,43 +1,46 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
 import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { waitForProven } from '@aztec/aztec.js/contracts';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
+import type { TxReceipt } from '@aztec/aztec.js/tx';
 import { CheatCodes } from '@aztec/aztec/testing';
-import {
-  type DeployL1ContractsArgs,
-  type DeployL1ContractsReturnType,
-  type ExtendedViemWalletClient,
-  createExtendedL1Client,
-  deployL1Contract,
-} from '@aztec/ethereum';
-import { InboxAbi, OutboxAbi, TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { InboxContract, OutboxContract, RollupContract } from '@aztec/ethereum/contracts';
+import type {
+  DeployAztecL1ContractsArgs,
+  DeployAztecL1ContractsReturnType,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
+import { sleep } from '@aztec/foundation/sleep';
+import { TestERC20Abi, TestERC20Bytecode } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { TestWallet } from '@aztec/test-wallet/server';
 
-import { getContract } from 'viem';
-
 import { MNEMONIC } from '../fixtures/fixtures.js';
 import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
+  type EndToEndContext,
+  type SetupOptions,
   deployAccounts,
   publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
-import type { SetupOptions } from '../fixtures/utils.js';
+  setup,
+  teardown,
+} from '../fixtures/setup.js';
 import { CrossChainTestHarness } from '../shared/cross_chain_test_harness.js';
 
-const { E2E_DATA_PATH: dataPath } = process.env;
-
 export class CrossChainMessagingTest {
-  private snapshotManager: ISnapshotManager;
+  private requireEpochProven: boolean;
+  private setupOptions: SetupOptions;
+  private deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs>;
   logger: Logger;
+  context!: EndToEndContext;
   aztecNode!: AztecNode;
   aztecNodeConfig!: AztecNodeConfig;
   aztecNodeAdmin!: AztecNodeAdmin;
-  ctx!: SubsystemsContext;
 
   l1Client!: ExtendedViemWalletClient | undefined;
 
@@ -50,130 +53,142 @@ export class CrossChainMessagingTest {
   l2Token!: TokenContract;
   l2Bridge!: TokenBridgeContract;
 
-  inbox!: any; // GetContractReturnType<typeof InboxAbi> | undefined;
-  outbox!: any; // GetContractReturnType<typeof OutboxAbi> | undefined;
+  rollup!: RollupContract;
+  inbox!: InboxContract;
+  outbox!: OutboxContract;
   cheatCodes!: CheatCodes;
 
-  deployL1ContractsValues!: DeployL1ContractsReturnType;
+  deployL1ContractsValues!: DeployAztecL1ContractsReturnType;
 
-  constructor(testName: string, opts: SetupOptions = {}, deployL1ContractsArgs: Partial<DeployL1ContractsArgs> = {}) {
+  constructor(
+    testName: string,
+    opts: SetupOptions = {},
+    deployL1ContractsArgs: Partial<DeployAztecL1ContractsArgs> = {},
+  ) {
     this.logger = createLogger(`e2e:e2e_cross_chain_messaging:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_cross_chain_messaging/${testName}`, dataPath, opts, {
+    this.setupOptions = opts;
+    this.deployL1ContractsArgs = {
       initialValidators: [],
       ...deployL1ContractsArgs,
-    });
+    };
+    this.requireEpochProven = opts.startProverNode ?? false;
   }
 
-  async assumeProven() {
-    await this.cheatCodes.rollup.markAsProven();
+  async setup() {
+    this.logger.info('Setting up cross chain messaging test');
+    this.context = await setup(0, {
+      ...this.setupOptions,
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+      l1ContractsArgs: this.deployL1ContractsArgs,
+    });
+    await this.applyBaseSetup();
   }
 
-  async setup() {
-    this.ctx = await this.snapshotManager.setup();
-    this.aztecNode = this.ctx.aztecNode;
-    this.wallet = this.ctx.wallet;
-    this.aztecNodeConfig = this.ctx.aztecNodeConfig;
-    this.cheatCodes = this.ctx.cheatCodes;
-    this.deployL1ContractsValues = this.ctx.deployL1ContractsValues;
-    this.aztecNodeAdmin = this.ctx.aztecNode;
+  async advanceToEpochProven(l2TxReceipt: TxReceipt): Promise<EpochNumber> {
+    const epoch = await this.rollup.getEpochNumberForCheckpoint(
+      CheckpointNumber.fromBlockNumber(l2TxReceipt.blockNumber!),
+    );
+    // Warp to the next epoch.
+    await this.cheatCodes.rollup.advanceToEpoch(EpochNumber(epoch + 1));
+    // Wait for the tx to be proven.
+    await waitForProven(this.aztecNode, l2TxReceipt, { provenTimeout: 300 });
+    // Return the epoch the tx is in.
+    return epoch;
   }
 
-  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 catchUpProvenChain() {
+    const bn = await this.aztecNode.getBlockNumber();
+    while ((await this.aztecNode.getProvenBlockNumber()) < bn) {
+      await sleep(1000);
+    }
+  }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
-  async applyBaseSnapshots() {
-    // Note that we are using the same `wallet`, `aztecNodeConfig` and `aztecNode` across all snapshots.
-    // This is to not have issues with different networks.
-
-    await this.snapshotManager.snapshot(
-      '3_accounts',
-      deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { wallet, aztecNodeConfig, aztecNode }) => {
-        [this.ownerAddress, this.user1Address, this.user2Address] = deployedAccounts.map(a => a.address);
-        this.wallet = wallet;
-        this.aztecNode = aztecNode;
-        this.aztecNodeConfig = aztecNodeConfig;
-        return Promise.resolve();
-      },
+  async applyBaseSetup() {
+    // Set up base context fields
+    this.aztecNode = this.context.aztecNodeService!;
+    this.wallet = this.context.wallet;
+    this.aztecNodeConfig = this.context.config;
+    this.cheatCodes = this.context.cheatCodes;
+    this.deployL1ContractsValues = this.context.deployL1ContractsValues;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
+
+    if (this.requireEpochProven) {
+      // Turn off the watcher to prevent it from keep marking blocks as proven.
+      this.context.watcher!.setIsMarkingAsProven(false);
+    }
+
+    // Deploy 3 accounts
+    this.logger.info('Applying 3_accounts setup');
+    const { deployedAccounts } = await deployAccounts(
+      3,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+    [this.ownerAddress, this.user1Address, this.user2Address] = deployedAccounts.map(a => a.address);
+
+    // Set up cross chain messaging
+    this.logger.info('Applying e2e_cross_chain_messaging setup');
+
+    // Create the token contract state.
+    this.logger.verbose(`Public deploy accounts...`);
+    await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
+
+    this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+
+    const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
+      'Underlying',
+      'UND',
+      this.l1Client.account.address,
+    ]).then(({ address }) => address);
+
+    this.logger.verbose(`Setting up cross chain harness...`);
+    this.crossChainTestHarness = await CrossChainTestHarness.new(
+      this.aztecNode,
+      this.l1Client,
+      this.wallet,
+      this.ownerAddress,
+      this.logger,
+      underlyingERC20Address,
     );
 
-    await this.snapshotManager.snapshot(
-      'e2e_cross_chain_messaging',
-      async () => {
-        // Create the token contract state.
-        // Move this account thing to addAccounts above?
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.ownerAddress, this.user1Address, this.user2Address]);
-
-        this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-
-        const underlyingERC20Address = await deployL1Contract(this.l1Client, TestERC20Abi, TestERC20Bytecode, [
-          'Underlying',
-          'UND',
-          this.l1Client.account.address,
-        ]).then(({ address }) => address);
-
-        this.logger.verbose(`Setting up cross chain harness...`);
-        this.crossChainTestHarness = await CrossChainTestHarness.new(
-          this.aztecNode,
-          this.l1Client,
-          this.wallet,
-          this.ownerAddress,
-          this.logger,
-          underlyingERC20Address,
-        );
-
-        this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
-
-        return this.crossChainTestHarness.toCrossChainContext();
-      },
-      crossChainContext => {
-        this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
-        this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
-
-        // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
-        this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
-        const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
-
-        const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-
-        const inbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.inboxAddress.toString(),
-          abi: InboxAbi,
-          client: l1Client,
-        });
-        const outbox = getContract({
-          address: this.aztecNodeConfig.l1Contracts.outboxAddress.toString(),
-          abi: OutboxAbi,
-          client: l1Client,
-        });
-
-        this.crossChainTestHarness = new CrossChainTestHarness(
-          this.aztecNode,
-          this.logger,
-          this.l2Token,
-          this.l2Bridge,
-          this.ethAccount,
-          tokenPortalAddress,
-          crossChainContext.underlying,
-          l1Client,
-          this.aztecNodeConfig.l1Contracts,
-          this.wallet,
-          this.ownerAddress,
-        );
-
-        this.l1Client = l1Client;
-        this.inbox = inbox;
-        this.outbox = outbox;
-        return Promise.resolve();
-      },
+    this.logger.verbose(`L2 token deployed to: ${this.crossChainTestHarness.l2Token.address}`);
+
+    const crossChainContext = this.crossChainTestHarness.toCrossChainContext();
+
+    this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
+    this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
+
+    // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
+    this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
+    const tokenPortalAddress = EthAddress.fromString(crossChainContext.tokenPortal.toString());
+
+    const l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+    this.l1Client = l1Client;
+
+    const l1Contracts = this.aztecNodeConfig.l1Contracts;
+    this.rollup = new RollupContract(l1Client, l1Contracts.rollupAddress.toString());
+    this.inbox = new InboxContract(l1Client, l1Contracts.inboxAddress.toString());
+    this.outbox = new OutboxContract(l1Client, l1Contracts.outboxAddress.toString());
+
+    this.crossChainTestHarness = new CrossChainTestHarness(
+      this.aztecNode,
+      this.logger,
+      this.l2Token,
+      this.l2Bridge,
+      this.ethAccount,
+      tokenPortalAddress,
+      crossChainContext.underlying,
+      l1Client,
+      this.aztecNodeConfig.l1Contracts,
+      this.wallet,
+      this.ownerAddress,
     );
   }
 }

package/src/e2e_deploy_contract/deploy_test.ts

@@ -10,12 +10,10 @@ import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/Statefu
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { TestWallet } from '@aztec/test-wallet/server';
 
-import { type ISnapshotManager, createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
-
-const { E2E_DATA_PATH: dataPath } = process.env;
+import { type EndToEndContext, deployAccounts, setup, teardown } from '../fixtures/setup.js';
 
 export class DeployTest {
-  private snapshotManager: ISnapshotManager;
+  public context!: EndToEndContext;
   public logger: Logger;
   public wallet!: TestWallet;
   public defaultAccountAddress!: AztecAddress;
@@ -24,26 +22,35 @@ export class DeployTest {
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_deploy_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_deploy_contract/${testName}`, dataPath);
   }
 
   async setup() {
-    await this.applyInitialAccountSnapshot();
-    const context = await this.snapshotManager.setup();
-    ({ aztecNode: this.aztecNode, wallet: this.wallet } = context);
-    this.aztecNodeAdmin = context.aztecNode;
+    this.logger.info('Setting up test environment');
+    this.context = await setup(0, {
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
+    this.aztecNode = this.context.aztecNodeService!;
+    this.wallet = this.context.wallet;
+    this.aztecNodeAdmin = this.context.aztecNodeService!;
+    await this.applyInitialAccount();
     return this;
   }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardown(this.context);
   }
 
-  private async applyInitialAccountSnapshot() {
-    await this.snapshotManager.snapshot('initial_account', deployAccounts(1, this.logger), ({ deployedAccounts }) => {
-      this.defaultAccountAddress = deployedAccounts[0].address;
-      return Promise.resolve();
+  private async applyInitialAccount() {
+    this.logger.info('Applying initial account setup');
+    const { deployedAccounts } = await deployAccounts(
+      1,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
     });
+    this.defaultAccountAddress = deployedAccounts[0].address;
   }
 
   async registerContract<T extends ContractBase>(

package/src/e2e_epochs/epochs_test.ts

@@ -6,19 +6,23 @@ import type { Logger } from '@aztec/aztec.js/log';
 import { MerkleTreeId } from '@aztec/aztec.js/trees';
 import type { Wallet } from '@aztec/aztec.js/wallet';
 import { EpochCache } from '@aztec/epoch-cache';
-import { DefaultL1ContractsConfig, type ExtendedViemWalletClient, createExtendedL1Client } from '@aztec/ethereum';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import { ChainMonitor, DelayedTxUtils, type Delayer, waitUntilL1Timestamp, withDelayer } from '@aztec/ethereum/test';
-import { EpochNumber } from '@aztec/foundation/branded-types';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
-import { randomBytes } from '@aztec/foundation/crypto';
+import { randomBytes } from '@aztec/foundation/crypto/random';
 import { withLogNameSuffix } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { ProverNode, type ProverNodeConfig, ProverNodePublisher } from '@aztec/prover-node';
 import type { TestProverNode } from '@aztec/prover-node/test';
+import type { PXEConfig } from '@aztec/pxe/config';
 import {
   type SequencerClient,
   type SequencerEvents,
@@ -26,7 +30,7 @@ import {
   SequencerState,
 } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import { EthAddress, type L2BlockNumber } from '@aztec/stdlib/block';
+import { type BlockParameter, EthAddress } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 
@@ -47,7 +51,7 @@ export const WORLD_STATE_BLOCK_CHECK_INTERVAL = 50;
 export const ARCHIVER_POLL_INTERVAL = 50;
 export const DEFAULT_L1_BLOCK_TIME = process.env.CI ? 12 : 8;
 
-export type EpochsTestOpts = Partial<SetupOptions> & { numberOfAccounts?: number };
+export type EpochsTestOpts = Partial<SetupOptions> & { numberOfAccounts?: number; pxeOpts?: Partial<PXEConfig> };
 
 export type TrackedSequencerEvent = {
   [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
@@ -95,43 +99,60 @@ export class EpochsTestContext {
     const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
     const aztecEpochDuration = opts.aztecEpochDuration ?? 6;
     const aztecProofSubmissionEpochs = opts.aztecProofSubmissionEpochs ?? 1;
-    return { ethereumSlotDuration, aztecSlotDuration, aztecEpochDuration, aztecProofSubmissionEpochs };
+    const l1PublishingTime = opts.l1PublishingTime ?? 1;
+    return {
+      l1PublishingTime,
+      ethereumSlotDuration,
+      aztecSlotDuration,
+      aztecEpochDuration,
+      aztecProofSubmissionEpochs,
+    };
   }
 
   public async setup(opts: EpochsTestOpts = {}) {
-    const { ethereumSlotDuration, aztecSlotDuration, aztecEpochDuration, aztecProofSubmissionEpochs } =
-      EpochsTestContext.getSlotDurations(opts);
+    const {
+      ethereumSlotDuration,
+      aztecSlotDuration,
+      aztecEpochDuration,
+      aztecProofSubmissionEpochs,
+      l1PublishingTime,
+    } = EpochsTestContext.getSlotDurations(opts);
 
     this.L1_BLOCK_TIME_IN_S = ethereumSlotDuration;
     this.L2_SLOT_DURATION_IN_S = aztecSlotDuration;
 
     // Set up system without any account nor protocol contracts
     // and with faster block times and shorter epochs.
-    const context = await setup(opts.numberOfAccounts ?? 0, {
-      automineL1Setup: true,
-      checkIntervalMs: 50,
-      archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
-      worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
-      skipProtocolContracts: true,
-      salt: 1,
-      aztecEpochDuration,
-      aztecSlotDuration,
-      ethereumSlotDuration,
-      aztecProofSubmissionEpochs,
-      aztecTargetCommitteeSize: opts.initialValidators?.length ?? 0,
-      minTxsPerBlock: 0,
-      realProofs: false,
-      startProverNode: true,
-      proverTestDelayMs: opts.proverTestDelayMs ?? 0,
-      // We use numeric incremental prover ids for simplicity, but we can switch to
-      // using the prover's eth address if the proverId is used for something in the rollup contract
-      // Use numeric EthAddress for deterministic prover id
-      proverId: EthAddress.fromNumber(1),
-      worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
-      exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
-      slasherFlavor: 'none',
-      ...opts,
-    });
+    const context = await setup(
+      opts.numberOfAccounts ?? 0,
+      {
+        automineL1Setup: true,
+        checkIntervalMs: 50,
+        archiverPollingIntervalMS: ARCHIVER_POLL_INTERVAL,
+        worldStateBlockCheckIntervalMS: WORLD_STATE_BLOCK_CHECK_INTERVAL,
+        aztecEpochDuration,
+        aztecSlotDuration,
+        ethereumSlotDuration,
+        aztecProofSubmissionEpochs,
+        aztecTargetCommitteeSize: opts.initialValidators?.length ?? 0,
+        minTxsPerBlock: 0,
+        realProofs: false,
+        startProverNode: true,
+        proverTestDelayMs: opts.proverTestDelayMs ?? 0,
+        // We use numeric incremental prover ids for simplicity, but we can switch to
+        // using the prover's eth address if the proverId is used for something in the rollup contract
+        // Use numeric EthAddress for deterministic prover id
+        proverId: EthAddress.fromNumber(1),
+        worldStateBlockHistory: WORLD_STATE_BLOCK_HISTORY,
+        exitDelaySeconds: DefaultL1ContractsConfig.exitDelaySeconds,
+        slasherFlavor: 'none',
+        l1PublishingTime,
+        ...opts,
+      },
+      // Use checkpointed chain tip for PXE by default to avoid issues with blocks being dropped due to pruned anchor blocks.
+      // Can be overridden via opts.pxeOpts.
+      { syncChainTip: 'checkpointed', ...opts.pxeOpts },
+    );
 
     this.context = context;
     this.proverNodes = context.proverNode ? [context.proverNode] : [];
@@ -198,7 +219,7 @@ export class EpochsTestContext {
           ...opts,
         },
         this.context.aztecNode,
-        undefined,
+        this.context.prefilledPublicData ?? [],
         { dateProvider: this.context.dateProvider },
       ),
     );
@@ -291,21 +312,21 @@ export class EpochsTestContext {
     return start;
   }
 
-  /** Waits until the given L2 block number is mined. */
-  public async waitUntilL2BlockNumber(target: number, timeout = 60) {
+  /** Waits until the given checkpoint number is mined. */
+  public async waitUntilCheckpointNumber(target: CheckpointNumber, timeout = 120) {
     await retryUntil(
       () => Promise.resolve(target <= this.monitor.checkpointNumber),
-      `Wait until L2 block ${target}`,
+      `Wait until checkpoint ${target}`,
       timeout,
       0.1,
     );
   }
 
-  /** Waits until the given L2 block number is marked as proven. */
-  public async waitUntilProvenL2BlockNumber(t: number, timeout = 60) {
+  /** Waits until the given checkpoint number is marked as proven. */
+  public async waitUntilProvenCheckpointNumber(target: CheckpointNumber, timeout = 120) {
     await retryUntil(
-      () => Promise.resolve(t <= this.monitor.provenCheckpointNumber),
-      `Wait proven L2 block ${t}`,
+      () => Promise.resolve(target <= this.monitor.provenCheckpointNumber),
+      `Wait proven checkpoint ${target}`,
       timeout,
       0.1,
     );
@@ -324,7 +345,7 @@ export class EpochsTestContext {
   }
 
   /** Waits for the aztec node to sync to the target block number. */
-  public async waitForNodeToSync(blockNumber: number, type: 'proven' | 'finalized' | 'historic') {
+  public async waitForNodeToSync(blockNumber: BlockNumber, type: 'proven' | 'finalized' | 'historic') {
     const waitTime = ARCHIVER_POLL_INTERVAL + WORLD_STATE_BLOCK_CHECK_INTERVAL;
     let synched = false;
     while (!synched) {
@@ -335,7 +356,7 @@ export class EpochsTestContext {
       ]);
       this.logger.info(`Wait for node synch ${blockNumber} ${type}`, { blockNumber, type, syncState, tips });
       if (type === 'proven') {
-        synched = tips.proven.number >= blockNumber && syncState.latestBlockNumber >= blockNumber;
+        synched = tips.proven.block.number >= blockNumber && syncState.latestBlockNumber >= blockNumber;
       } else if (type === 'finalized') {
         synched = syncState.finalizedBlockNumber >= blockNumber;
       } else {
@@ -357,6 +378,19 @@ export class EpochsTestContext {
     return SpamContract.at(instance.address, wallet);
   }
 
+  /** Registers the TestContract on the given wallet. */
+  public async registerTestContract(wallet: Wallet, salt = Fr.ZERO) {
+    const instance = await getContractInstanceFromInstantiationParams(TestContract.artifact, {
+      constructorArgs: [],
+      constructorArtifact: undefined,
+      salt,
+      publicKeys: undefined,
+      deployer: undefined,
+    });
+    await wallet.registerContract(instance, TestContract.artifact);
+    return TestContract.at(instance.address, wallet);
+  }
+
   /** Creates an L1 client using a fresh account with funds from anvil, with a tx delayer already set up. */
   public async createL1Client() {
     const { client, delayer } = withDelayer(
@@ -373,7 +407,7 @@ export class EpochsTestContext {
   }
 
   /** Verifies whether the given block number is found on the aztec node. */
-  public async verifyHistoricBlock(blockNumber: L2BlockNumber, expectedSuccess: boolean) {
+  public async verifyHistoricBlock(blockNumber: BlockParameter, expectedSuccess: boolean) {
     // We use `findLeavesIndexes` here, but could use any function that queries the world-state
     // at a particular block, so we know whether that historic block is available or has been
     // pruned. Note that `getBlock` would not work here, since it only hits the archiver.
@@ -391,11 +425,11 @@ export class EpochsTestContext {
     const stateChanges: TrackedSequencerEvent[] = [];
     const failEvents: TrackedSequencerEvent[] = [];
 
-    // Note we do not include the 'tx-count-check-failed' event here, since it is fine if we dont build
+    // Note we do not include the 'block-tx-count-check-failed' event here, since it is fine if we dont build
     // due to lack of txs available.
     const failEventsKeys: (keyof SequencerEvents)[] = [
       'block-build-failed',
-      'block-publish-failed',
+      'checkpoint-publish-failed',
       'proposer-rollup-check-failed',
     ];
 

package/src/e2e_fees/bridging_race.notest.ts

@@ -1,7 +1,7 @@
 import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
 import { Fr } from '@aztec/aztec.js/fields';
 import type { Logger } from '@aztec/aztec.js/log';
-import { Fq } from '@aztec/foundation/fields';
+import { Fq } from '@aztec/foundation/curves/bn254';
 import { sleep } from '@aztec/foundation/sleep';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { TestWallet } from '@aztec/test-wallet/server';
@@ -26,11 +26,8 @@ describe('e2e_fees bridging_race', () => {
   });
 
   beforeAll(async () => {
-    await t.applyInitialAccountsSnapshot();
-    await t.applyPublicDeployAccountsSnapshot();
-    await t.applySetupFeeJuiceSnapshot();
-
-    ({ wallet, logger } = await t.setup());
+    await t.setup();
+    ({ wallet, logger } = t);
   });
 
   afterAll(async () => {
@@ -70,10 +67,7 @@ describe('e2e_fees bridging_race', () => {
     // Yes, we need to REFACTOR it at some point
     const claim = await t.feeJuiceBridgeTestHarness.prepareTokensOnL1(bobsAddress);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await t.feeJuiceContract.methods
-      .claim(bobsAddress, claim.claimAmount, secret, index)
-      .send({ from: bobsAddress })
-      .wait();
+    await t.feeJuiceContract.methods.claim(bobsAddress, claim.claimAmount, secret, index).send({ from: bobsAddress });
     const [balance] = await t.getGasBalanceFn(bobsAddress);
     expect(balance).toEqual(claim.claimAmount);
   });