@aztec/end-to-end 3.0.0-nightly.20250910 → 3.0.0-nightly.20250912

package/src/e2e_p2p/p2p_network.ts

@@ -1,7 +1,6 @@
-import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import { type AccountWalletWithSecretKey, AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
+import { AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
 import {
   type EmpireSlashingProposerContract,
   type ExtendedViemWalletClient,
@@ -26,6 +25,7 @@ import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
+import type { TestWallet } from '@aztec/test-wallet';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
@@ -75,7 +75,7 @@ export class P2PNetworkTest {
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
 
   // The re-execution test needs a wallet and a spam contract
-  public wallet?: AccountWalletWithSecretKey;
+  public wallet?: TestWallet;
   public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
@@ -260,7 +260,7 @@ export class P2PNetworkTest {
           client: deployL1ContractsValues.l1Client,
         });
 
-        const stakeNeeded = l1ContractsConfig.activationThreshold * BigInt(this.numberOfValidators);
+        const stakeNeeded = (await rollup.read.getActivationThreshold()) * BigInt(this.numberOfValidators);
         await Promise.all(
           [await stakingAsset.write.mint([multiAdder.address, stakeNeeded], {} as any)].map(txHash =>
             deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: txHash }),
@@ -291,14 +291,15 @@ export class P2PNetworkTest {
           hash: await multiAdder.write.addValidators([validatorTuples]),
         });
 
-        const timestamp = await cheatCodes.rollup.advanceToEpoch(2n, { updateDateProvider: dateProvider });
+        await cheatCodes.rollup.advanceToEpoch(
+          (await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochs()) + 1n,
+          {
+            updateDateProvider: dateProvider,
+          },
+        );
 
         // Send and await a tx to make sure we mine a block for the warp to correctly progress.
         await this._sendDummyTx(deployL1ContractsValues.l1Client);
-
-        // Set the system time in the node, only after we have warped the time and waited for a block
-        // Time is only set in the NEXT block
-        dateProvider.setTime(Number(timestamp) * 1000);
       },
     );
   }
