@aztec/end-to-end 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/src/fixtures/e2e_prover_test.ts

@@ -1,8 +1,19 @@
+import {
+  SchnorrAccountContractArtifact,
+  getSchnorrAccount,
+  getSchnorrWalletWithSecretKey,
+} from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
-import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
+import {
+  type AccountWalletWithSecretKey,
+  type AztecNode,
+  type CompleteAddress,
+  EthAddress,
+  type Logger,
+  type PXE,
+  createLogger,
+} from '@aztec/aztec.js';
 import { CheatCodes } from '@aztec/aztec/testing';
 import {
   BBCircuitVerifier,
@@ -18,8 +29,8 @@ import { SecretValue } from '@aztec/foundation/config';
 import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts';
 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/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { type Hex, getContract } from 'viem';
@@ -35,12 +46,12 @@ import {
   deployAccounts,
   publicDeployAccounts,
 } from './snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEAndGetWallet } from './utils.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEService } from './utils.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
 
 type ProvenSetup = {
-  wallet: TestWallet;
+  pxe: PXE;
   teardown: () => Promise<void>;
 };
 
@@ -57,21 +68,21 @@ export class FullProverTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallet!: TestWallet;
-  provenWallet!: TestWallet;
-  accounts: AztecAddress[] = [];
-  deployedAccounts!: InitialAccountData[];
+  deployedAccounts: InitialAccountData[] = [];
+  wallets: AccountWalletWithSecretKey[] = [];
+  accounts: CompleteAddress[] = [];
   fakeProofsAsset!: TokenContract;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
   aztecNodeAdmin!: AztecNodeAdmin;
+  pxe!: PXEService;
   cheatCodes!: CheatCodes;
   blobSink!: BlobSinkServer;
   private provenComponents: ProvenSetup[] = [];
   private bbConfigCleanup?: () => Promise<void>;
   private acvmConfigCleanup?: () => Promise<void>;
   circuitProofVerifier?: ClientProtocolCircuitVerifier;
-  provenAsset!: TokenContract;
+  provenAssets: TokenContract[] = [];
   private context!: SubsystemsContext;
   private proverNode!: ProverNode;
   private simulatedProverNode!: ProverNode;
