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

package/src/e2e_fees/fees_test.ts

@@ -8,15 +8,9 @@ import {
   createLogger,
   sleep,
 } from '@aztec/aztec.js';
-import { CheatCodes } from '@aztec/aztec.js/testing';
+import { CheatCodes } from '@aztec/aztec/testing';
 import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
-import {
-  type DeployL1ContractsArgs,
-  RollupContract,
-  createExtendedL1Client,
-  getPublicClient,
-  l1Artifacts,
-} from '@aztec/ethereum';
+import { type DeployL1ContractsArgs, RollupContract, createExtendedL1Client } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
@@ -43,7 +37,7 @@ import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import {
   type BalancesFn,
   type SetupOptions,
-  ensureAccountsPubliclyDeployed,
+  ensureAccountContractsPublished,
   getBalancesFn,
   setupSponsoredFPC,
 } from '../fixtures/utils.js';
@@ -64,6 +58,7 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class FeesTest {
   private snapshotManager: ISnapshotManager;
   private wallets: AccountWallet[] = [];
+  private accounts: AztecAddress[] = [];
 
   public logger: Logger;
   public pxe!: PXE;
@@ -81,6 +76,8 @@ export class FeesTest {
 
   public gasSettings!: GasSettings;
 
+  public rollupContract!: RollupContract;
+
   public feeJuiceContract!: FeeJuiceContract;
   public bananaCoin!: BananaCoin;
   public bananaFPC!: FPCContract;
@@ -124,8 +121,8 @@ export class FeesTest {
     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();
+    this.rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
+    this.chainMonitor = new ChainMonitor(this.rollupContract, context.dateProvider, this.logger, 200).start();
 
     return this;
   }
@@ -147,16 +144,10 @@ export class FeesTest {
   }
 
   async getBlockRewards() {
-    const rewardDistributor = getContract({
-      address: this.context.deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(),
-      abi: l1Artifacts.rewardDistributor.contractAbi,
-      client: this.context.deployL1ContractsValues.l1Client,
-    });
-
-    const blockReward = await rewardDistributor.read.BLOCK_REWARD();
+    const blockReward = await this.rollupContract.getBlockReward();
 
     const balance = await this.feeJuiceBridgeTestHarness.getL1FeeJuiceBalance(
-      EthAddress.fromString(rewardDistributor.address),
+      this.context.deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress,
     );
 
     const toDistribute = balance > blockReward ? blockReward : balance;
@@ -166,19 +157,23 @@ export class FeesTest {
     return { sequencerBlockRewards, proverBlockRewards };
   }
 
-  async mintAndBridgeFeeJuice(address: AztecAddress, amount: bigint) {
-    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, address);
+  async mintAndBridgeFeeJuice(minter: AztecAddress, recipient: AztecAddress, amount: bigint) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, recipient);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await this.feeJuiceContract.methods.claim(address, amount, secret, index).send().wait();
+    await this.feeJuiceContract.methods.claim(recipient, amount, secret, index).send({ from: minter }).wait();
   }
 
   /** Alice 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();
+    const balanceBefore = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: this.aliceAddress });
 
-    await mintTokensToPrivate(this.bananaCoin, this.aliceWallet, address, amount);
+    await mintTokensToPrivate(this.bananaCoin, this.aliceAddress, this.aliceWallet, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate();
+    const balanceAfter = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: this.aliceAddress });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -201,8 +196,9 @@ export class FeesTest {
         this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, 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.accounts = this.wallets.map(w => w.getAddress());
         [this.aliceWallet, this.bobWallet] = this.wallets.slice(0, 2);
-        [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.wallets.map(w => w.getAddress());
+        [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.accounts;
 
         // We set Alice as the FPC admin to avoid the need for deployment of another account.
         this.fpcAdmin = this.aliceAddress;
@@ -216,7 +212,7 @@ export class FeesTest {
 
   async applyPublicDeployAccountsSnapshot() {
     await this.snapshotManager.snapshot('public_deploy_accounts', () =>
-      ensureAccountsPubliclyDeployed(this.aliceWallet, this.wallets),
+      ensureAccountContractsPublished(this.aliceWallet, this.wallets),
     );
   }
 
@@ -229,7 +225,12 @@ export class FeesTest {
 
         this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.aliceWallet);
 
-        this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
+        this.getGasBalanceFn = getBalancesFn(
+          '⛽',
+          this.feeJuiceContract.methods.balance_of_public,
+          this.aliceAddress,
+          this.logger,
+        );
 
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: context.aztecNode,
@@ -248,7 +249,7 @@ export class FeesTest {
       'deploy_banana_token',
       async () => {
         const bananaCoin = await BananaCoin.deploy(this.aliceWallet, this.aliceAddress, 'BC', 'BC', 18n)
-          .send()
+          .send({ from: this.aliceAddress })
           .deployed();
         this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
         return { bananaCoinAddress: bananaCoin.address };
@@ -256,10 +257,16 @@ export class FeesTest {
       async ({ bananaCoinAddress }) => {
         this.bananaCoin = await BananaCoin.at(bananaCoinAddress, this.aliceWallet);
         const logger = this.logger;
-        this.getBananaPublicBalanceFn = getBalancesFn('🍌.public', this.bananaCoin.methods.balance_of_public, logger);
+        this.getBananaPublicBalanceFn = getBalancesFn(
+          '🍌.public',
+          this.bananaCoin.methods.balance_of_public,
+          this.aliceAddress,
+          logger,
+        );
         this.getBananaPrivateBalanceFn = getBalancesFn(
           '🍌.private',
           this.bananaCoin.methods.balance_of_private,
+          this.aliceAddress,
           logger,
         );
       },
@@ -271,16 +278,20 @@ export class FeesTest {
       'fpc_setup',
       async context => {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
+        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
         const bananaCoin = this.bananaCoin;
         const bananaFPC = await FPCContract.deploy(this.aliceWallet, bananaCoin.address, this.fpcAdmin)
-          .send()
+          .send({ from: this.aliceAddress })
           .deployed();
 
         this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
-        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(FEE_FUNDING_FOR_TESTER_ACCOUNT, bananaFPC.address);
+        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(
+          FEE_FUNDING_FOR_TESTER_ACCOUNT,
+          bananaFPC.address,
+          this.aliceAddress,
+        );
 
         return {
           bananaFPCAddress: bananaFPC.address,
@@ -304,20 +315,12 @@ export class FeesTest {
         };
 
         this.getCoinbaseSequencerRewards = async () => {
-          const l1Client = createExtendedL1Client(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const rollup = new RollupContract(l1Client, data.rollupAddress);
-          return await rollup.getSequencerRewards(this.coinbase);
+          return await this.rollupContract.getSequencerRewards(this.coinbase);
         };
 
         this.getProverFee = async (blockNumber: number) => {
           const block = await this.pxe.getBlock(blockNumber);
 
-          const publicClient = getPublicClient({
-            l1RpcUrls: context.aztecNodeConfig.l1RpcUrls,
-            l1ChainId: context.aztecNodeConfig.l1ChainId,
-          });
-          const rollup = new RollupContract(publicClient, data.rollupAddress);
-
           // @todo @lherskind As we deal with #13601
           // Right now the value is from `FeeLib.sol`
           const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
@@ -325,15 +328,15 @@ export class FeesTest {
           // We round up
           const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
 
-          const { baseFee } = await rollup.getL1FeesAt(block!.header.globalVariables.timestamp);
+          const { baseFee } = await this.rollupContract.getL1FeesAt(block!.header.globalVariables.timestamp);
           const proverCost =
             mulDiv(
-              mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, await rollup.getEpochDuration()),
+              mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, await this.rollupContract.getEpochDuration()),
               1n,
-              await rollup.getManaTarget(),
-            ) + (await rollup.getProvingCostPerMana());
+              await this.rollupContract.getManaTarget(),
+            ) + (await this.rollupContract.getProvingCostPerMana());
 
-          const price = await rollup.getFeeAssetPerEth();
+          const price = await this.rollupContract.getFeeAssetPerEth();
 
           const mana = block!.header.totalManaUsed.toBigInt();
           return mulDiv(mana * proverCost, price, 10n ** 9n);
@@ -347,7 +350,7 @@ export class FeesTest {
       'sponsored_fpc_setup',
       async context => {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
+        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
         const sponsoredFPC = await setupSponsoredFPC(context.pxe);
         this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
@@ -367,7 +370,10 @@ export class FeesTest {
       'fund_alice',
       async () => {
         await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
-        await this.bananaCoin.methods.mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS).send().wait();
+        await this.bananaCoin.methods
+          .mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS)
+          .send({ from: this.aliceAddress })
+          .wait();
       },
       () => Promise.resolve(),
     );
@@ -382,37 +388,4 @@ export class FeesTest {
       () => Promise.resolve(),
     );
   }
-
-  public async applySetupSubscription() {
-    await this.snapshotManager.snapshot(
-      'setup_subscription',
-      async () => {
-        const counterContract = await CounterContract.deploy(this.bobWallet, 0, this.bobAddress).send().deployed();
-
-        // Deploy subscription contract, that allows subscriptions for SUBSCRIPTION_AMOUNT of bananas
-        const subscriptionContract = await AppSubscriptionContract.deploy(
-          this.bobWallet,
-          counterContract.address,
-          this.bobAddress,
-          this.bananaCoin.address,
-          this.SUBSCRIPTION_AMOUNT,
-          this.APP_SPONSORED_TX_GAS_LIMIT,
-        )
-          .send()
-          .deployed();
-
-        // Mint some Fee Juice to the subscription contract
-        // Could also use bridgeFromL1ToL2 from the harness, but this is more direct
-        await this.mintAndBridgeFeeJuice(subscriptionContract.address, FEE_FUNDING_FOR_TESTER_ACCOUNT);
-        return {
-          counterContractAddress: counterContract.address,
-          subscriptionContractAddress: subscriptionContract.address,
-        };
-      },
-      async ({ counterContractAddress, subscriptionContractAddress }) => {
-        this.counterContract = await CounterContract.at(counterContractAddress, this.bobWallet);
-        this.subscriptionContract = await AppSubscriptionContract.at(subscriptionContractAddress, this.bobWallet);
-      },
-    );
-  }
 }

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -1,5 +1,5 @@
 import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type CompleteAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
+import { type AccountWallet, AztecAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
 import { ChildContract } from '@aztec/noir-test-contracts.js/Child';
 import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
 
@@ -16,8 +16,8 @@ const { E2E_DATA_PATH: dataPath } = process.env;
 export class NestedContractTest {
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
+  wallet!: AccountWallet;
+  defaultAccountAddress!: AztecAddress;
   pxe!: PXE;
 
   parentContract!: ParentContract;
@@ -41,9 +41,10 @@ export class NestedContractTest {
       'accounts',
       deployAccounts(this.numberOfAccounts, this.logger),
       async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = await pxe.getRegisteredAccounts();
-        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)));
+        wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        [this.wallet] = wallets;
+        this.defaultAccountAddress = this.wallet.getAddress();
         this.pxe = pxe;
       },
     );
@@ -53,7 +54,7 @@ export class NestedContractTest {
       async () => {},
       async () => {
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
+        await publicDeployAccounts(this.wallet, [this.defaultAccountAddress]);
       },
     );
   }
@@ -76,13 +77,17 @@ export class NestedContractTest {
     await this.snapshotManager.snapshot(
       'manual',
       async () => {
-        const parentContract = await ParentContract.deploy(this.wallets[0]).send().deployed();
-        const childContract = await ChildContract.deploy(this.wallets[0]).send().deployed();
+        const parentContract = await ParentContract.deploy(this.wallet)
+          .send({ from: this.defaultAccountAddress })
+          .deployed();
+        const childContract = await ChildContract.deploy(this.wallet)
+          .send({ from: this.defaultAccountAddress })
+          .deployed();
         return { parentContractAddress: parentContract.address, childContractAddress: childContract.address };
       },
       async ({ parentContractAddress, childContractAddress }) => {
-        this.parentContract = await ParentContract.at(parentContractAddress, this.wallets[0]);
-        this.childContract = await ChildContract.at(childContractAddress, this.wallets[0]);
+        this.parentContract = await ParentContract.at(parentContractAddress, this.wallet);
+        this.childContract = await ChildContract.at(childContractAddress, this.wallet);
       },
     );
   }

package/src/e2e_p2p/p2p_network.ts

@@ -1,18 +1,20 @@
 import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import { type AccountWalletWithSecretKey, EthAddress } from '@aztec/aztec.js';
+import { type AccountWalletWithSecretKey, AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
 import {
   type ExtendedViemWalletClient,
+  GSEContract,
   L1TxUtils,
+  MultiAdderArtifact,
   type Operator,
   RollupContract,
   type ViemClient,
   deployL1Contract,
   getL1ContractsConfigEnvVars,
-  l1Artifacts,
 } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
+import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RollupAbi, SlashFactoryAbi, SlasherAbi, SlashingProposerAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
@@ -70,6 +72,7 @@ export class P2PNetworkTest {
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
   // The re-execution test needs a wallet and a spam contract
   public wallet?: AccountWalletWithSecretKey;
+  public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
   public bootstrapNode?: BootstrapNode;
@@ -78,8 +81,9 @@ export class P2PNetworkTest {
     testName: string,
     public bootstrapNodeEnr: string,
     public bootNodePort: number,
-    private numberOfNodes: number,
+    public numberOfValidators: number,
     initialValidatorConfig: AztecNodeConfig,
+    public numberOfNodes = 0,
     // If set enable metrics collection
     private metricsPort?: number,
     startProverNode?: boolean,
@@ -90,7 +94,10 @@ export class P2PNetworkTest {
     // Set up the base account and node private keys for the initial network deployment
     this.baseAccountPrivateKey = `0x${getPrivateKeyFromIndex(1)!.toString('hex')}`;
     this.baseAccount = privateKeyToAccount(this.baseAccountPrivateKey);
-    this.attesterPrivateKeys = generatePrivateKeys(ATTESTER_PRIVATE_KEYS_START_INDEX, numberOfNodes);
+    this.attesterPrivateKeys = generatePrivateKeys(
+      ATTESTER_PRIVATE_KEYS_START_INDEX + numberOfNodes,
+      numberOfValidators,
+    );
     this.attesterPublicKeys = this.attesterPrivateKeys.map(privateKey => privateKeyToAccount(privateKey).address);
 
     const zkPassportParams = ZkPassportProofParams.random();
@@ -105,7 +112,7 @@ export class P2PNetworkTest {
         aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
         aztecProofSubmissionEpochs:
           initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
-        aztecTargetCommitteeSize: numberOfNodes,
+        aztecTargetCommitteeSize: numberOfValidators,
         salt: 420,
         metricsPort: metricsPort,
         numberOfInitialFundedAccounts: 2,
@@ -118,7 +125,7 @@ export class P2PNetworkTest {
         aztecSlotDuration: initialValidatorConfig.aztecSlotDuration ?? l1ContractsConfig.aztecSlotDuration,
         aztecProofSubmissionEpochs:
           initialValidatorConfig.aztecProofSubmissionEpochs ?? l1ContractsConfig.aztecProofSubmissionEpochs,
-        aztecTargetCommitteeSize: numberOfNodes,
+        aztecTargetCommitteeSize: numberOfValidators,
         initialValidators: [],
         zkPassportArgs: {
           mockZkPassportVerifier,
@@ -132,6 +139,7 @@ export class P2PNetworkTest {
   static async create({
     testName,
     numberOfNodes,
+    numberOfValidators,
     basePort,
     metricsPort,
     initialConfig,
@@ -140,6 +148,7 @@ export class P2PNetworkTest {
   }: {
     testName: string;
     numberOfNodes: number;
+    numberOfValidators: number;
     basePort?: number;
     metricsPort?: number;
     initialConfig?: Partial<AztecNodeConfig>;
@@ -160,8 +169,9 @@ export class P2PNetworkTest {
       testName,
       bootstrapNodeEnr,
       port,
-      numberOfNodes,
+      numberOfValidators,
       initialValidatorConfig,
+      numberOfNodes,
       metricsPort,
       startProverNode,
       mockZkPassportVerifier,
@@ -192,12 +202,14 @@ export class P2PNetworkTest {
   getValidators() {
     const validators: Operator[] = [];
 
-    for (let i = 0; i < this.numberOfNodes; i++) {
-      const attester = privateKeyToAccount(this.attesterPrivateKeys[i]!);
+    for (let i = 0; i < this.numberOfValidators; i++) {
+      const keyIndex = i;
+      const attester = privateKeyToAccount(this.attesterPrivateKeys[keyIndex]!);
 
       validators.push({
         attester: EthAddress.fromString(attester.address),
         withdrawer: EthAddress.fromString(attester.address),
+        bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
       });
 
       this.logger.info(`Adding attester ${attester.address} as validator`);
@@ -216,7 +228,7 @@ export class P2PNetworkTest {
           client: deployL1ContractsValues.l1Client,
         });
 
-        this.logger.verbose(`Adding ${this.numberOfNodes} validators`);
+        this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
         const stakingAsset = getContract({
           address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
@@ -226,18 +238,18 @@ export class P2PNetworkTest {
 
         const { address: multiAdderAddress } = await deployL1Contract(
           deployL1ContractsValues.l1Client,
-          l1Artifacts.multiAdder.contractAbi,
-          l1Artifacts.multiAdder.contractBytecode,
+          MultiAdderArtifact.contractAbi,
+          MultiAdderArtifact.contractBytecode,
           [rollup.address, deployL1ContractsValues.l1Client.account.address],
         );
 
         const multiAdder = getContract({
           address: multiAdderAddress.toString(),
-          abi: l1Artifacts.multiAdder.contractAbi,
+          abi: MultiAdderArtifact.contractAbi,
           client: deployL1ContractsValues.l1Client,
         });
 
-        const stakeNeeded = l1ContractsConfig.depositAmount * BigInt(this.numberOfNodes);
+        const stakeNeeded = l1ContractsConfig.activationThreshold * BigInt(this.numberOfValidators);
         await Promise.all(
           [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
             deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
@@ -247,16 +259,25 @@ export class P2PNetworkTest {
         const { validators } = this.getValidators();
         this.validators = validators;
 
+        const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
+        if (!gseAddress) {
+          throw new Error('GSE contract not deployed');
+        }
+
+        const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
+
+        const makeValidatorTuples = async (validator: Operator) => {
+          const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
+          return {
+            attester: validator.attester.toString() as `0x${string}`,
+            withdrawer: validator.withdrawer.toString() as `0x${string}`,
+            ...registrationTuple,
+          };
+        };
+        const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+
         await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-          hash: await multiAdder.write.addValidators([
-            this.validators.map(
-              v =>
-                ({
-                  attester: v.attester.toString() as `0x${string}`,
-                  withdrawer: v.withdrawer.toString() as `0x${string}`,
-                }) as const,
-            ),
-          ]),
+          hash: await multiAdder.write.addValidators([validatorTuples]),
         });
 
         const timestamp = await cheatCodes.rollup.advanceToEpoch(2n, { updateDateProvider: dateProvider });
@@ -279,6 +300,7 @@ export class P2PNetworkTest {
         this.deployedAccounts = deployedAccounts;
         const [account] = deployedAccounts;
         this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
+        this.defaultAccountAddress = this.wallet.getAddress();
       },
     );
   }
@@ -291,7 +313,9 @@ export class P2PNetworkTest {
           throw new Error('Call snapshot t.setupAccount before deploying account contract');
         }
 
-        const spamContract = await SpamContract.deploy(this.wallet).send().deployed();
+        const spamContract = await SpamContract.deploy(this.wallet)
+          .send({ from: this.defaultAccountAddress! })
+          .deployed();
         return { contractAddress: spamContract.address };
       },
       async ({ contractAddress }) => {
@@ -305,7 +329,7 @@ export class P2PNetworkTest {
 
   async removeInitialNode() {
     await this.snapshotManager.snapshot(
-      'remove-inital-validator',
+      'remove-initial-validator',
       async ({ deployL1ContractsValues, aztecNode, dateProvider }) => {
         // Send and await a tx to make sure we mine a block for the warp to correctly progress.
         const { receipt } = await this._sendDummyTx(deployL1ContractsValues.l1Client);
@@ -340,7 +364,8 @@ export class P2PNetworkTest {
     const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
     this.prefilledPublicData = prefilledPublicData;
 
-    this.monitor = new ChainMonitor(RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues)).start();
+    const rollupContract = RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues);
+    this.monitor = new ChainMonitor(rollupContract, this.ctx.dateProvider).start();
     this.monitor.on('l1-block', ({ timestamp }) => this.ctx.dateProvider.setTime(Number(timestamp) * 1000));
   }
 

package/src/e2e_p2p/shared.ts

@@ -2,15 +2,16 @@ import { getSchnorrAccount } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
 import {
+  AztecAddress,
   Fr,
   type Logger,
   ProvenTx,
   type SentTx,
   TxStatus,
-  getContractInstanceFromDeployParams,
+  getContractInstanceFromInstantiationParams,
   retryUntil,
 } from '@aztec/aztec.js';
-import type { RollupCheatCodes } from '@aztec/aztec.js/testing';
+import type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { RollupContract, ViemClient } from '@aztec/ethereum';
 import { timesAsync } from '@aztec/foundation/collection';
 import type { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
@@ -28,6 +29,7 @@ import { submitTxsTo } from '../shared/submit-transactions.js';
 // submits a set of transactions to the provided Private eXecution Environment (PXE)
 export const submitComplexTxsTo = async (
   logger: Logger,
+  from: AztecAddress,
   spamContract: SpamContract,
   numTxs: number,
   opts: { callPublic?: boolean } = {},
@@ -37,10 +39,10 @@ export const submitComplexTxsTo = async (
   const seed = 1234n;
   const spamCount = 15;
   for (let i = 0; i < numTxs; i++) {
-    const tx = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic).send();
+    const tx = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic).send({ from });
     const txHash = await tx.getTxHash();
 
-    logger.info(`Tx sent with hash ${txHash}`);
+    logger.info(`Tx sent with hash ${txHash.toString()}`);
     const receipt = await tx.getReceipt();
     expect(receipt).toEqual(
       expect.objectContaining({
@@ -48,7 +50,7 @@ export const submitComplexTxsTo = async (
         error: '',
       }),
     );
-    logger.info(`Receipt received for ${txHash}`);
+    logger.info(`Receipt received for ${txHash.toString()}`);
     txs.push(tx);
   }
   return txs;
@@ -92,13 +94,13 @@ export async function createPXEServiceAndPrepareTransactions(
   await account.register();
   const wallet = await account.getWallet();
 
-  const testContractInstance = await getContractInstanceFromDeployParams(TestContractArtifact, {});
+  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {});
   await wallet.registerContract({ instance: testContractInstance, artifact: TestContractArtifact });
   const contract = await TestContract.at(testContractInstance.address, wallet);
 
   const txs = await timesAsync(numTxs, async () => {
-    const tx = await contract.methods.emit_nullifier(Fr.random()).prove();
-    const txHash = await tx.getTxHash();
+    const tx = await contract.methods.emit_nullifier(Fr.random()).prove({ from: account.getAddress() });
+    const txHash = tx.getTxHash();
     logger.info(`Tx prepared with hash ${txHash}`);
     return tx;
   });
@@ -112,16 +114,16 @@ export async function awaitProposalExecution(
 ) {
   await retryUntil(
     async () => {
-      const events = await slashingProposer.getEvents.ProposalExecuted();
+      const events = await slashingProposer.getEvents.PayloadSubmitted();
       if (events.length === 0) {
         return false;
       }
       const event = events[0];
       const roundNumber = event.args.round;
-      const proposal = event.args.proposal;
-      return roundNumber && proposal;
+      const payload = event.args.payload;
+      return roundNumber && payload;
     },
-    'proposal executed',
+    'payload submitted',
     timeoutSeconds,
     1,
   );