@aztec/end-to-end 3.0.0-nightly.20250908 → 3.0.0-nightly.20250911

package/dest/spartan/setup_test_wallets.js

@@ -1,42 +1,43 @@
-import { getSchnorrAccount, getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
-import { generateSchnorrAccounts, getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import { generateSchnorrAccounts, getDeployedTestAccounts } from '@aztec/accounts/testing';
 import { FeeJuicePaymentMethodWithClaim, Fr, L1FeeJuicePortalManager, SponsoredFeePaymentMethod, createAztecNodeClient, createCompatibleClient, retryUntil } from '@aztec/aztec.js';
 import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { createPXEService } from '@aztec/pxe/server';
+import { TestWallet } from '@aztec/test-wallet';
 import { getACVMConfig } from '../fixtures/get_acvm_config.js';
 import { getBBConfig } from '../fixtures/get_bb_config.js';
 import { getSponsoredFPCAddress, registerSponsoredFPC } from '../fixtures/utils.js';
 const TOKEN_NAME = 'USDC';
 const TOKEN_SYMBOL = 'USD';
 const TOKEN_DECIMALS = 18n;
-export async function setupTestWalletsWithTokens(pxeUrl, mintAmount, logger) {
-    const WALLET_COUNT = 1; // TODO fix this to allow for 16 wallets again
+export async function setupTestAccountsWithTokens(pxeUrl, mintAmount, logger) {
+    const ACCOUNT_COUNT = 1; // TODO fix this to allow for 16 wallets again
     const pxe = await createCompatibleClient(pxeUrl, logger);
-    const [recipientWallet, ...wallets] = (await getDeployedTestAccountsWallets(pxe)).slice(0, WALLET_COUNT + 1);
-    const tokenAdmin = wallets[0];
-    const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
-    const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+    const wallet = new TestWallet(pxe);
+    const [recipientAccount, ...accounts] = (await getDeployedTestAccounts(pxe)).slice(0, ACCOUNT_COUNT + 1);
+    const tokenAdmin = accounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, accounts.map((acc)=>acc.address), tokenAdmin.address, mintAmount, undefined, logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
     return {
         pxe,
-        wallets,
-        tokenAdminWallet,
-        tokenAdminAddress: tokenAdmin.getAddress(),
+        accounts: accounts.map((acc)=>acc.address),
+        wallet,
+        tokenAdminAddress: tokenAdmin.address,
         tokenName: TOKEN_NAME,
         tokenAddress,
-        recipientAddress: recipientWallet.getAddress(),
-        recipientWallet
+        tokenContract,
+        recipientAddress: recipientAccount.address
     };
 }
-export async function deploySponsoredTestWallets(pxe, mintAmount, logger, numberOfFundedWallets = 1) {
+export async function deploySponsoredTestAccounts(pxe, mintAmount, logger, numberOfFundedWallets = 1) {
+    const wallet = new TestWallet(pxe);
     const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
-    const recipientWallet = await getSchnorrWalletWithSecretKey(pxe, recipient.secret, recipient.signingKey, recipient.salt);
-    const fundedAccounts = await Promise.all(funded.map((a)=>getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)));
-    await registerSponsoredFPC(pxe);
-    const wallets = await Promise.all(fundedAccounts.map(async (a)=>{
-        const wallet = await a.getWallet();
+    const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+    const fundedAccounts = await Promise.all(funded.map((a)=>wallet.createSchnorrAccount(a.secret, a.salt)));
+    await registerSponsoredFPC(wallet);
+    await Promise.all(fundedAccounts.map(async (a)=>{
         const paymentMethod = new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
-        await a.deploy({
+        await recipientAccount.deploy({
             fee: {
                 paymentMethod
             }
@@ -44,56 +45,54 @@ export async function deploySponsoredTestWallets(pxe, mintAmount, logger, number
             timeout: 2400
         }); // increase timeout on purpose in order to account for two empty epochs
         logger.info(`Account deployed at ${a.getAddress()}`);
-        return wallet;
     }));
-    const tokenAdmin = wallets[0];
-    const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()), logger);
-    const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+    const tokenAdmin = fundedAccounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, fundedAccounts.map((acc)=>acc.getAddress()), tokenAdmin.getAddress(), mintAmount, new SponsoredFeePaymentMethod(await getSponsoredFPCAddress()), logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
     return {
         pxe,
-        wallets,
+        wallet,
+        accounts: fundedAccounts.map((acc)=>acc.getAddress()),
         tokenAdminAddress: tokenAdmin.getAddress(),
-        tokenAdminWallet,
         tokenName: TOKEN_NAME,
         tokenAddress,
-        recipientWallet,
-        recipientAddress: recipientWallet.getAddress()
+        tokenContract,
+        recipientAddress: recipientAccount.getAddress()
     };
 }
-export async function deployTestWalletWithTokens(pxeUrl, nodeUrl, l1RpcUrls, mnemonicOrPrivateKey, mintAmount, logger, numberOfFundedWallets = 1) {
+export async function deployTestAccountsWithTokens(pxeUrl, nodeUrl, l1RpcUrls, mnemonicOrPrivateKey, mintAmount, logger, numberOfFundedWallets = 1) {
     const pxe = await createCompatibleClient(pxeUrl, logger);
     const node = createAztecNodeClient(nodeUrl);
+    const wallet = new TestWallet(pxe);
     const [recipient, ...funded] = await generateSchnorrAccounts(numberOfFundedWallets + 1);
-    const recipientWallet = await getSchnorrWalletWithSecretKey(pxe, recipient.secret, recipient.signingKey, recipient.salt);
-    const fundedAccounts = await Promise.all(funded.map((a)=>getSchnorrAccount(pxe, a.secret, a.signingKey, a.salt)));
+    const recipientAccount = await wallet.createSchnorrAccount(recipient.secret, recipient.salt);
+    const fundedAccounts = await Promise.all(funded.map((a)=>wallet.createSchnorrAccount(a.secret, a.salt)));
     const claims = await Promise.all(fundedAccounts.map((a)=>bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, pxe, a.getAddress(), undefined, logger)));
     // Progress by 3 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
     await advanceL2Block(node);
     await advanceL2Block(node);
     await advanceL2Block(node);
-    const wallets = await Promise.all(fundedAccounts.map(async (a, i)=>{
-        const wallet = await a.getWallet();
-        const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claims[i]);
+    await Promise.all(fundedAccounts.map(async (a, i)=>{
+        const paymentMethod = new FeeJuicePaymentMethodWithClaim(a.getAddress(), claims[i]);
         await a.deploy({
             fee: {
                 paymentMethod
             }
         }).wait();
         logger.info(`Account deployed at ${a.getAddress()}`);
-        return wallet;
     }));
-    const tokenAdmin = wallets[0];
-    const tokenAddress = await deployTokenAndMint(wallets, tokenAdmin.getAddress(), mintAmount, undefined, logger);
-    const tokenAdminWallet = await TokenContract.at(tokenAddress, tokenAdmin);
+    const tokenAdmin = fundedAccounts[0];
+    const tokenAddress = await deployTokenAndMint(wallet, fundedAccounts.map((acc)=>acc.getAddress()), tokenAdmin.getAddress(), mintAmount, undefined, logger);
+    const tokenContract = await TokenContract.at(tokenAddress, wallet);
     return {
         pxe,
-        wallets,
+        wallet,
+        accounts: fundedAccounts.map((acc)=>acc.getAddress()),
         tokenAdminAddress: tokenAdmin.getAddress(),
-        tokenAdminWallet,
         tokenName: TOKEN_NAME,
         tokenAddress,
-        recipientWallet,
-        recipientAddress: recipientWallet.getAddress()
+        tokenContract,
+        recipientAddress: recipientAccount.getAddress()
     };
 }
 async function bridgeL1FeeJuice(l1RpcUrls, mnemonicOrPrivateKey, pxe, recipient, amount, log) {
@@ -125,9 +124,9 @@ async function advanceL2Block(node, nodeAdmin) {
         });
     }
 }
-async function deployTokenAndMint(wallets, admin, mintAmount, paymentMethod, logger) {
+async function deployTokenAndMint(wallet, accounts, admin, mintAmount, paymentMethod, logger) {
     logger.verbose(`Deploying TokenContract...`);
-    const tokenContract = await TokenContract.deploy(wallets[0], admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS).send({
+    const tokenContract = await TokenContract.deploy(wallet, admin, TOKEN_NAME, TOKEN_SYMBOL, TOKEN_DECIMALS).send({
         from: admin,
         fee: {
             paymentMethod
@@ -136,8 +135,8 @@ async function deployTokenAndMint(wallets, admin, mintAmount, paymentMethod, log
         timeout: 600
     });
     const tokenAddress = tokenContract.address;
-    logger.verbose(`Minting ${mintAmount} public assets to the ${wallets.length} wallets...`);
-    await Promise.all(wallets.map(async (w)=>(await TokenContract.at(tokenAddress, w)).methods.mint_to_public(w.getAddress(), mintAmount).send({
+    logger.verbose(`Minting ${mintAmount} public assets to the ${accounts.length} accounts...`);
+    await Promise.all(accounts.map(async (acc)=>(await TokenContract.at(tokenAddress, wallet)).methods.mint_to_public(acc, mintAmount).send({
             from: admin,
             fee: {
                 paymentMethod
@@ -148,11 +147,16 @@ async function deployTokenAndMint(wallets, admin, mintAmount, paymentMethod, log
     logger.verbose(`Minting complete.`);
     return tokenAddress;
 }
-export async function performTransfers({ testWallets, rounds, transferAmount, logger }) {
-    const recipient = testWallets.recipientWallet.getAddress();
+export async function performTransfers({ testAccounts, rounds, transferAmount, logger, feePaymentMethod }) {
+    const recipient = testAccounts.recipientAddress;
+    // Default to sponsored fee payment if no fee method is provided
+    const defaultFeePaymentMethod = feePaymentMethod || new SponsoredFeePaymentMethod(await getSponsoredFPCAddress());
     for(let i = 0; i < rounds; i++){
-        const txs = testWallets.wallets.map(async (w)=>(await TokenContract.at(testWallets.tokenAddress, w)).methods.transfer_in_public(w.getAddress(), recipient, transferAmount, 0).prove({
-                from: w.getAddress()
+        const txs = testAccounts.accounts.map(async (acc)=>(await TokenContract.at(testAccounts.tokenAddress, testAccounts.wallet)).methods.transfer_in_public(acc, recipient, transferAmount, 0).prove({
+                from: acc,
+                fee: {
+                    paymentMethod: defaultFeePaymentMethod
+                }
             }));
         const provenTxs = await Promise.all(txs);
         await Promise.all(provenTxs.map((t)=>t.send().wait({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/end-to-end",
-  "version": "3.0.0-nightly.20250908",
+  "version": "3.0.0-nightly.20250911",
   "type": "module",
   "exports": "./dest/index.js",
   "inherits": [
@@ -25,41 +25,42 @@
     "formatting": "run -T prettier --check ./src && run -T eslint ./src"
   },
   "dependencies": {
-    "@aztec/accounts": "3.0.0-nightly.20250908",
-    "@aztec/archiver": "3.0.0-nightly.20250908",
-    "@aztec/aztec": "3.0.0-nightly.20250908",
-    "@aztec/aztec-node": "3.0.0-nightly.20250908",
-    "@aztec/aztec.js": "3.0.0-nightly.20250908",
-    "@aztec/bb-prover": "3.0.0-nightly.20250908",
-    "@aztec/blob-lib": "3.0.0-nightly.20250908",
-    "@aztec/blob-sink": "3.0.0-nightly.20250908",
-    "@aztec/bot": "3.0.0-nightly.20250908",
-    "@aztec/cli": "3.0.0-nightly.20250908",
-    "@aztec/constants": "3.0.0-nightly.20250908",
-    "@aztec/entrypoints": "3.0.0-nightly.20250908",
-    "@aztec/epoch-cache": "3.0.0-nightly.20250908",
-    "@aztec/ethereum": "3.0.0-nightly.20250908",
-    "@aztec/foundation": "3.0.0-nightly.20250908",
-    "@aztec/kv-store": "3.0.0-nightly.20250908",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250908",
-    "@aztec/merkle-tree": "3.0.0-nightly.20250908",
-    "@aztec/node-keystore": "3.0.0-nightly.20250908",
-    "@aztec/noir-contracts.js": "3.0.0-nightly.20250908",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250908",
-    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20250908",
-    "@aztec/noir-test-contracts.js": "3.0.0-nightly.20250908",
-    "@aztec/p2p": "3.0.0-nightly.20250908",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20250908",
-    "@aztec/prover-client": "3.0.0-nightly.20250908",
-    "@aztec/prover-node": "3.0.0-nightly.20250908",
-    "@aztec/pxe": "3.0.0-nightly.20250908",
-    "@aztec/sequencer-client": "3.0.0-nightly.20250908",
-    "@aztec/simulator": "3.0.0-nightly.20250908",
-    "@aztec/slasher": "3.0.0-nightly.20250908",
-    "@aztec/stdlib": "3.0.0-nightly.20250908",
-    "@aztec/telemetry-client": "3.0.0-nightly.20250908",
-    "@aztec/validator-client": "3.0.0-nightly.20250908",
-    "@aztec/world-state": "3.0.0-nightly.20250908",
+    "@aztec/accounts": "3.0.0-nightly.20250911",
+    "@aztec/archiver": "3.0.0-nightly.20250911",
+    "@aztec/aztec": "3.0.0-nightly.20250911",
+    "@aztec/aztec-node": "3.0.0-nightly.20250911",
+    "@aztec/aztec.js": "3.0.0-nightly.20250911",
+    "@aztec/bb-prover": "3.0.0-nightly.20250911",
+    "@aztec/blob-lib": "3.0.0-nightly.20250911",
+    "@aztec/blob-sink": "3.0.0-nightly.20250911",
+    "@aztec/bot": "3.0.0-nightly.20250911",
+    "@aztec/cli": "3.0.0-nightly.20250911",
+    "@aztec/constants": "3.0.0-nightly.20250911",
+    "@aztec/entrypoints": "3.0.0-nightly.20250911",
+    "@aztec/epoch-cache": "3.0.0-nightly.20250911",
+    "@aztec/ethereum": "3.0.0-nightly.20250911",
+    "@aztec/foundation": "3.0.0-nightly.20250911",
+    "@aztec/kv-store": "3.0.0-nightly.20250911",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20250911",
+    "@aztec/merkle-tree": "3.0.0-nightly.20250911",
+    "@aztec/node-keystore": "3.0.0-nightly.20250911",
+    "@aztec/noir-contracts.js": "3.0.0-nightly.20250911",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250911",
+    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20250911",
+    "@aztec/noir-test-contracts.js": "3.0.0-nightly.20250911",
+    "@aztec/p2p": "3.0.0-nightly.20250911",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20250911",
+    "@aztec/prover-client": "3.0.0-nightly.20250911",
+    "@aztec/prover-node": "3.0.0-nightly.20250911",
+    "@aztec/pxe": "3.0.0-nightly.20250911",
+    "@aztec/sequencer-client": "3.0.0-nightly.20250911",
+    "@aztec/simulator": "3.0.0-nightly.20250911",
+    "@aztec/slasher": "3.0.0-nightly.20250911",
+    "@aztec/stdlib": "3.0.0-nightly.20250911",
+    "@aztec/telemetry-client": "3.0.0-nightly.20250911",
+    "@aztec/test-wallet": "3.0.0-nightly.20250911",
+    "@aztec/validator-client": "3.0.0-nightly.20250911",
+    "@aztec/world-state": "3.0.0-nightly.20250911",
     "@iarna/toml": "^2.2.5",
     "@jest/globals": "^30.0.0",
     "@noble/curves": "=1.0.0",

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,8 +1,4 @@
-import { EcdsaRAccountContractArtifact, getEcdsaRAccount } from '@aztec/accounts/ecdsa';
-import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWallet } from '@aztec/accounts/schnorr';
 import {
-  type AccountWallet,
-  AccountWalletWithSecretKey,
   AztecAddress,
   type AztecNode,
   FeeJuicePaymentMethod,
@@ -32,6 +28,7 @@ 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 { TestWallet } from '@aztec/test-wallet';
 
 import { MNEMONIC } from '../../fixtures/fixtures.js';
 import {
@@ -53,22 +50,22 @@ import { type ClientFlowsConfig, FULL_FLOWS_CONFIG, KEY_FLOWS_CONFIG } from './c
 const { E2E_DATA_PATH: dataPath, BENCHMARK_CONFIG } = process.env;
 
 export type AccountType = 'ecdsar1' | 'schnorr';
-export type FeePaymentMethodGetter = (wallet: Wallet) => Promise<FeePaymentMethod>;
+export type FeePaymentMethodGetter = (wallet: Wallet, sender: AztecAddress) => Promise<FeePaymentMethod>;
 export type BenchmarkingFeePaymentMethod = 'bridged_fee_juice' | 'private_fpc' | 'sponsored_fpc' | 'fee_juice';
 
 export class ClientFlowsBenchmark {
   private snapshotManager: ISnapshotManager;
 
   public logger: Logger;
-  public pxe!: PXE;
+  private pxe!: PXE;
   public aztecNode!: AztecNode;
   public cheatCodes!: CheatCodes;
   public context!: SubsystemsContext;
   public chainMonitor!: ChainMonitor;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
+  public adminWallet!: TestWallet;
 
   // The admin that aids in the setup of the test
-  public adminWallet!: AccountWallet;
   public adminAddress!: AztecAddress;
 
   // Aztec Node config
@@ -89,8 +86,9 @@ export class ClientFlowsBenchmark {
   // Sponsored FPC contract
   public sponsoredFPC!: SponsoredFPCContract;
 
-  // PXE used by the benchmarking user. It can be set up with client-side proving enabled
-  public userPXE!: PXE;
+  // PXE and Wallet used by the benchmarking user. It can be set up with client-side proving enabled
+  public userWallet!: TestWallet;
+  private userPXE!: PXE;
 
   public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
 
@@ -169,7 +167,7 @@ export class ClientFlowsBenchmark {
       .balance_of_private(address)
       .simulate({ from: this.adminAddress });
 
-    await mintTokensToPrivate(this.bananaCoin, this.adminAddress, this.adminWallet, address, amount);
+    await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
 
     const balanceAfter = await this.bananaCoin.methods
       .balance_of_private(address)
@@ -177,23 +175,20 @@ export class ClientFlowsBenchmark {
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
-  async createBenchmarkingAccountManager(pxe: PXE, type: 'ecdsar1' | 'schnorr') {
-    const benchysSecretKey = Fr.random();
+  createBenchmarkingAccountManager(wallet: TestWallet, type: 'ecdsar1' | 'schnorr') {
+    const benchysSecret = Fr.random();
     const salt = Fr.random();
 
     let benchysPrivateSigningKey;
-    let benchysAccountManager;
     if (type === 'schnorr') {
-      benchysPrivateSigningKey = deriveSigningKey(benchysSecretKey);
-      benchysAccountManager = await getSchnorrAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
+      benchysPrivateSigningKey = deriveSigningKey(benchysSecret);
+      return wallet.createSchnorrAccount(benchysSecret, salt, benchysPrivateSigningKey);
     } else if (type === 'ecdsar1') {
       benchysPrivateSigningKey = randomBytes(32);
-      benchysAccountManager = await getEcdsaRAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
+      return wallet.createECDSARAccount(benchysSecret, salt, benchysPrivateSigningKey);
     } else {
       throw new Error(`Unknown account type: ${type}`);
     }
-    await benchysAccountManager.register();
-    return benchysAccountManager;
   }
 
   public async applyBaseSnapshots() {
@@ -205,18 +200,17 @@ export class ClientFlowsBenchmark {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(2, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
+      async (
+        { deployedAccounts: [{ address: adminAddress }, { address: sequencerAddress }] },
+        { wallet, pxe, aztecNode, aztecNodeConfig },
+      ) => {
         this.pxe = pxe;
-
+        this.adminWallet = wallet;
         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();
+        this.adminAddress = adminAddress;
+        this.sequencerAddress = sequencerAddress;
 
         const canonicalFeeJuice = await getCanonicalFeeJuice();
         this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
@@ -235,6 +229,7 @@ export class ClientFlowsBenchmark {
             prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
           },
         });
+        this.userWallet = new TestWallet(this.userPXE);
       },
     );
   }
@@ -330,7 +325,7 @@ export class ClientFlowsBenchmark {
     );
   }
 
-  public async createCrossChainTestHarness(owner: AccountWallet) {
+  public async createCrossChainTestHarness(owner: AztecAddress) {
     const l1Client = createExtendedL1Client(this.context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
     const underlyingERC20Address = await deployL1Contract(l1Client, TestERC20Abi, TestERC20Bytecode, [
@@ -344,8 +339,8 @@ export class ClientFlowsBenchmark {
       this.aztecNode,
       this.pxe,
       l1Client,
+      this.adminWallet,
       owner,
-      owner.getAddress(),
       this.logger,
       underlyingERC20Address,
     );
@@ -355,26 +350,20 @@ export class ClientFlowsBenchmark {
     return crossChainTestHarness;
   }
 
-  public async createAndFundBenchmarkingWallet(accountType: AccountType) {
-    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.pxe, accountType);
-    const benchysWallet = await benchysAccountManager.getWallet();
+  public async createAndFundBenchmarkingAccountOnUserWallet(accountType: AccountType) {
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.adminWallet, accountType);
+    const benchysAccount = await benchysAccountManager.getAccount();
     const benchysAddress = benchysAccountManager.getAddress();
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
-    const paymentMethod = new FeeJuicePaymentMethodWithClaim(benchysWallet, claim);
+    const paymentMethod = new FeeJuicePaymentMethodWithClaim(benchysAddress, claim);
     await benchysAccountManager.deploy({ fee: { paymentMethod } }).wait();
-    // Register benchy on the user's PXE, where we're going to be interacting from
-    await this.userPXE.registerContract({
-      instance: benchysAccountManager.getInstance(),
-      artifact: accountType === 'ecdsar1' ? EcdsaRAccountContractArtifact : SchnorrAccountContractArtifact,
+    // Register benchy on the user's Wallet, where we're going to be interacting from
+    const accountManager = await this.userWallet.createAccount({
+      secret: benchysAccount.getSecretKey(),
+      salt: new Fr(benchysAccount.salt),
+      contract: benchysAccountManager.getAccountContract(),
     });
-    await this.userPXE.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
-    const entrypoint = await benchysAccountManager.getAccount();
-    return new AccountWalletWithSecretKey(
-      this.userPXE,
-      entrypoint,
-      benchysWallet.getSecretKey(),
-      benchysAccountManager.salt,
-    );
+    return accountManager.getAddress();
   }
 
   public async applyDeployAmmSnapshot() {
@@ -403,20 +392,20 @@ export class ClientFlowsBenchmark {
     );
   }
 
-  public async getBridgedFeeJuicePaymentMethodForWallet(wallet: Wallet) {
-    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(wallet.getAddress());
-    return new FeeJuicePaymentMethodWithClaim(wallet, claim);
+  public async getBridgedFeeJuicePaymentMethodForWallet(_wallet: Wallet, sender: AztecAddress) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(sender);
+    return new FeeJuicePaymentMethodWithClaim(sender, claim);
   }
 
-  public getPrivateFPCPaymentMethodForWallet(wallet: Wallet) {
-    return Promise.resolve(new PrivateFeePaymentMethod(this.bananaFPC.address, wallet));
+  public getPrivateFPCPaymentMethodForWallet(wallet: Wallet, sender: AztecAddress) {
+    return Promise.resolve(new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet));
   }
 
-  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet) {
+  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet, _sender: AztecAddress) {
     return Promise.resolve(new SponsoredFeePaymentMethod(this.sponsoredFPC.address));
   }
 
-  public getFeeJuicePaymentMethodForWallet(wallet: Wallet) {
-    return Promise.resolve(new FeeJuicePaymentMethod(wallet.getAddress()));
+  public getFeeJuicePaymentMethodForWallet(_wallet: Wallet, sender: AztecAddress) {
+    return Promise.resolve(new FeeJuicePaymentMethod(sender));
   }
 }

package/src/bench/utils.ts

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