@@ -306,12 +307,12 @@ export class P2PNetworkTest {
   async setupAccount() {
     await this.snapshotManager.snapshot(
       'setup-account',
-      deployAccounts(1, this.logger, false),
-      async ({ deployedAccounts }, { pxe }) => {
+      deployAccounts(1, this.logger),
+      ({ deployedAccounts }, { wallet }) => {
         this.deployedAccounts = deployedAccounts;
-        const [account] = deployedAccounts;
-        this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
-        this.defaultAccountAddress = this.wallet.getAddress();
+        [{ address: this.defaultAccountAddress }] = deployedAccounts;
+        this.wallet = wallet;
+        return Promise.resolve();
       },
     );
   }
@@ -415,7 +416,7 @@ export class P2PNetworkTest {
     );
 
     const slasherContract = getContract({
-      address: getAddress(await rollup.getSlasher()),
+      address: getAddress(await rollup.getSlasherAddress()),
       abi: SlasherAbi,
       client: this.ctx.deployL1ContractsValues.l1Client,
     });

package/src/e2e_p2p/shared.ts

@@ -1,4 +1,3 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
 import {
@@ -21,6 +20,7 @@ import { PXEService, createPXEService, getPXEServiceConfig as getRpcConfig } fro
 import { getRoundForOffense } from '@aztec/slasher';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import { TestWallet } from '@aztec/test-wallet';
 
 import type { NodeContext } from '../fixtures/setup_p2p_test.js';
 import { submitTxsTo } from '../shared/submit-transactions.js';
@@ -65,17 +65,9 @@ export const createPXEServiceAndSubmitTransactions = async (
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
   const pxeService = await createPXEService(node, rpcConfig, { useLogSuffix: true });
-
-  const account = await getSchnorrAccount(
-    pxeService,
-    fundedAccount.secret,
-    fundedAccount.signingKey,
-    fundedAccount.salt,
-  );
-  await account.register();
-  const wallet = await account.getWallet();
-
-  const txs = await submitTxsTo(pxeService, numTxs, wallet, logger);
+  const wallet = new TestWallet(pxeService);
+  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  const txs = await submitTxsTo(wallet, fundedAccountManager.getAddress(), numTxs, logger);
   return { txs, pxeService, node };
 };
 
@@ -89,16 +81,15 @@ export async function createPXEServiceAndPrepareTransactions(
   rpcConfig.proverEnabled = false;
   const pxe = await createPXEService(node, rpcConfig, { useLogSuffix: true });
 
-  const account = await getSchnorrAccount(pxe, fundedAccount.secret, fundedAccount.signingKey, fundedAccount.salt);
-  await account.register();
-  const wallet = await account.getWallet();
+  const wallet = new TestWallet(pxe);
+  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
 
   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({ from: account.getAddress() });
+    const tx = await contract.methods.emit_nullifier(Fr.random()).prove({ from: fundedAccountManager.getAddress() });
     const txHash = tx.getTxHash();
     logger.info(`Tx prepared with hash ${txHash}`);
     return tx;
@@ -219,8 +210,9 @@ export async function awaitCommitteeKicked({
 
   logger.info(`Advancing epochs so we start slashing`);
   await cheatCodes.debugRollup();
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
+  await cheatCodes.advanceToEpoch((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochs()) + 1n, {
+    updateDateProvider: dateProvider,
+  });
 
   // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
   if (slashingProposer.type === 'empire') {
@@ -265,10 +257,11 @@ export async function awaitCommitteeKicked({
     expect(attesterInfo.status).toEqual(2); // Living
   }
 
-  logger.info(`Advancing two epochs to check current committee`);
+  logger.info(`Advancing to check current committee`);
   await cheatCodes.debugRollup();
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
+  await cheatCodes.advanceToEpoch((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochs()) + 1n, {
+    updateDateProvider: dateProvider,
+  });
   await cheatCodes.debugRollup();
 
   const committeeNextEpoch = await rollup.getCurrentEpochCommittee();

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,5 +1,4 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, AztecAddress, type AztecNode, type Logger, createLogger } from '@aztec/aztec.js';
+import { AztecAddress, type AztecNode, type Logger, type Wallet, createLogger } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 
@@ -28,11 +27,9 @@ export class TokenContractTest {
   node!: AztecNode;
 
   badAccount!: InvalidAccountContract;
-  admin!: AccountWallet;
+  wallet!: Wallet;
   adminAddress!: AztecAddress;
-  account1!: AccountWallet;
   account1Address!: AztecAddress;
-  account2!: AccountWallet;
   account2Address!: AztecAddress;
 
   constructor(testName: string) {
@@ -54,11 +51,11 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode }) => {
+      ({ deployedAccounts }, { wallet, aztecNode }) => {
         this.node = aztecNode;
-        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        [this.admin, this.account1, this.account2] = wallets;
-        [this.adminAddress, this.account1Address, this.account2Address] = wallets.map(w => w.getAddress());
+        this.wallet = wallet;
+        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
+        return Promise.resolve();
       },
     );
 
@@ -68,11 +65,11 @@ export class TokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.admin, [this.adminAddress, this.account1Address]);
+        await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.admin,
+          this.wallet,
           this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
@@ -83,22 +80,22 @@ export class TokenContractTest {
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.admin);
+        this.asset = await TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(this.asset, this.admin, this.adminAddress, this.logger, [
+        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
           this.adminAddress,
           this.account1Address,
         ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.admin);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
@@ -131,14 +128,14 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, admin, adminAddress } = this;
+        const { asset, adminAddress } = this;
         const amount = 10000n;
 
         this.logger.verbose(`Minting ${amount} publicly...`);
         await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, adminAddress, admin, adminAddress, amount);
+        await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };

package/src/fixtures/e2e_prover_test.ts

@@ -1,19 +1,6 @@
-import {
-  SchnorrAccountContractArtifact,
-  getSchnorrAccount,
-  getSchnorrWalletWithSecretKey,
-} from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
-import {
-  type AccountWalletWithSecretKey,
-  type AztecNode,
-  type CompleteAddress,
-  EthAddress,
-  type Logger,
-  type PXE,
-  createLogger,
-} from '@aztec/aztec.js';
+import { AztecAddress, type AztecNode, EthAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
 import { CheatCodes } from '@aztec/aztec/testing';
 import {
   BBCircuitVerifier,
@@ -31,6 +18,7 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { type ProverNode, type ProverNodeConfig, createProverNode } from '@aztec/prover-node';
 import type { PXEService } from '@aztec/pxe/server';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { TestWallet } from '@aztec/test-wallet';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type Hex, getContract } from 'viem';
@@ -68,9 +56,9 @@ export class FullProverTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  deployedAccounts: InitialAccountData[] = [];
-  wallets: AccountWalletWithSecretKey[] = [];
-  accounts: CompleteAddress[] = [];
+  wallet!: TestWallet;
+  accounts: AztecAddress[] = [];
+  deployedAccounts!: InitialAccountData[];
   fakeProofsAsset!: TokenContract;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
@@ -115,13 +103,11 @@ export class FullProverTest {
     await this.snapshotManager.snapshot(
       '2_accounts',
       deployAccounts(2, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
+      ({ deployedAccounts }, { wallet }) => {
         this.deployedAccounts = deployedAccounts;
-        this.wallets = await Promise.all(
-          deployedAccounts.map(a => getSchnorrWalletWithSecretKey(pxe, a.secret, a.signingKey, a.salt)),
-        );
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        this.accounts = deployedAccounts.map(a => a.address);
+        this.wallet = wallet;
+        return Promise.resolve();
       },
     );
 
@@ -131,17 +117,17 @@ export class FullProverTest {
         // 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, 2));
+        await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallets[0],
+          this.wallet,
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send({ from: this.wallets[0].getAddress() })
+          .send({ from: this.accounts[0] })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
@@ -149,19 +135,19 @@ export class FullProverTest {
       },
       async ({ tokenContractAddress }) => {
         // Restore the token contract state.
-        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
-          this.wallets[0],
-          this.wallets[0].getAddress(),
+          this.wallet,
+          this.accounts[0],
           this.logger,
-          this.accounts.map(a => a.address),
+          this.accounts,
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0].address })).toBe(
-          this.accounts[0].address.toBigInt(),
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
+          this.accounts[0].toBigInt(),
         );
       },
     );
@@ -238,30 +224,13 @@ export class FullProverTest {
       this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
       await result.pxe.registerContract(this.fakeProofsAsset);
 
+      const provenWallet = new TestWallet(result.pxe);
+
       for (let i = 0; i < 2; i++) {
-        await result.pxe.registerAccount(
-          this.deployedAccounts[i].secret,
-          this.wallets[i].getCompleteAddress().partialAddress,
-        );
-        await this.pxe.registerAccount(
-          this.deployedAccounts[i].secret,
-          this.wallets[i].getCompleteAddress().partialAddress,
-        );
+        await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
+        await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
       }
 
-      const account = await getSchnorrAccount(
-        result.pxe,
-        this.deployedAccounts[0].secret,
-        this.deployedAccounts[0].signingKey,
-        this.deployedAccounts[0].salt,
-      );
-
-      await result.pxe.registerContract({
-        instance: account.getInstance(),
-        artifact: SchnorrAccountContractArtifact,
-      });
-
-      const provenWallet = await account.getWallet();
       const asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
       this.provenComponents.push({
         pxe: result.pxe,
@@ -368,15 +337,12 @@ export class FullProverTest {
 
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
-          .mint_to_public(accounts[0].address, privateAmount + publicAmount)
-          .send({ from: accounts[0].address })
+          .mint_to_public(accounts[0], privateAmount + publicAmount)
+          .send({ from: accounts[0] })
           .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods
-          .transfer_to_private(accounts[0].address, privateAmount)
-          .send({ from: accounts[0].address })
-          .wait();
+        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] }).wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -385,7 +351,7 @@ export class FullProverTest {
       async ({ amount }) => {
         const {
           fakeProofsAsset: asset,
-          accounts: [{ address }],
+          accounts: [address],
           tokenSim,
         } = this;
         tokenSim.mintPublic(address, amount);

package/src/fixtures/snapshot_manager.ts

@@ -1,13 +1,11 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, deployFundedSchnorrAccounts, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
 import {
   type AztecAddress,
   type AztecNode,
   BatchCall,
-  type CompleteAddress,
   type ContractFunctionInteraction,
-  DefaultWaitForProvenOpts,
   EthAddress,
   type Logger,
   type PXE,
@@ -38,6 +36,7 @@ import { type PXEService, createPXEService, getPXEServiceConfig } from '@aztec/p
 import type { SequencerClient } from '@aztec/sequencer-client';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
+import { TestWallet } from '@aztec/test-wallet';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import type { Anvil } from '@viem/anvil';
@@ -71,6 +70,7 @@ export type SubsystemsContext = {
   aztecNode: AztecNodeService;
   aztecNodeConfig: AztecNodeConfig;
   pxe: PXEService;
+  wallet: TestWallet;
   deployL1ContractsValues: DeployL1ContractsReturnType;
   proverNode?: ProverNode;
   watcher: AnvilTestWatcher;
@@ -444,7 +444,7 @@ async function setupFromFresh(
   // Only enable proving if specifically requested.
   pxeConfig.proverEnabled = !!opts.realProofs;
   const pxe = await createPXEService(aztecNode, pxeConfig);
-
+  const wallet = new TestWallet(pxe);
   const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
 
   if (statePath) {
@@ -457,6 +457,7 @@ async function setupFromFresh(
     anvil,
     aztecNode,
     pxe,
+    wallet,
     sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
@@ -568,7 +569,7 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   const pxeConfig = getPXEServiceConfig();
   pxeConfig.dataDirectory = statePath;
   const pxe = await createPXEService(aztecNode, pxeConfig);
-
+  const wallet = new TestWallet(pxe);
   const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
 
   return {
@@ -576,6 +577,7 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     anvil,
     aztecNode,
     pxe,
+    wallet,
     sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
@@ -599,20 +601,27 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
  * The 'restore' function is not provided, as it must be a closure within the test context to capture the results.
  */
 export const deployAccounts =
-  (numberOfAccounts: number, logger: Logger, waitUntilProven = false) =>
-  async ({ pxe, initialFundedAccounts }: { pxe: PXE; initialFundedAccounts: InitialAccountData[] }) => {
+  (numberOfAccounts: number, logger: Logger) =>
+  async ({ wallet, initialFundedAccounts }: { wallet: TestWallet; initialFundedAccounts: InitialAccountData[] }) => {
     if (initialFundedAccounts.length < numberOfAccounts) {
       throw new Error(`Cannot deploy more than ${initialFundedAccounts.length} initial accounts.`);
     }
 
     logger.verbose('Deploying accounts funded with fee juice...');
     const deployedAccounts = initialFundedAccounts.slice(0, numberOfAccounts);
-    await deployFundedSchnorrAccounts(
-      pxe,
-      deployedAccounts,
-      undefined,
-      waitUntilProven ? DefaultWaitForProvenOpts : undefined,
-    );
+    // Serial due to https://github.com/AztecProtocol/aztec-packages/issues/12045
+    for (let i = 0; i < deployedAccounts.length; i++) {
+      const accountManager = await wallet.createSchnorrAccount(
+        deployedAccounts[i].secret,
+        deployedAccounts[i].salt,
+        deployedAccounts[i].signingKey,
+      );
+      await accountManager
+        .deploy({
+          skipClassPublication: i !== 0, // Publish the contract class at most once.
+        })
+        .wait();
+    }
 
     return { deployedAccounts };
   };
@@ -626,27 +635,26 @@ export const deployAccounts =
  * @param pxeOrNode - PXE or AztecNode to wait for proven.
  */
 export async function publicDeployAccounts(
-  sender: Wallet,
-  accountsToDeploy: (CompleteAddress | AztecAddress)[],
+  wallet: Wallet,
+  accountsToDeploy: AztecAddress[],
   waitUntilProven = false,
   pxeOrNode?: PXE | AztecNode,
 ) {
-  const accountAddressesToDeploy = accountsToDeploy.map(a => ('address' in a ? a.address : a));
-  const instances = (
-    await Promise.all(accountAddressesToDeploy.map(account => sender.getContractMetadata(account)))
-  ).map(metadata => metadata.contractInstance);
+  const instances = (await Promise.all(accountsToDeploy.map(account => wallet.getContractMetadata(account)))).map(
+    metadata => metadata.contractInstance,
+  );
 
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
+  const alreadyRegistered = (await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
 
   const calls: ContractFunctionInteraction[] = await Promise.all([
-    ...(!alreadyRegistered ? [publishContractClass(sender, SchnorrAccountContractArtifact)] : []),
-    ...instances.map(instance => publishInstance(sender, instance!)),
+    ...(!alreadyRegistered ? [publishContractClass(wallet, SchnorrAccountContractArtifact)] : []),
+    ...instances.map(instance => publishInstance(wallet, instance!)),
   ]);
 
-  const batch = new BatchCall(sender, calls);
+  const batch = new BatchCall(wallet, calls);
 
-  const txReceipt = await batch.send({ from: accountAddressesToDeploy[0] }).wait();
+  const txReceipt = await batch.send({ from: accountsToDeploy[0] }).wait();
   if (waitUntilProven) {
     if (!pxeOrNode) {
       throw new Error('Need to provide a PXE or AztecNode to wait for proven.');

package/src/fixtures/token_utils.ts

@@ -3,20 +3,14 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 // docs:start:token_utils
 
-export async function deployToken(
-  adminWallet: Wallet,
-  deployerAddress: AztecAddress,
-  initialAdminBalance: bigint,
-  logger: Logger,
-) {
+export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(adminWallet, deployerAddress, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: deployerAddress })
+  const contract = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: admin })
     .deployed();
 
   if (initialAdminBalance > 0n) {
-    // Minter is minting to herself so contract as minter is the same as contract as recipient
-    await mintTokensToPrivate(contract, deployerAddress, adminWallet, deployerAddress, initialAdminBalance);
+    await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
   }
 
   logger.info('L2 contract deployed');
@@ -27,12 +21,10 @@ export async function deployToken(
 export async function mintTokensToPrivate(
   token: TokenContract,
   minter: AztecAddress,
-  minterWallet: Wallet,
   recipient: AztecAddress,
   amount: bigint,
 ) {
-  const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
-  await tokenAsMinter.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
+  await token.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
 }
 // docs:end:token_utils
 
@@ -51,7 +43,7 @@ export async function expectTokenBalance(
 }
 
 export async function mintNotes(
-  sender: Wallet,
+  wallet: Wallet,
   minter: AztecAddress,
   recipient: AztecAddress,
   asset: TokenContract,
@@ -63,7 +55,7 @@ export async function mintNotes(
   for (let mintedNotes = 0; mintedNotes < noteAmounts.length; mintedNotes += notesPerIteration) {
     const toMint = noteAmounts.slice(mintedNotes, mintedNotes + notesPerIteration);
     const actions = toMint.map(amt => asset.methods.mint_to_private(recipient, amt));
-    await new BatchCall(sender, actions).send({ from: minter }).wait();
+    await new BatchCall(wallet, actions).send({ from: minter }).wait();
   }
 
   return noteAmounts.reduce((prev, curr) => prev + curr, 0n);