@aztec/end-to-end 1.2.1 → 2.0.0-nightly.20250814

package/src/bench/utils.ts

@@ -22,7 +22,9 @@ export async function benchmarkSetup(
   },
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
-  const contract = await BenchmarkingContract.deploy(context.wallet).send().deployed();
+  const contract = await BenchmarkingContract.deploy(context.wallet)
+    .send({ from: context.wallet.getAddress() })
+    .deployed();
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
   const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
@@ -110,12 +112,11 @@ function makeCall(
   heavyPublicCompute: boolean,
 ) {
   const owner = context.wallet.getAddress();
-  const sender = owner;
   if (heavyPublicCompute) {
     return new BatchCall(context.wallet, [contract.methods.sha256_hash_2048(randomBytesAsBigInts(2048))]);
   } else {
     return new BatchCall(context.wallet, [
-      contract.methods.create_note(owner, sender, index + 1),
+      contract.methods.create_note(owner, index + 1),
       contract.methods.increment_balance(owner, index + 1),
     ]);
   }
@@ -138,7 +139,7 @@ export async function sendTxs(
 ): Promise<SentTx[]> {
   const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
   context.logger.info(`Creating ${txCount} txs`);
-  const provenTxs = await Promise.all(calls.map(call => call.prove()));
+  const provenTxs = await Promise.all(calls.map(call => call.prove({ from: context.wallet.getAddress() })));
   context.logger.info(`Sending ${txCount} txs`);
   return provenTxs.map(tx => tx.send());
 }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -2,6 +2,7 @@ import { getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
   type AccountWallet,
   AztecAddress,
+  type AztecNode,
   type CompleteAddress,
   Fr,
   type Logger,
@@ -10,9 +11,11 @@ import {
   computeSecretHash,
   createLogger,
 } from '@aztec/aztec.js';
+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 { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
+import type { SequencerClient } from '@aztec/sequencer-client';
 
 import { jest } from '@jest/globals';
 
@@ -55,9 +58,8 @@ export class Role {
 }
 
 export class BlacklistTokenContractTest {
-  // A low delay is really poor ux, but we need to keep it low for the tests to run "quickly".
   // This value MUST match the same value that we have in the contract
-  static DELAY = 2;
+  static CHANGE_ROLES_DELAY = 86400;
 
   private snapshotManager: ISnapshotManager;
   logger: Logger;
@@ -67,20 +69,28 @@ export class BlacklistTokenContractTest {
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
+  cheatCodes!: CheatCodes;
+  sequencer!: SequencerClient;
+  aztecNode!: AztecNode;
 
   admin!: AccountWallet;
+  adminAddress!: AztecAddress;
   other!: AccountWallet;
+  otherAddress!: AztecAddress;
   blacklisted!: AccountWallet;
+  blacklistedAddress!: AztecAddress;
 
   constructor(testName: string) {
     this.logger = createLogger(`e2e:e2e_blacklist_token_contract:${testName}`);
     this.snapshotManager = createSnapshotManager(`e2e_blacklist_token_contract/${testName}`, dataPath);
   }
 
-  async mineBlocks(amount: number = BlacklistTokenContractTest.DELAY) {
-    for (let i = 0; i < amount; ++i) {
-      await this.asset.methods.get_roles(this.admin.getAddress()).send().wait();
-    }
+  async crossTimestampOfChange() {
+    await this.cheatCodes.warpL2TimeAtLeastBy(
+      this.sequencer,
+      this.aztecNode,
+      BlacklistTokenContractTest.CHANGE_ROLES_DELAY,
+    );
   }
 
   /**
@@ -95,12 +105,18 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
+      async ({ deployedAccounts }, { pxe, cheatCodes, aztecNode, sequencer }) => {
         this.pxe = pxe;
+        this.cheatCodes = cheatCodes;
+        this.aztecNode = aztecNode;
+        this.sequencer = sequencer;
         this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
         this.admin = this.wallets[0];
+        this.adminAddress = this.admin.getAddress();
         this.other = this.wallets[1];
+        this.otherAddress = this.other.getAddress();
         this.blacklisted = this.wallets[2];
+        this.blacklistedAddress = this.blacklisted.getAddress();
         this.accounts = this.wallets.map(w => w.getCompleteAddress());
       },
     );
@@ -111,17 +127,19 @@ export class BlacklistTokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.admin, this.accounts.slice(0, 3));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.admin, this.admin.getAddress()).send().deployed();
+        this.asset = await TokenBlacklistContract.deploy(this.admin, 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.wallets[0]).send().deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
-        await this.mineBlocks();
+        await this.crossTimestampOfChange();
 
         return { tokenContractAddress: this.asset.address, badAccountAddress: this.badAccount.address };
       },
@@ -132,7 +150,8 @@ export class BlacklistTokenContractTest {
 
         this.tokenSim = new TokenSimulator(
           this.asset as unknown as TokenContract,
-          this.wallets[0],
+          this.admin,
+          this.adminAddress,
           this.logger,
           this.accounts.map(a => a.address),
         );
@@ -140,7 +159,7 @@ export class BlacklistTokenContractTest {
         this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
-        expect(await this.asset.methods.get_roles(this.admin.getAddress()).simulate()).toEqual(
+        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
           new Role().withAdmin().toNoirStruct(),
         );
       },
@@ -179,7 +198,7 @@ export class BlacklistTokenContractTest {
         txEffects!.data.nullifiers[0],
         recipient,
       )
-      .simulate();
+      .simulate({ from: recipient });
   }
 
   async applyMintSnapshot() {
@@ -193,32 +212,34 @@ export class BlacklistTokenContractTest {
         await this.asset
           .withWallet(this.admin)
           .methods.update_roles(this.admin.getAddress(), adminMinterRole.toNoirStruct())
-          .send()
+          .send({ from: this.adminAddress })
           .wait();
 
         const blacklistRole = new Role().withBlacklisted();
         await this.asset
           .withWallet(this.admin)
           .methods.update_roles(this.blacklisted.getAddress(), blacklistRole.toNoirStruct())
-          .send()
+          .send({ from: this.adminAddress })
           .wait();
 
-        await this.mineBlocks(); // This gets us past the block of change
+        await this.crossTimestampOfChange();
 
-        expect(await this.asset.methods.get_roles(this.admin.getAddress()).simulate()).toEqual(
-          adminMinterRole.toNoirStruct(),
-        );
+        expect(
+          await this.asset.methods.get_roles(this.admin.getAddress()).simulate({ from: this.adminAddress }),
+        ).toEqual(adminMinterRole.toNoirStruct());
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(accounts[0].address, amount).send().wait();
+        await asset.methods.mint_public(accounts[0].address, 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().wait();
+        const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress }).wait();
 
         await this.addPendingShieldNoteToPXE(asset, wallets[0].getAddress(), amount, secretHash, receipt.txHash);
-        const txClaim = asset.methods.redeem_shield(accounts[0].address, amount, secret).send();
+        const txClaim = asset.methods
+          .redeem_shield(accounts[0].address, amount, secret)
+          .send({ from: this.adminAddress });
         await txClaim.wait();
         this.logger.verbose(`Minting complete.`);
 
@@ -232,16 +253,16 @@ export class BlacklistTokenContractTest {
         } = this;
         tokenSim.mintPublic(address, amount);
 
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
         expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
 
         tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
         expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -10,7 +10,7 @@ import {
   type PXE,
   createLogger,
 } from '@aztec/aztec.js';
-import { CheatCodes } from '@aztec/aztec.js/testing';
+import { CheatCodes } from '@aztec/aztec/testing';
 import {
   type DeployL1ContractsReturnType,
   type ExtendedViemWalletClient,
@@ -39,7 +39,6 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class CrossChainMessagingTest {
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
   accounts: CompleteAddress[] = [];
   aztecNode!: AztecNode;
   pxe!: PXE;
@@ -49,7 +48,9 @@ export class CrossChainMessagingTest {
   l1Client!: ExtendedViemWalletClient | undefined;
 
   user1Wallet!: AccountWallet;
+  user1Address!: AztecAddress;
   user2Wallet!: AccountWallet;
+  user2Address!: AztecAddress;
   crossChainTestHarness!: CrossChainTestHarness;
   ethAccount!: EthAddress;
   ownerAddress!: AztecAddress;
@@ -99,12 +100,14 @@ export class CrossChainMessagingTest {
       '3_accounts',
       deployAccounts(3, this.logger),
       async ({ deployedAccounts }, { pxe, aztecNodeConfig, aztecNode }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        this.accounts = wallets.map(w => w.getCompleteAddress());
+        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
 
-        this.user1Wallet = this.wallets[0];
-        this.user2Wallet = this.wallets[1];
+        this.user1Wallet = wallets[0];
+        this.user1Address = this.user1Wallet.getAddress();
+        this.user2Wallet = wallets[1];
+        this.user2Address = this.user2Wallet.getAddress();
 
         this.pxe = pxe;
         this.aztecNode = aztecNode;
@@ -118,7 +121,7 @@ export class CrossChainMessagingTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.user1Wallet, this.accounts.slice(0, 3));
 
         this.l1Client = createExtendedL1Client(this.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
@@ -133,7 +136,8 @@ export class CrossChainMessagingTest {
           this.aztecNode,
           this.pxe,
           this.l1Client,
-          this.wallets[0],
+          this.user1Wallet,
+          this.user1Address,
           this.logger,
           underlyingERC20Address,
         );
@@ -176,6 +180,7 @@ export class CrossChainMessagingTest {
           l1Client,
           this.aztecNodeConfig.l1Contracts,
           this.user1Wallet,
+          this.user1Address,
         );
 
         this.l1Client = l1Client;

package/src/e2e_deploy_contract/deploy_test.ts

@@ -11,7 +11,7 @@ import {
   type PublicKeys,
   type Wallet,
   createLogger,
-  getContractInstanceFromDeployParams,
+  getContractInstanceFromInstantiationParams,
 } from '@aztec/aztec.js';
 import type { StatefulTestContract } from '@aztec/noir-test-contracts.js/StatefulTest';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
@@ -22,11 +22,10 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 
 export class DeployTest {
   private snapshotManager: ISnapshotManager;
-  private wallets: AccountWallet[] = [];
-
   public logger: Logger;
   public pxe!: PXE;
   public wallet!: AccountWallet;
+  public defaultAccountAddress!: AztecAddress;
   public aztecNode!: AztecNode;
   public aztecNodeAdmin!: AztecNodeAdmin;
 
@@ -52,9 +51,10 @@ export class DeployTest {
       'initial_account',
       deployAccounts(1, this.logger),
       async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        this.wallet = this.wallets[0];
+        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        this.wallet = wallets[0];
+        this.defaultAccountAddress = this.wallet.getAddress();
       },
     );
   }
@@ -71,7 +71,7 @@ export class DeployTest {
     } = {},
   ): Promise<T> {
     const { salt, publicKeys, initArgs, constructorName, deployer } = opts;
-    const instance = await getContractInstanceFromDeployParams(contractArtifact.artifact, {
+    const instance = await getContractInstanceFromInstantiationParams(contractArtifact.artifact, {
       constructorArgs: initArgs ?? [],
       constructorArtifact: constructorName,
       salt,

package/src/e2e_epochs/epochs_test.ts

@@ -4,7 +4,7 @@ import {
   type Logger,
   MerkleTreeId,
   type Wallet,
-  getContractInstanceFromDeployParams,
+  getContractInstanceFromInstantiationParams,
   getTimestampRangeForEpoch,
   retryUntil,
   sleep,
@@ -19,9 +19,14 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
 import { ProverNode, ProverNodePublisher } from '@aztec/prover-node';
 import type { TestProverNode } from '@aztec/prover-node/test';
-import type { SequencerPublisher } from '@aztec/sequencer-client';
+import {
+  type SequencerClient,
+  type SequencerEvents,
+  type SequencerPublisher,
+  SequencerState,
+} from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import type { L2BlockNumber } from '@aztec/stdlib/block';
+import type { EthAddress, L2BlockNumber } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getProofSubmissionDeadlineTimestamp } from '@aztec/stdlib/epoch-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 
@@ -40,24 +45,17 @@ import {
 export const WORLD_STATE_BLOCK_HISTORY = 2;
 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<
-  Pick<
-    SetupOptions,
-    | 'startProverNode'
-    | 'aztecProofSubmissionEpochs'
-    | 'aztecEpochDuration'
-    | 'proverTestDelayMs'
-    | 'l1PublishRetryIntervalMS'
-    | 'txPropagationMaxQueryAttempts'
-    | 'proverNodeConfig'
-    | 'ethereumSlotDuration'
-    | 'aztecSlotDuration'
-    | 'initialValidators'
-    | 'mockGossipSubNetwork'
-    | 'disableAnvilTestWatcher'
-  >
-> & { numberOfAccounts?: number };
+export type TrackedSequencerEvent = {
+  [K in keyof SequencerEvents]: Parameters<SequencerEvents[K]>[0] & {
+    type: K;
+    sequencerIndex: number;
+    validator: EthAddress;
+  };
+}[keyof SequencerEvents];
 
 /**
  * Tests building of epochs using fast block times and short epochs.
@@ -89,7 +87,9 @@ export class EpochsTestContext {
   }
 
   public static getSlotDurations(opts: EpochsTestOpts = {}) {
-    const envEthereumSlotDuration = process.env.L1_BLOCK_TIME ? parseInt(process.env.L1_BLOCK_TIME) : 8;
+    const envEthereumSlotDuration = process.env.L1_BLOCK_TIME
+      ? parseInt(process.env.L1_BLOCK_TIME)
+      : DEFAULT_L1_BLOCK_TIME;
     const ethereumSlotDuration = opts.ethereumSlotDuration ?? envEthereumSlotDuration;
     const aztecSlotDuration = opts.aztecSlotDuration ?? ethereumSlotDuration * 2;
     const aztecEpochDuration = opts.aztecEpochDuration ?? 4;
@@ -141,7 +141,7 @@ export class EpochsTestContext {
     this.rollup = RollupContract.getFromConfig(context.config);
 
     // Loop that tracks L1 and L2 block numbers and logs whenever there's a new one.
-    this.monitor = new ChainMonitor(this.rollup, this.logger).start();
+    this.monitor = new ChainMonitor(this.rollup, context.dateProvider, this.logger).start();
 
     // This is hideous.
     // We ought to have a definite reference to the l1TxUtils that we're using in both places, provided by the test context.
@@ -192,6 +192,8 @@ export class EpochsTestContext {
         { ...this.context.config, proverId: Fr.fromString(suffix) },
         { dataDirectory: join(this.context.config.dataDirectory!, randomBytes(8).toString('hex')) },
         this.context.aztecNode,
+        undefined,
+        { dateProvider: this.context.dateProvider },
       ),
     );
     this.proverNodes.push(proverNode);
@@ -205,13 +207,15 @@ export class EpochsTestContext {
 
   public createValidatorNode(
     privateKeys: `0x${string}`[],
-    opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {},
+    opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
   ) {
     this.logger.warn('Creating and syncing a validator node...');
     return this.createNode({ ...opts, disableValidator: false, validatorPrivateKeys: new SecretValue(privateKeys) });
   }
 
-  private async createNode(opts: Partial<AztecNodeConfig> & { dontStartSequencer?: boolean } = {}) {
+  private async createNode(
+    opts: Partial<AztecNodeConfig> & { txDelayerMaxInclusionTimeIntoSlot?: number; dontStartSequencer?: boolean } = {},
+  ) {
     const suffix = (this.nodes.length + 1).toString();
     const { mockGossipSubNetwork } = this.context;
     const resolvedConfig = { ...this.context.config, ...opts };
@@ -238,6 +242,21 @@ export class EpochsTestContext {
         },
       ),
     );
+
+    // REFACTOR: We're getting too much into the internals of the sequencer here.
+    // We should have a single method for constructing an aztec node that returns a TestAztecNodeService
+    // which directly exposes the delayer and sets any test config.
+    if (opts.txDelayerMaxInclusionTimeIntoSlot !== undefined) {
+      this.logger.info(
+        `Setting tx delayer max inclusion time into slot to ${opts.txDelayerMaxInclusionTimeIntoSlot} seconds`,
+      );
+      const sequencer = node.getSequencer() as TestSequencerClient;
+      const publisher = sequencer.sequencer.publisher;
+      const delayed = DelayedTxUtils.fromL1TxUtils(publisher.l1TxUtils, this.L1_BLOCK_TIME_IN_S);
+      delayed.delayer!.setMaxInclusionTimeIntoSlot(opts.txDelayerMaxInclusionTimeIntoSlot);
+      publisher.l1TxUtils = delayed;
+    }
+
     this.nodes.push(node);
     return node;
   }
@@ -310,7 +329,7 @@ export class EpochsTestContext {
 
   /** Registers the SpamContract on the given wallet. */
   public async registerSpamContract(wallet: Wallet, salt = Fr.ZERO) {
-    const instance = await getContractInstanceFromDeployParams(SpamContract.artifact, {
+    const instance = await getContractInstanceFromInstantiationParams(SpamContract.artifact, {
       constructorArgs: [],
       constructorArtifact: undefined,
       salt,
@@ -329,6 +348,7 @@ export class EpochsTestContext {
         privateKeyToAccount(this.getNextPrivateKey()),
         this.l1Client.chain,
       ),
+      this.context.dateProvider!,
       { ethereumSlotDuration: this.L1_BLOCK_TIME_IN_S },
     );
     expect(await client.getBalance({ address: client.account.address })).toBeGreaterThan(0n);
@@ -346,4 +366,56 @@ export class EpochsTestContext {
       .catch(_ => false);
     expect(result).toBe(expectedSuccess);
   }
+
+  public watchSequencerEvents(
+    sequencers: SequencerClient[],
+    getMetadata: (i: number) => Record<string, any> = () => ({}),
+  ) {
+    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
+    // due to lack of txs available.
+    const failEventsKeys: (keyof SequencerEvents)[] = [
+      'block-build-failed',
+      'block-publish-failed',
+      'proposer-rollup-check-failed',
+    ];
+
+    const makeEvent = (
+      i: number,
+      eventName: keyof SequencerEvents,
+      args: Parameters<SequencerEvents[keyof SequencerEvents]>[0],
+    ) =>
+      ({
+        ...args,
+        type: eventName,
+        sequencerIndex: i + 2,
+        ...getMetadata(i),
+      }) as TrackedSequencerEvent;
+
+    sequencers.forEach((sequencer, i) => {
+      const sequencerIndex = i + 2;
+      sequencer.getSequencer().on('state-changed', (args: Parameters<SequencerEvents['state-changed']>[0]) => {
+        const noisyStates = [SequencerState.IDLE, SequencerState.PROPOSER_CHECK, SequencerState.SYNCHRONIZING];
+        if (!noisyStates.includes(args.newState)) {
+          const evt = makeEvent(i, 'state-changed', args);
+          stateChanges.push(evt);
+          this.logger.verbose(
+            `Sequencer ${sequencerIndex} transitioned from state ${args.oldState} to state ${args.newState}`,
+            evt,
+          );
+        }
+      });
+      failEventsKeys.forEach(eventName => {
+        sequencer.getSequencer().on(eventName, (args: Parameters<SequencerEvents[typeof eventName]>[0]) => {
+          const evt = makeEvent(i, eventName, args);
+          failEvents.push(evt);
+          this.logger.error(`Failed event ${eventName} from sequencer ${sequencerIndex}`, evt);
+        });
+      });
+    });
+
+    return { failEvents, stateChanges };
+  }
 }

package/src/e2e_fees/bridging_race.notest.ts

@@ -67,7 +67,7 @@ describe('e2e_fees bridging_race', () => {
     const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
     const claim = await t.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, bobsAddress);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await t.feeJuiceContract.methods.claim(bobsAddress, amount, secret, index).send().wait();
+    await t.feeJuiceContract.methods.claim(bobsAddress, amount, secret, index).send({ from: bobsAddress }).wait();
     const [balance] = await t.getGasBalanceFn(bobsAddress);
     expect(balance).toEqual(amount);
   });