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

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,9 +1,20 @@
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
-import { type FeePaymentMethod, PrivateFeePaymentMethod, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
-import type { Wallet } from '@aztec/aztec.js/wallet';
+import { EcdsaRAccountContractArtifact, getEcdsaRAccount } from '@aztec/accounts/ecdsa';
+import { SchnorrAccountContractArtifact, getSchnorrAccount, getSchnorrWallet } from '@aztec/accounts/schnorr';
+import {
+  type AccountWallet,
+  AccountWalletWithSecretKey,
+  AztecAddress,
+  type AztecNode,
+  FeeJuicePaymentMethod,
+  FeeJuicePaymentMethodWithClaim,
+  type FeePaymentMethod,
+  type Logger,
+  type PXE,
+  PrivateFeePaymentMethod,
+  SponsoredFeePaymentMethod,
+  type Wallet,
+  createLogger,
+} from '@aztec/aztec.js';
 import { CheatCodes } from '@aztec/aztec/testing';
 import { type DeployL1ContractsArgs, RollupContract, createExtendedL1Client, deployL1Contract } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
@@ -19,10 +30,8 @@ import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { TokenContract as BananaCoin, TokenContract } from '@aztec/noir-contracts.js/Token';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
-import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
-import { GasSettings } from '@aztec/stdlib/gas';
+import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../../fixtures/fixtures.js';
 import {
@@ -44,21 +53,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, sender: AztecAddress) => Promise<FeePaymentMethod | undefined>;
+export type FeePaymentMethodGetter = (wallet: Wallet) => 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;
   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
@@ -79,8 +89,8 @@ export class ClientFlowsBenchmark {
   // Sponsored FPC contract
   public sponsoredFPC!: SponsoredFPCContract;
 
-  // PXE and Wallet used by the benchmarking user. It can be set up with client-side proving enabled
-  public userWallet!: TestWallet;
+  // PXE used by the benchmarking user. It can be set up with client-side proving enabled
+  public userPXE!: PXE;
 
   public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
 
@@ -107,7 +117,7 @@ export class ClientFlowsBenchmark {
       },
       // eslint-disable-next-line camelcase
       fee_juice: {
-        forWallet: () => Promise.resolve(undefined),
+        forWallet: this.getFeeJuicePaymentMethodForWallet.bind(this),
         circuits: 0,
       },
     };
@@ -159,7 +169,7 @@ export class ClientFlowsBenchmark {
       .balance_of_private(address)
       .simulate({ from: this.adminAddress });
 
-    await mintTokensToPrivate(this.bananaCoin, this.adminAddress, address, amount);
+    await mintTokensToPrivate(this.bananaCoin, this.adminAddress, this.adminWallet, address, amount);
 
     const balanceAfter = await this.bananaCoin.methods
       .balance_of_private(address)
@@ -167,20 +177,23 @@ export class ClientFlowsBenchmark {
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
-  createBenchmarkingAccountManager(wallet: TestWallet, type: 'ecdsar1' | 'schnorr') {
-    const benchysSecret = Fr.random();
+  async createBenchmarkingAccountManager(pxe: PXE, type: 'ecdsar1' | 'schnorr') {
+    const benchysSecretKey = Fr.random();
     const salt = Fr.random();
 
     let benchysPrivateSigningKey;
+    let benchysAccountManager;
     if (type === 'schnorr') {
-      benchysPrivateSigningKey = deriveSigningKey(benchysSecret);
-      return wallet.createSchnorrAccount(benchysSecret, salt, benchysPrivateSigningKey);
+      benchysPrivateSigningKey = deriveSigningKey(benchysSecretKey);
+      benchysAccountManager = await getSchnorrAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
     } else if (type === 'ecdsar1') {
       benchysPrivateSigningKey = randomBytes(32);
-      return wallet.createECDSARAccount(benchysSecret, salt, benchysPrivateSigningKey);
+      benchysAccountManager = await getEcdsaRAccount(pxe, benchysSecretKey, benchysPrivateSigningKey, salt);
     } else {
       throw new Error(`Unknown account type: ${type}`);
     }
+    await benchysAccountManager.register();
+    return benchysAccountManager;
   }
 
   public async applyBaseSnapshots() {
@@ -192,28 +205,32 @@ export class ClientFlowsBenchmark {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(2, this.logger),
-      async (
-        { deployedAccounts: [{ address: adminAddress }, { address: sequencerAddress }] },
-        { wallet, aztecNode, cheatCodes },
-      ) => {
-        this.adminWallet = wallet;
+      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
+        this.pxe = pxe;
+
         this.aztecNode = aztecNode;
-        this.cheatCodes = cheatCodes;
+        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
 
-        this.adminAddress = adminAddress;
-        this.sequencerAddress = sequencerAddress;
+        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();
 
         const canonicalFeeJuice = await getCanonicalFeeJuice();
         this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.adminWallet);
         this.coinbase = EthAddress.random();
 
-        const userPXEConfig = getPXEConfig();
+        const userPXEConfig = getPXEServiceConfig();
+        const l1Contracts = await aztecNode.getL1ContractAddresses();
         const userPXEConfigWithContracts = {
           ...userPXEConfig,
           proverEnabled: this.realProofs,
-        } as PXEConfig;
+          l1Contracts,
+        } as PXEServiceConfig;
 
-        this.userWallet = await TestWallet.create(this.aztecNode, userPXEConfigWithContracts, {
+        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, {
           loggers: {
             prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
           },
@@ -234,6 +251,7 @@ export class ClientFlowsBenchmark {
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: context.aztecNode,
           aztecNodeAdmin: context.aztecNode,
+          pxeService: context.pxe,
           l1Client: context.deployL1ContractsValues.l1Client,
           wallet: this.adminWallet,
           logger: this.logger,
@@ -279,7 +297,7 @@ export class ClientFlowsBenchmark {
       'fpc_setup',
       async context => {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
         const bananaCoin = this.bananaCoin;
         const bananaFPC = await FPCContract.deploy(this.adminWallet, bananaCoin.address, this.adminAddress)
@@ -302,7 +320,7 @@ export class ClientFlowsBenchmark {
     await this.snapshotManager.snapshot(
       'deploy_sponsored_fpc',
       async () => {
-        const sponsoredFPC = await setupSponsoredFPC(this.adminWallet);
+        const sponsoredFPC = await setupSponsoredFPC(this.pxe);
         this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
         return { sponsoredFPCAddress: sponsoredFPC.address };
       },
@@ -312,7 +330,7 @@ export class ClientFlowsBenchmark {
     );
   }
 
-  public async createCrossChainTestHarness(owner: AztecAddress) {
+  public async createCrossChainTestHarness(owner: AccountWallet) {
     const l1Client = createExtendedL1Client(this.context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
 
     const underlyingERC20Address = await deployL1Contract(l1Client, TestERC20Abi, TestERC20Bytecode, [
@@ -324,9 +342,10 @@ export class ClientFlowsBenchmark {
     this.logger.verbose(`Setting up cross chain harness...`);
     const crossChainTestHarness = await CrossChainTestHarness.new(
       this.aztecNode,
+      this.pxe,
       l1Client,
-      this.adminWallet,
       owner,
+      owner.getAddress(),
       this.logger,
       underlyingERC20Address,
     );
@@ -336,25 +355,26 @@ export class ClientFlowsBenchmark {
     return crossChainTestHarness;
   }
 
-  public async createAndFundBenchmarkingAccountOnUserWallet(accountType: AccountType) {
-    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.adminWallet, accountType);
-    const benchysAccount = await benchysAccountManager.getAccount();
-    const benchysAddress = benchysAccountManager.address;
+  public async createAndFundBenchmarkingWallet(accountType: AccountType) {
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.pxe, accountType);
+    const benchysWallet = await benchysAccountManager.getWallet();
+    const benchysAddress = benchysAccountManager.getAddress();
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
-    const behchysDeployMethod = await benchysAccountManager.getDeployMethod();
-    await behchysDeployMethod
-      .send({
-        from: AztecAddress.ZERO,
-        fee: { paymentMethod: new FeeJuicePaymentMethodWithClaim(benchysAddress, claim) },
-      })
-      .wait();
-    // 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(),
+    const paymentMethod = new FeeJuicePaymentMethodWithClaim(benchysWallet, 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,
     });
-    return accountManager.address;
+    await this.userPXE.registerAccount(benchysWallet.getSecretKey(), benchysWallet.getCompleteAddress().partialAddress);
+    const entrypoint = await benchysAccountManager.getAccount();
+    return new AccountWalletWithSecretKey(
+      this.userPXE,
+      entrypoint,
+      benchysWallet.getSecretKey(),
+      benchysAccountManager.salt,
+    );
   }
 
   public async applyDeployAmmSnapshot() {
@@ -383,20 +403,20 @@ export class ClientFlowsBenchmark {
     );
   }
 
-  public async getBridgedFeeJuicePaymentMethodForWallet(_wallet: Wallet, sender: AztecAddress) {
-    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(sender);
-    return new FeeJuicePaymentMethodWithClaim(sender, claim);
+  public async getBridgedFeeJuicePaymentMethodForWallet(wallet: Wallet) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(wallet.getAddress());
+    return new FeeJuicePaymentMethodWithClaim(wallet, claim);
   }
 
-  public async getPrivateFPCPaymentMethodForWallet(wallet: Wallet, sender: AztecAddress) {
-    // The private fee paying method assembled on the app side requires knowledge of the maximum
-    // fee the user is willing to pay
-    const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1.5);
-    const gasSettings = GasSettings.default({ maxFeesPerGas });
-    return new PrivateFeePaymentMethod(this.bananaFPC.address, sender, wallet, gasSettings);
+  public getPrivateFPCPaymentMethodForWallet(wallet: Wallet) {
+    return Promise.resolve(new PrivateFeePaymentMethod(this.bananaFPC.address, wallet));
   }
 
-  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet, _sender: AztecAddress) {
+  public getSponsoredFPCPaymentMethodForWallet(_wallet: Wallet) {
     return Promise.resolve(new SponsoredFeePaymentMethod(this.sponsoredFPC.address));
   }
+
+  public getFeeJuicePaymentMethodForWallet(wallet: Wallet) {
+    return Promise.resolve(new FeeJuicePaymentMethod(wallet.getAddress()));
+  }
 }

package/src/bench/client_flows/data_extractor.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@aztec/aztec.js/log';
+import type { Logger } from '@aztec/aztec.js';
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
 import { createLogger, logger } from '@aztec/foundation/log';
@@ -46,7 +46,7 @@ async function main() {
     proxyLogger.createLogger('bb:prover'),
   );
 
-  const userLog = createLogger('chonk_flows:data_processor');
+  const userLog = createLogger('client_ivc_flows:data_processor');
 
   for (const flow of flows) {
     userLog.info(`Processing flow ${flow}`);
@@ -84,10 +84,10 @@ async function main() {
     let provingTime;
     try {
       const provingTimer = new Timer();
-      await prover.createChonkProof(privateExecutionSteps);
+      await prover.createClientIvcProof(privateExecutionSteps);
       provingTime = provingTimer.ms();
     } catch (e) {
-      userLog.error(`Failed to generate chonk proof for ${flow}`, e);
+      userLog.error(`Failed to generate client ivc proof for ${flow}`, e);
       error = (e as Error).message;
     }
     // Extract logs from this run from the proxy and write them to disk unconditionally

package/src/bench/utils.ts

@@ -1,7 +1,8 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
+import { type AztecNode, BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js';
 import { mean, stdDev, times } from '@aztec/foundation/collection';
 import { BenchmarkingContract } from '@aztec/noir-test-contracts.js/Benchmarking';
+import { type PXEService, type PXEServiceConfig, createPXEService } from '@aztec/pxe/server';
 import type { MetricsType } from '@aztec/telemetry-client';
 import type { BenchmarkDataPoint, BenchmarkMetricsType, BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 
@@ -21,8 +22,9 @@ export async function benchmarkSetup(
   },
 ) {
   const context = await setup(1, { ...opts, telemetryConfig: { benchmark: true } });
-  const defaultAccountAddress = context.accounts[0];
-  const contract = await BenchmarkingContract.deploy(context.wallet).send({ from: defaultAccountAddress }).deployed();
+  const contract = await BenchmarkingContract.deploy(context.wallet)
+    .send({ from: context.wallet.getAddress() })
+    .deployed();
   context.logger.info(`Deployed benchmarking contract at ${contract.address}`);
   const sequencer = (context.aztecNode as AztecNodeService).getSequencer()!;
   const telemetry = context.telemetryClient! as BenchmarkTelemetryClient;
@@ -109,9 +111,9 @@ function makeCall(
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean,
 ) {
-  const [owner] = context.accounts;
+  const owner = context.wallet.getAddress();
   if (heavyPublicCompute) {
-    return new BatchCall(context.wallet, [contract.methods.sha256_hash_1024(randomBytesAsBigInts(1024))]);
+    return new BatchCall(context.wallet, [contract.methods.sha256_hash_2048(randomBytesAsBigInts(2048))]);
   } else {
     return new BatchCall(context.wallet, [
       contract.methods.create_note(owner, index + 1),
@@ -129,17 +131,17 @@ function makeCall(
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns Array of sent txs.
  */
-export function sendTxs(
+export async function sendTxs(
   txCount: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): SentTx[] {
+): Promise<SentTx[]> {
   const calls = times(txCount, index => makeCall(index, context, contract, heavyPublicCompute));
   context.logger.info(`Creating ${txCount} txs`);
-  const [from] = context.accounts;
+  const provenTxs = await Promise.all(calls.map(call => call.prove({ from: context.wallet.getAddress() })));
   context.logger.info(`Sending ${txCount} txs`);
-  return calls.map(call => call.send({ from }));
+  return provenTxs.map(tx => tx.send());
 }
 
 export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
@@ -148,6 +150,32 @@ export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpt
   context.logger.info(`All ${txs.length} txs have been mined`);
 }
 
+/**
+ * Creates a new PXE
+ * @param node - Node to connect the pxe to.
+ * @param contract - Benchmark contract to add to the pxe.
+ * @param startingBlock - First l2 block to process.
+ * @returns The new PXE.
+ */
+export async function createNewPXE(node: AztecNode, contract: BenchmarkingContract): Promise<PXEService> {
+  const l1Contracts = await node.getL1ContractAddresses();
+  const { l1ChainId, rollupVersion } = await node.getNodeInfo();
+  const pxeConfig = {
+    l2BlockBatchSize: 50,
+    l2BlockPollingIntervalMS: 100,
+    dataDirectory: undefined,
+    dataStoreMapSizeKb: 1024 * 1024,
+    l1Contracts,
+    l1ChainId,
+    rollupVersion,
+  } as PXEServiceConfig;
+  // docs:start:PXEcreate
+  const pxe = await createPXEService(node, pxeConfig);
+  // docs:end:PXEcreate
+  await pxe.registerContract(contract);
+  return pxe;
+}
+
 function randomBytesAsBigInts(length: number): bigint[] {
   return [...Array(length)].map(_ => BigInt(Math.floor(Math.random() * 255)));
 }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -1,15 +1,21 @@
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { computeSecretHash } from '@aztec/aztec.js/crypto';
-import { Fr } from '@aztec/aztec.js/fields';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
-import type { TxHash } from '@aztec/aztec.js/tx';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
+import {
+  type AccountWallet,
+  AztecAddress,
+  type AztecNode,
+  type CompleteAddress,
+  Fr,
+  type Logger,
+  type PXE,
+  type TxHash,
+  computeSecretHash,
+  createLogger,
+} from '@aztec/aztec.js';
 import type { CheatCodes } from '@aztec/aztec/testing';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBlacklistContract } from '@aztec/noir-contracts.js/TokenBlacklist';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
@@ -57,7 +63,9 @@ export class BlacklistTokenContractTest {
 
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallet!: TestWallet;
+  wallets: AccountWallet[] = [];
+  pxe!: PXE;
+  accounts: CompleteAddress[] = [];
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
@@ -65,8 +73,11 @@ export class BlacklistTokenContractTest {
   sequencer!: SequencerClient;
   aztecNode!: AztecNode;
 
+  admin!: AccountWallet;
   adminAddress!: AztecAddress;
+  other!: AccountWallet;
   otherAddress!: AztecAddress;
+  blacklisted!: AccountWallet;
   blacklistedAddress!: AztecAddress;
 
   constructor(testName: string) {
@@ -94,15 +105,19 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { cheatCodes, aztecNode, sequencer, wallet }) => {
+      async ({ deployedAccounts }, { pxe, cheatCodes, aztecNode, sequencer }) => {
+        this.pxe = pxe;
         this.cheatCodes = cheatCodes;
         this.aztecNode = aztecNode;
         this.sequencer = sequencer;
-        this.wallet = wallet;
-        this.adminAddress = deployedAccounts[0].address;
-        this.otherAddress = deployedAccounts[1].address;
-        this.blacklistedAddress = deployedAccounts[2].address;
-        return Promise.resolve();
+        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
+        this.admin = this.wallets[0];
+        this.adminAddress = this.admin.getAddress();
+        this.other = this.wallets[1];
+        this.otherAddress = this.other.getAddress();
+        this.blacklisted = this.wallets[2];
+        this.blacklistedAddress = this.blacklisted.getAddress();
+        this.accounts = this.wallets.map(w => w.getCompleteAddress());
       },
     );
 
@@ -112,16 +127,16 @@ export class BlacklistTokenContractTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
+        await publicDeployAccounts(this.admin, this.accounts.slice(0, 3));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.wallet, this.adminAddress)
+        this.asset = await TokenBlacklistContract.deploy(this.admin, this.adminAddress)
           .send({ from: this.adminAddress })
           .deployed();
         this.logger.verbose(`Token deployed to ${this.asset.address}`);
 
         this.logger.verbose(`Deploying bad account...`);
-        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.admin).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         await this.crossTimestampOfChange();
@@ -130,18 +145,18 @@ export class BlacklistTokenContractTest {
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallet);
+        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallets[0]);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.asset as unknown as TokenContract,
-          this.wallet,
+          this.admin,
           this.adminAddress,
           this.logger,
-          [this.adminAddress, this.otherAddress, this.blacklistedAddress],
+          this.accounts.map(a => a.address),
         );
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
@@ -172,7 +187,7 @@ export class BlacklistTokenContractTest {
     secretHash: Fr,
     txHash: TxHash,
   ) {
-    const txEffects = await this.aztecNode.getTxEffect(txHash);
+    const txEffects = await this.pxe.getTxEffect(txHash);
     await contract.methods
       .deliver_transparent_note(
         contract.address,
@@ -190,38 +205,40 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset } = this;
+        const { asset, accounts, wallets } = this;
         const amount = 10000n;
 
         const adminMinterRole = new Role().withAdmin().withMinter();
-        await this.asset.methods
-          .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
+        await this.asset
+          .withWallet(this.admin)
+          .methods.update_roles(this.admin.getAddress(), adminMinterRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         const blacklistRole = new Role().withBlacklisted();
-        await this.asset.methods
-          .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
+        await this.asset
+          .withWallet(this.admin)
+          .methods.update_roles(this.blacklisted.getAddress(), blacklistRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         await this.crossTimestampOfChange();
 
-        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
-          adminMinterRole.toNoirStruct(),
-        );
+        expect(
+          await this.asset.methods.get_roles(this.admin.getAddress()).simulate({ from: this.adminAddress }),
+        ).toEqual(adminMinterRole.toNoirStruct());
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(this.adminAddress, amount).send({ from: this.adminAddress }).wait();
+        await asset.methods.mint_public(accounts[0].address, amount).send({ from: this.adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
         const secret = Fr.random();
         const secretHash = await computeSecretHash(secret);
         const receipt = await asset.methods.mint_private(amount, secretHash).send({ from: this.adminAddress }).wait();
 
-        await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
+        await this.addPendingShieldNoteToPXE(asset, wallets[0].getAddress(), amount, secretHash, receipt.txHash);
         const txClaim = asset.methods
-          .redeem_shield(this.adminAddress, amount, secret)
+          .redeem_shield(accounts[0].address, amount, secret)
           .send({ from: this.adminAddress });
         await txClaim.wait();
         this.logger.verbose(`Minting complete.`);
@@ -229,23 +246,23 @@ export class BlacklistTokenContractTest {
         return { amount };
       },
       async ({ amount }) => {
-        const { asset, tokenSim } = this;
-        tokenSim.mintPublic(this.adminAddress, amount);
-
-        const publicBalance = await asset.methods
-          .balance_of_public(this.adminAddress)
-          .simulate({ from: this.adminAddress });
+        const {
+          asset,
+          accounts: [{ address }],
+          tokenSim,
+        } = this;
+        tokenSim.mintPublic(address, amount);
+
+        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
 
-        tokenSim.mintPrivate(this.adminAddress, amount);
-        const privateBalance = await asset.methods
-          .balance_of_private(this.adminAddress)
-          .simulate({ from: this.adminAddress });
+        tokenSim.mintPrivate(address, amount);
+        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
 
-        const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
+        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);