@aztec/end-to-end 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/bench/client_flows/client_flows_benchmark.ts

@@ -1,20 +1,9 @@
-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 { 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 { CheatCodes } from '@aztec/aztec/testing';
 import { type DeployL1ContractsArgs, RollupContract, createExtendedL1Client, deployL1Contract } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
@@ -30,8 +19,10 @@ 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 PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
+import { GasSettings } from '@aztec/stdlib/gas';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { TestWallet } from '@aztec/test-wallet/server';
 
 import { MNEMONIC } from '../../fixtures/fixtures.js';
 import {
@@ -53,22 +44,21 @@ 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 | undefined>;
 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
@@ -89,8 +79,8 @@ 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;
 
   public realProofs = ['true', '1'].includes(process.env.REAL_PROOFS ?? '');
 
@@ -117,7 +107,7 @@ export class ClientFlowsBenchmark {
       },
       // eslint-disable-next-line camelcase
       fee_juice: {
-        forWallet: this.getFeeJuicePaymentMethodForWallet.bind(this),
+        forWallet: () => Promise.resolve(undefined),
         circuits: 0,
       },
     };
@@ -169,7 +159,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 +167,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,32 +192,28 @@ export class ClientFlowsBenchmark {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(2, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
-        this.pxe = pxe;
-
+      async (
+        { deployedAccounts: [{ address: adminAddress }, { address: sequencerAddress }] },
+        { wallet, aztecNode, cheatCodes },
+      ) => {
+        this.adminWallet = wallet;
         this.aztecNode = aztecNode;
-        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
+        this.cheatCodes = cheatCodes;
 
-        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);
         this.coinbase = EthAddress.random();
 
-        const userPXEConfig = getPXEServiceConfig();
-        const l1Contracts = await aztecNode.getL1ContractAddresses();
+        const userPXEConfig = getPXEConfig();
         const userPXEConfigWithContracts = {
           ...userPXEConfig,
           proverEnabled: this.realProofs,
-          l1Contracts,
-        } as PXEServiceConfig;
+        } as PXEConfig;
 
-        this.userPXE = await createPXEService(this.aztecNode, userPXEConfigWithContracts, {
+        this.userWallet = await TestWallet.create(this.aztecNode, userPXEConfigWithContracts, {
           loggers: {
             prover: this.proxyLogger.createLogger('pxe:bb:wasm:bundle:proxied'),
           },
@@ -251,7 +234,6 @@ 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,
@@ -297,7 +279,7 @@ export class ClientFlowsBenchmark {
       'fpc_setup',
       async context => {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
         const bananaCoin = this.bananaCoin;
         const bananaFPC = await FPCContract.deploy(this.adminWallet, bananaCoin.address, this.adminAddress)
@@ -320,7 +302,7 @@ export class ClientFlowsBenchmark {
     await this.snapshotManager.snapshot(
       'deploy_sponsored_fpc',
       async () => {
-        const sponsoredFPC = await setupSponsoredFPC(this.pxe);
+        const sponsoredFPC = await setupSponsoredFPC(this.adminWallet);
         this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
         return { sponsoredFPCAddress: sponsoredFPC.address };
       },
@@ -330,7 +312,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, [
@@ -342,10 +324,9 @@ 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,
     );
@@ -355,26 +336,25 @@ export class ClientFlowsBenchmark {
     return crossChainTestHarness;
   }
 
-  public async createAndFundBenchmarkingWallet(accountType: AccountType) {
-    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.pxe, accountType);
-    const benchysWallet = await benchysAccountManager.getWallet();
-    const benchysAddress = benchysAccountManager.getAddress();
+  public async createAndFundBenchmarkingAccountOnUserWallet(accountType: AccountType) {
+    const benchysAccountManager = await this.createBenchmarkingAccountManager(this.adminWallet, accountType);
+    const benchysAccount = await benchysAccountManager.getAccount();
+    const benchysAddress = benchysAccountManager.address;
     const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(benchysAddress);
-    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,
+    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(),
     });
-    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.address;
   }
 
   public async applyDeployAmmSnapshot() {
@@ -403,20 +383,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 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 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()));
-  }
 }

package/src/bench/client_flows/data_extractor.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '@aztec/aztec.js';
+import type { Logger } from '@aztec/aztec.js/log';
 import { BBNativePrivateKernelProver } from '@aztec/bb-prover/client/native';
 import { BBWASMBundlePrivateKernelProver } from '@aztec/bb-prover/client/wasm/bundle';
 import { createLogger, logger } from '@aztec/foundation/log';

package/src/bench/utils.ts

@@ -1,8 +1,7 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { type AztecNode, BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js';
+import { BatchCall, type SentTx, type WaitOpts } from '@aztec/aztec.js/contracts';
 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';
 
@@ -22,9 +21,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 +109,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),
@@ -131,17 +129,17 @@ function makeCall(
  * @param heavyPublicCompute - Whether the transactions include heavy public compute (like a big sha256).
  * @returns Array of sent txs.
  */
-export async function sendTxs(
+export function sendTxs(
   txCount: number,
   context: EndToEndContext,
   contract: BenchmarkingContract,
   heavyPublicCompute: boolean = false,
-): Promise<SentTx[]> {
+): 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;
   context.logger.info(`Sending ${txCount} txs`);
-  return provenTxs.map(tx => tx.send());
+  return calls.map(call => call.send({ from }));
 }
 
 export async function waitTxs(txs: SentTx[], context: EndToEndContext, txWaitOpts?: WaitOpts) {
@@ -150,32 +148,6 @@ 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,21 +1,15 @@
-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 { 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 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';
 
@@ -63,9 +57,7 @@ export class BlacklistTokenContractTest {
 
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  pxe!: PXE;
-  accounts: CompleteAddress[] = [];
+  wallet!: TestWallet;
   asset!: TokenBlacklistContract;
   tokenSim!: TokenSimulator;
   badAccount!: InvalidAccountContract;
@@ -73,11 +65,8 @@ export class BlacklistTokenContractTest {
   sequencer!: SequencerClient;
   aztecNode!: AztecNode;
 
-  admin!: AccountWallet;
   adminAddress!: AztecAddress;
-  other!: AccountWallet;
   otherAddress!: AztecAddress;
-  blacklisted!: AccountWallet;
   blacklistedAddress!: AztecAddress;
 
   constructor(testName: string) {
@@ -105,19 +94,15 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      async ({ deployedAccounts }, { pxe, cheatCodes, aztecNode, sequencer }) => {
-        this.pxe = pxe;
+      ({ deployedAccounts }, { cheatCodes, aztecNode, sequencer, wallet }) => {
         this.cheatCodes = cheatCodes;
         this.aztecNode = aztecNode;
         this.sequencer = sequencer;
-        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());
+        this.wallet = wallet;
+        this.adminAddress = deployedAccounts[0].address;
+        this.otherAddress = deployedAccounts[1].address;
+        this.blacklistedAddress = deployedAccounts[2].address;
+        return Promise.resolve();
       },
     );
 
@@ -127,16 +112,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.admin, this.accounts.slice(0, 3));
+        await publicDeployAccounts(this.wallet, [this.adminAddress, this.otherAddress, this.blacklistedAddress]);
 
         this.logger.verbose(`Deploying TokenContract...`);
-        this.asset = await TokenBlacklistContract.deploy(this.admin, this.adminAddress)
+        this.asset = await TokenBlacklistContract.deploy(this.wallet, 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.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}.`);
 
         await this.crossTimestampOfChange();
@@ -145,18 +130,18 @@ export class BlacklistTokenContractTest {
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallets[0]);
+        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.asset as unknown as TokenContract,
-          this.admin,
+          this.wallet,
           this.adminAddress,
           this.logger,
-          this.accounts.map(a => a.address),
+          [this.adminAddress, this.otherAddress, this.blacklistedAddress],
         );
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallets[0]);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
@@ -187,7 +172,7 @@ export class BlacklistTokenContractTest {
     secretHash: Fr,
     txHash: TxHash,
   ) {
-    const txEffects = await this.pxe.getTxEffect(txHash);
+    const txEffects = await this.aztecNode.getTxEffect(txHash);
     await contract.methods
       .deliver_transparent_note(
         contract.address,
@@ -205,40 +190,38 @@ export class BlacklistTokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, accounts, wallets } = this;
+        const { asset } = this;
         const amount = 10000n;
 
         const adminMinterRole = new Role().withAdmin().withMinter();
-        await this.asset
-          .withWallet(this.admin)
-          .methods.update_roles(this.admin.getAddress(), adminMinterRole.toNoirStruct())
+        await this.asset.methods
+          .update_roles(this.adminAddress, adminMinterRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         const blacklistRole = new Role().withBlacklisted();
-        await this.asset
-          .withWallet(this.admin)
-          .methods.update_roles(this.blacklisted.getAddress(), blacklistRole.toNoirStruct())
+        await this.asset.methods
+          .update_roles(this.blacklistedAddress, blacklistRole.toNoirStruct())
           .send({ from: this.adminAddress })
           .wait();
 
         await this.crossTimestampOfChange();
 
-        expect(
-          await this.asset.methods.get_roles(this.admin.getAddress()).simulate({ from: this.adminAddress }),
-        ).toEqual(adminMinterRole.toNoirStruct());
+        expect(await this.asset.methods.get_roles(this.adminAddress).simulate({ from: this.adminAddress })).toEqual(
+          adminMinterRole.toNoirStruct(),
+        );
 
         this.logger.verbose(`Minting ${amount} publicly...`);
-        await asset.methods.mint_public(accounts[0].address, amount).send({ from: this.adminAddress }).wait();
+        await asset.methods.mint_public(this.adminAddress, 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, wallets[0].getAddress(), amount, secretHash, receipt.txHash);
+        await this.addPendingShieldNoteToPXE(asset, this.adminAddress, amount, secretHash, receipt.txHash);
         const txClaim = asset.methods
-          .redeem_shield(accounts[0].address, amount, secret)
+          .redeem_shield(this.adminAddress, amount, secret)
           .send({ from: this.adminAddress });
         await txClaim.wait();
         this.logger.verbose(`Minting complete.`);
@@ -246,23 +229,23 @@ export class BlacklistTokenContractTest {
         return { amount };
       },
       async ({ amount }) => {
-        const {
-          asset,
-          accounts: [{ address }],
-          tokenSim,
-        } = this;
-        tokenSim.mintPublic(address, amount);
-
-        const publicBalance = await asset.methods.balance_of_public(address).simulate({ from: address });
+        const { asset, tokenSim } = this;
+        tokenSim.mintPublic(this.adminAddress, amount);
+
+        const publicBalance = await asset.methods
+          .balance_of_public(this.adminAddress)
+          .simulate({ from: this.adminAddress });
         this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(this.adminAddress));
 
-        tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate({ from: address });
+        tokenSim.mintPrivate(this.adminAddress, amount);
+        const privateBalance = await asset.methods
+          .balance_of_private(this.adminAddress)
+          .simulate({ from: this.adminAddress });
         this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(this.adminAddress));
 
-        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
+        const totalSupply = await asset.methods.total_supply().simulate({ from: this.adminAddress });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);