@@ -104,11 +115,13 @@ export class FullProverTest {
     await this.snapshotManager.snapshot(
       '2_accounts',
       deployAccounts(2, this.logger),
-      ({ deployedAccounts }, { wallet }) => {
+      async ({ deployedAccounts }, { pxe }) => {
         this.deployedAccounts = deployedAccounts;
-        this.accounts = deployedAccounts.map(a => a.address);
-        this.wallet = wallet;
-        return Promise.resolve();
+        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()}`));
       },
     );
 
@@ -118,17 +131,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.wallet, this.accounts.slice(0, 2));
+        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallet,
+          this.wallets[0],
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send({ from: this.accounts[0] })
+          .send({ from: this.wallets[0].getAddress() })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
@@ -136,19 +149,19 @@ export class FullProverTest {
       },
       async ({ tokenContractAddress }) => {
         // Restore the token contract state.
-        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallet);
+        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
-          this.wallet,
-          this.accounts[0],
+          this.wallets[0],
+          this.wallets[0].getAddress(),
           this.logger,
-          this.accounts,
+          this.accounts.map(a => a.address),
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
-          this.accounts[0].toBigInt(),
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0].address })).toBe(
+          this.accounts[0].address.toBigInt(),
         );
       },
     );
@@ -162,6 +175,7 @@ export class FullProverTest {
 
     this.simulatedProverNode = this.context.proverNode!;
     ({
+      pxe: this.pxe,
       aztecNode: this.aztecNode,
       deployL1ContractsValues: this.l1Contracts,
       cheatCodes: this.cheatCodes,
@@ -210,31 +224,51 @@ export class FullProverTest {
     await this.context.cheatCodes.rollup.markAsProven();
 
     this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
-    const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(
-      this.aztecNode,
-      {
-        proverEnabled: this.realProofs,
-        bbBinaryPath: bbConfig?.bbBinaryPath,
-        bbWorkingDirectory: bbConfig?.bbWorkingDirectory,
-      },
-      undefined,
-      true,
-    );
-    this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
-    await provenWallet.registerContract(this.fakeProofsAsset);
-
     for (let i = 0; i < 2; i++) {
-      await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
-      await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
-    }
+      const result = await setupPXEService(
+        this.aztecNode,
+        {
+          proverEnabled: this.realProofs,
+          bbBinaryPath: bbConfig?.bbBinaryPath,
+          bbWorkingDirectory: bbConfig?.bbWorkingDirectory,
+        },
+        undefined,
+        true,
+      );
+      this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
+      await result.pxe.registerContract(this.fakeProofsAsset);
+
+      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,
+        );
+      }
+
+      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 asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
-    this.provenComponents.push({
-      wallet: provenWallet,
-      teardown: provenTeardown,
-    });
-    this.provenAsset = asset;
-    this.provenWallet = provenWallet;
+      const provenWallet = await account.getWallet();
+      const asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
+      this.provenComponents.push({
+        pxe: result.pxe,
+        teardown: result.teardown,
+      });
+      this.provenAssets.push(asset);
+    }
     this.logger.info(`Full prover PXE started`);
 
     // Shutdown the current, simulated prover node
@@ -335,12 +369,15 @@ export class FullProverTest {
 
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
-          .mint_to_public(accounts[0], privateAmount + publicAmount)
-          .send({ from: accounts[0] })
+          .mint_to_public(accounts[0].address, privateAmount + publicAmount)
+          .send({ from: accounts[0].address })
           .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] }).wait();
+        await asset.methods
+          .transfer_to_private(accounts[0].address, privateAmount)
+          .send({ from: accounts[0].address })
+          .wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -349,7 +386,7 @@ export class FullProverTest {
       async ({ amount }) => {
         const {
           fakeProofsAsset: asset,
-          accounts: [address],
+          accounts: [{ address }],
           tokenSim,
         } = this;
         tokenSim.mintPublic(address, amount);

package/src/fixtures/get_acvm_config.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/aztec.js';
 import { parseBooleanEnv } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { tryRmDir } from '@aztec/foundation/fs';

package/src/fixtures/get_bb_config.ts

@@ -1,11 +1,10 @@
-import type { Logger } from '@aztec/aztec.js/log';
+import { type Logger, fileURLToPath } from '@aztec/aztec.js';
 import type { BBConfig } from '@aztec/bb-prover';
 import { tryRmDir } from '@aztec/foundation/fs';
 
 import fs from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'path';
-import { fileURLToPath } from 'url';
 
 const {
   BB_RELEASE_DIR = 'barretenberg/cpp/build/bin',
@@ -23,7 +22,7 @@ export const getBBConfig = async (
   try {
     const bbBinaryPath =
       BB_BINARY_PATH ??
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb-avm');
+      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb');
     await fs.access(bbBinaryPath, fs.constants.R_OK);
 
     let bbWorkingDirectory: string;

package/src/fixtures/setup_l1_contracts.ts

@@ -1,7 +1,7 @@
-import type { Logger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/aztec.js';
 import { type DeployL1ContractsArgs, type L1ContractsConfig, deployL1Contracts } from '@aztec/ethereum';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 
 import type { HDAccount, PrivateKeyAccount } from 'viem';
 import { foundry } from 'viem/chains';
@@ -16,7 +16,7 @@ export const setupL1Contracts = async (
 ) => {
   const l1Data = await deployL1Contracts([l1RpcUrl], account, foundry, logger, {
     vkTreeRoot: getVKTreeRoot(),
-    protocolContractsHash,
+    protocolContractTreeRoot,
     salt: undefined,
     realVerifier: false,
     ...args,

package/src/fixtures/setup_p2p_test.ts

@@ -2,11 +2,13 @@
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import type { SentTx } from '@aztec/aztec.js';
 import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { ProverNodeConfig, ProverNodeDeps } from '@aztec/prover-node';
+import type { PXEService } from '@aztec/pxe/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 
 import getPort from 'get-port';
@@ -21,6 +23,12 @@ import { getEndToEndTestTelemetryClient } from './with_telemetry_utils.js';
 // to avoid running validators with the same key
 export const ATTESTER_PRIVATE_KEYS_START_INDEX = 3;
 
+export interface NodeContext {
+  node: AztecNodeService;
+  pxeService: PXEService;
+  txs: SentTx[];
+}
+
 export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `0x${string}`[] {
   const privateKeys: `0x${string}`[] = [];
   // Do not start from 0 as it is used during setup

package/src/fixtures/snapshot_manager.ts

@@ -1,13 +1,21 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { type InitialAccountData, generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { type InitialAccountData, deployFundedSchnorrAccounts, generateSchnorrAccounts } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { getContractClassFromArtifact } from '@aztec/aztec.js/contracts';
-import { BatchCall, type ContractFunctionInteraction, waitForProven } from '@aztec/aztec.js/contracts';
+import {
+  type AztecAddress,
+  type AztecNode,
+  BatchCall,
+  type CompleteAddress,
+  type ContractFunctionInteraction,
+  DefaultWaitForProvenOpts,
+  EthAddress,
+  type Logger,
+  type PXE,
+  type Wallet,
+  getContractClassFromArtifact,
+  waitForProven,
+} from '@aztec/aztec.js';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
-import type { Logger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
-import type { Wallet } from '@aztec/aztec.js/wallet';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
 import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
 import {
@@ -26,11 +34,10 @@ import { createLogger } from '@aztec/foundation/log';
 import { resolver, reviver } from '@aztec/foundation/serialize';
 import { TestDateProvider } from '@aztec/foundation/timer';
 import type { ProverNode } from '@aztec/prover-node';
-import { getPXEConfig } from '@aztec/pxe/server';
+import { type PXEService, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
 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/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import type { Anvil } from '@viem/anvil';
@@ -63,7 +70,7 @@ export type SubsystemsContext = {
   bbConfig: any;
   aztecNode: AztecNodeService;
   aztecNodeConfig: AztecNodeConfig;
-  wallet: TestWallet;
+  pxe: PXEService;
   deployL1ContractsValues: DeployL1ContractsReturnType;
   proverNode?: ProverNode;
   watcher: AnvilTestWatcher;
@@ -199,7 +206,7 @@ class SnapshotManager implements ISnapshotManager {
     await restore(snapshotData, context);
 
     // Save the snapshot data.
-    const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls, context.dateProvider);
+    const ethCheatCodes = new EthCheatCodesWithState(context.aztecNodeConfig.l1RpcUrls);
     const anvilStateFile = `${this.livePath}/anvil.dat`;
     await ethCheatCodes.dumpChainState(anvilStateFile);
     writeFileSync(`${this.livePath}/${name}.json`, JSON.stringify(snapshotData || {}, resolver));
@@ -346,9 +353,7 @@ async function setupFromFresh(
   const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
   const anvil = res.anvil;
   aztecNodeConfig.l1RpcUrls = [res.rpcUrl];
-
-  const dateProvider = new TestDateProvider();
-  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
+  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
 
   // Deploy our L1 contracts.
   logger.verbose('Deploying L1 contracts...');
@@ -376,8 +381,10 @@ async function setupFromFresh(
   aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
   aztecNodeConfig.rollupVersion = deployL1ContractsValues.rollupVersion;
 
+  const dateProvider = new TestDateProvider();
+
   const watcher = new AnvilTestWatcher(
-    new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider),
+    new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     deployL1ContractsValues.l1ContractAddresses.rollupAddress,
     deployL1ContractsValues.l1Client,
     dateProvider,
@@ -436,12 +443,13 @@ async function setupFromFresh(
   }
 
   logger.verbose('Creating pxe...');
-  const pxeConfig = getPXEConfig();
+  const pxeConfig = getPXEServiceConfig();
   pxeConfig.dataDirectory = statePath ?? path.join(directoryToCleanup, randomBytes(8).toString('hex'));
   // Only enable proving if specifically requested.
   pxeConfig.proverEnabled = !!opts.realProofs;
-  const wallet = await TestWallet.create(aztecNode, pxeConfig);
-  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
+  const pxe = await createPXEService(aztecNode, pxeConfig);
+
+  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
 
   if (statePath) {
     writeFileSync(`${statePath}/aztec_node_config.json`, JSON.stringify(aztecNodeConfig, resolver));
@@ -452,7 +460,7 @@ async function setupFromFresh(
     aztecNodeConfig,
     anvil,
     aztecNode,
-    wallet,
+    pxe,
     sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
@@ -497,9 +505,7 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   aztecNodeConfig.l1RpcUrls = [rpcUrl];
   // Load anvil state.
   const anvilStateFile = `${statePath}/anvil.dat`;
-
-  const dateProvider = new TestDateProvider();
-  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls, dateProvider);
+  const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
   await ethCheatCodes.loadChainState(anvilStateFile);
 
   // TODO: Encapsulate this in a NativeAcvm impl.
@@ -518,8 +524,9 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   logger.verbose('Creating ETH clients...');
   const l1Client = createExtendedL1Client(aztecNodeConfig.l1RpcUrls, mnemonicToAccount(MNEMONIC));
 
+  const dateProvider = new TestDateProvider();
   const watcher = new AnvilTestWatcher(
-    ethCheatCodes,
+    new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls),
     aztecNodeConfig.l1Contracts.rollupAddress,
     l1Client,
     dateProvider,
@@ -566,16 +573,17 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
   }
 
   logger.verbose('Creating pxe...');
-  const pxeConfig = getPXEConfig();
+  const pxeConfig = getPXEServiceConfig();
   pxeConfig.dataDirectory = statePath;
-  const wallet = await TestWallet.create(aztecNode, pxeConfig);
-  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, aztecNode, dateProvider);
+  const pxe = await createPXEService(aztecNode, pxeConfig);
+
+  const cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
 
   return {
     aztecNodeConfig,
     anvil,
     aztecNode,
-    wallet,
+    pxe,
     sequencer: aztecNode.getSequencer()!,
     acvmConfig,
     bbConfig,
@@ -599,29 +607,20 @@ 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) =>
-  async ({ wallet, initialFundedAccounts }: { wallet: TestWallet; initialFundedAccounts: InitialAccountData[] }) => {
+  (numberOfAccounts: number, logger: Logger, waitUntilProven = false) =>
+  async ({ pxe, initialFundedAccounts }: { pxe: PXE; 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);
-    // 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,
-      );
-      const deployMethod = await accountManager.getDeployMethod();
-      await deployMethod
-        .send({
-          from: AztecAddress.ZERO,
-          skipClassPublication: i !== 0, // Publish the contract class at most once.
-        })
-        .wait();
-    }
+    await deployFundedSchnorrAccounts(
+      pxe,
+      deployedAccounts,
+      undefined,
+      waitUntilProven ? DefaultWaitForProvenOpts : undefined,
+    );
 
     return { deployedAccounts };
   };
@@ -632,34 +631,35 @@ export const deployAccounts =
  * @param sender - Wallet to send the deployment tx.
  * @param accountsToDeploy - Which accounts to publicly deploy.
  * @param waitUntilProven - Whether to wait for the tx to be proven.
- * @param node - AztecNode used to wait for proven tx.
+ * @param pxeOrNode - PXE or AztecNode to wait for proven.
  */
 export async function publicDeployAccounts(
-  wallet: Wallet,
-  accountsToDeploy: AztecAddress[],
+  sender: Wallet,
+  accountsToDeploy: (CompleteAddress | AztecAddress)[],
   waitUntilProven = false,
-  node?: AztecNode,
+  pxeOrNode?: PXE | AztecNode,
 ) {
-  const instances = (await Promise.all(accountsToDeploy.map(account => wallet.getContractMetadata(account)))).map(
-    metadata => metadata.contractInstance,
-  );
+  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 contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  const alreadyRegistered = (await wallet.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
+  const alreadyRegistered = (await sender.getContractClassMetadata(contractClass.id)).isContractClassPubliclyRegistered;
 
   const calls: ContractFunctionInteraction[] = await Promise.all([
-    ...(!alreadyRegistered ? [publishContractClass(wallet, SchnorrAccountContractArtifact)] : []),
-    ...instances.map(instance => publishInstance(wallet, instance!)),
+    ...(!alreadyRegistered ? [publishContractClass(sender, SchnorrAccountContractArtifact)] : []),
+    ...instances.map(instance => publishInstance(sender, instance!)),
   ]);
 
-  const batch = new BatchCall(wallet, calls);
+  const batch = new BatchCall(sender, calls);
 
-  const txReceipt = await batch.send({ from: accountsToDeploy[0] }).wait();
+  const txReceipt = await batch.send({ from: accountAddressesToDeploy[0] }).wait();
   if (waitUntilProven) {
-    if (!node) {
-      throw new Error('Need to provide an AztecNode to wait for proven.');
+    if (!pxeOrNode) {
+      throw new Error('Need to provide a PXE or AztecNode to wait for proven.');
     } else {
-      await waitForProven(node, txReceipt);
+      await waitForProven(pxeOrNode, txReceipt);
     }
   }
 }

package/src/fixtures/token_utils.ts

@@ -1,17 +1,22 @@
-import type { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall } from '@aztec/aztec.js/contracts';
-import type { Logger } from '@aztec/aztec.js/log';
-import type { Wallet } from '@aztec/aztec.js/wallet';
+import { type AztecAddress, BatchCall, type Logger, type Wallet } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
-export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
+// docs:start:token_utils
+
+export async function deployToken(
+  adminWallet: Wallet,
+  deployerAddress: AztecAddress,
+  initialAdminBalance: bigint,
+  logger: Logger,
+) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: admin })
+  const contract = await TokenContract.deploy(adminWallet, deployerAddress, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: deployerAddress })
     .deployed();
 
   if (initialAdminBalance > 0n) {
-    await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
+    // Minter is minting to herself so contract as minter is the same as contract as recipient
+    await mintTokensToPrivate(contract, deployerAddress, adminWallet, deployerAddress, initialAdminBalance);
   }
 
   logger.info('L2 contract deployed');
@@ -22,11 +27,14 @@ export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAd
 export async function mintTokensToPrivate(
   token: TokenContract,
   minter: AztecAddress,
+  minterWallet: Wallet,
   recipient: AztecAddress,
   amount: bigint,
 ) {
-  await token.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
+  const tokenAsMinter = await TokenContract.at(token.address, minterWallet);
+  await tokenAsMinter.methods.mint_to_private(recipient, amount).send({ from: minter }).wait();
 }
+// docs:end:token_utils
 
 export async function expectTokenBalance(
   wallet: Wallet,
@@ -43,19 +51,19 @@ export async function expectTokenBalance(
 }
 
 export async function mintNotes(
-  wallet: Wallet,
+  sender: Wallet,
   minter: AztecAddress,
   recipient: AztecAddress,
   asset: TokenContract,
   noteAmounts: bigint[],
 ): Promise<bigint> {
-  // We can only mint 5 notes at a time, since that's the maximum number of calls our entrypoints allow
+  // We can only mint 4 notes at a time, since that's the maximum number of calls our entrypoints allow
   // TODO(#13024): mint as many notes as possible in a single tx
-  const notesPerIteration = 5;
+  const notesPerIteration = 4;
   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(wallet, actions).send({ from: minter }).wait();
+    await new BatchCall(sender, actions).send({ from: minter }).wait();
   }
 
   return noteAmounts.reduce((prev, curr) => prev + curr, 0n);