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

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -1,5 +1,5 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
+import { EthAddress } from '@aztec/aztec.js';
 import { RollupContract } from '@aztec/ethereum';
 
 import fs from 'fs';
@@ -17,8 +17,8 @@ const SLASHING_QUORUM = 3;
 const EPOCH_DURATION = 2;
 const SLASHING_ROUND_SIZE_IN_EPOCHS = 2;
 const BOOT_NODE_UDP_PORT = 4500;
-const ETHEREUM_SLOT_DURATION = process.env.CI ? 8 : 4;
-const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
+const ETHEREUM_SLOT_DURATION = 4;
+const AZTEC_SLOT_DURATION = 8;
 const SLASHING_UNIT = BigInt(1e18);
 const SLASHING_AMOUNT = SLASHING_UNIT * 3n;
 
@@ -146,10 +146,6 @@ export class P2PInactivityTest {
       offlineValidators: this.offlineValidators,
     });
 
-    // Wait for P2P mesh to be fully formed before starting slashing period
-    // This prevents race conditions where validators propose blocks before the network is ready
-    await this.test.waitForP2PMeshConnectivity(this.nodes, NUM_NODES);
-
     this.test.logger.warn(`Advancing to epoch ${SETUP_EPOCH_DURATION + 1} to start slashing`);
     await this.test.ctx.cheatCodes.rollup.advanceToEpoch(SETUP_EPOCH_DURATION + 1);
 

package/src/e2e_p2p/p2p_network.ts

@@ -1,7 +1,7 @@
+import { getSchnorrWalletWithSecretKey } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
-import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { Fr } from '@aztec/aztec.js/fields';
+import { type AccountWalletWithSecretKey, AztecAddress, EthAddress, Fr } from '@aztec/aztec.js';
 import {
   type EmpireSlashingProposerContract,
   type ExtendedViemWalletClient,
@@ -18,7 +18,6 @@ import {
 import { ChainMonitor } from '@aztec/ethereum/test';
 import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
 import { RollupAbi, SlasherAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
@@ -27,7 +26,6 @@ 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/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import getPort from 'get-port';
@@ -77,7 +75,7 @@ export class P2PNetworkTest {
   public prefilledPublicData: PublicDataTreeLeaf[] = [];
 
   // The re-execution test needs a wallet and a spam contract
-  public wallet?: TestWallet;
+  public wallet?: AccountWalletWithSecretKey;
   public defaultAccountAddress?: AztecAddress;
   public spamContract?: SpamContract;
 
@@ -232,83 +230,89 @@ export class P2PNetworkTest {
 
   async applyBaseSnapshots() {
     await this.addBootstrapNode();
-    await this.snapshotManager.snapshot('add-validators', async ({ deployL1ContractsValues, cheatCodes }) => {
-      const rollup = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-        abi: RollupAbi,
-        client: deployL1ContractsValues.l1Client,
-      });
+    await this.snapshotManager.snapshot(
+      'add-validators',
+      async ({ deployL1ContractsValues, dateProvider, cheatCodes }) => {
+        const rollup = getContract({
+          address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
+          abi: RollupAbi,
+          client: deployL1ContractsValues.l1Client,
+        });
 
-      this.logger.info(`Adding ${this.numberOfValidators} validators`);
+        this.logger.info(`Adding ${this.numberOfValidators} validators`);
 
-      const stakingAsset = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-        abi: TestERC20Abi,
-        client: deployL1ContractsValues.l1Client,
-      });
+        const stakingAsset = getContract({
+          address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
+          abi: TestERC20Abi,
+          client: deployL1ContractsValues.l1Client,
+        });
 
-      const { address: multiAdderAddress } = await deployL1Contract(
-        deployL1ContractsValues.l1Client,
-        MultiAdderArtifact.contractAbi,
-        MultiAdderArtifact.contractBytecode,
-        [rollup.address, deployL1ContractsValues.l1Client.account.address],
-      );
+        const { address: multiAdderAddress } = await deployL1Contract(
+          deployL1ContractsValues.l1Client,
+          MultiAdderArtifact.contractAbi,
+          MultiAdderArtifact.contractBytecode,
+          [rollup.address, deployL1ContractsValues.l1Client.account.address],
+        );
 
-      const multiAdder = getContract({
-        address: multiAdderAddress.toString(),
-        abi: MultiAdderArtifact.contractAbi,
-        client: deployL1ContractsValues.l1Client,
-      });
+        const multiAdder = getContract({
+          address: multiAdderAddress.toString(),
+          abi: MultiAdderArtifact.contractAbi,
+          client: deployL1ContractsValues.l1Client,
+        });
 
-      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 }),
-        ),
-      );
+        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 }),
+          ),
+        );
 
-      const { validators } = this.getValidators();
-      this.validators = validators;
+        const { validators } = this.getValidators();
+        this.validators = validators;
 
-      const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
-      if (!gseAddress) {
-        throw new Error('GSE contract not deployed');
-      }
+        const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress!;
+        if (!gseAddress) {
+          throw new Error('GSE contract not deployed');
+        }
 
-      const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
+        const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
 
-      const makeValidatorTuples = async (validator: Operator) => {
-        const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
-        return {
-          attester: validator.attester.toString() as `0x${string}`,
-          withdrawer: validator.withdrawer.toString() as `0x${string}`,
-          ...registrationTuple,
+        const makeValidatorTuples = async (validator: Operator) => {
+          const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
+          return {
+            attester: validator.attester.toString() as `0x${string}`,
+            withdrawer: validator.withdrawer.toString() as `0x${string}`,
+            ...registrationTuple,
+          };
         };
-      };
-      const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+        const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
 
-      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-        hash: await multiAdder.write.addValidators([validatorTuples]),
-      });
+        await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+          hash: await multiAdder.write.addValidators([validatorTuples]),
+        });
 
-      await cheatCodes.rollup.advanceToEpoch(
-        (await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochs()) + 1n,
-      );
+        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);
-    });
+        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+        await this._sendDummyTx(deployL1ContractsValues.l1Client);
+      },
+    );
   }
 
   async setupAccount() {
     await this.snapshotManager.snapshot(
       'setup-account',
-      deployAccounts(1, this.logger),
-      ({ deployedAccounts }, { wallet }) => {
+      deployAccounts(1, this.logger, false),
+      async ({ deployedAccounts }, { pxe }) => {
         this.deployedAccounts = deployedAccounts;
-        [{ address: this.defaultAccountAddress }] = deployedAccounts;
-        this.wallet = wallet;
-        return Promise.resolve();
+        const [account] = deployedAccounts;
+        this.wallet = await getSchnorrWalletWithSecretKey(pxe, account.secret, account.signingKey, account.salt);
+        this.defaultAccountAddress = this.wallet.getAddress();
       },
     );
   }
@@ -390,48 +394,6 @@ export class P2PNetworkTest {
     this.logger.info('Nodes stopped');
   }
 
-  /**
-   * Wait for P2P mesh to be fully formed across all nodes.
-   * This ensures that all nodes are connected to each other before proceeding,
-   * preventing race conditions where validators propose blocks before the network is ready.
-   *
-   * @param nodes - Array of nodes to check for P2P connectivity
-   * @param expectedNodeCount - Expected number of nodes in the network (defaults to nodes.length)
-   * @param timeoutSeconds - Maximum time to wait for connections (default: 30 seconds)
-   * @param checkIntervalSeconds - How often to check connectivity (default: 0.1 seconds)
-   */
-  async waitForP2PMeshConnectivity(
-    nodes: AztecNodeService[],
-    expectedNodeCount?: number,
-    timeoutSeconds = 30,
-    checkIntervalSeconds = 0.1,
-  ) {
-    const nodeCount = expectedNodeCount ?? nodes.length;
-    const minPeerCount = nodeCount - 1;
-
-    this.logger.warn(
-      `Waiting for all ${nodeCount} nodes to connect to P2P mesh (at least ${minPeerCount} peers each)...`,
-    );
-
-    await Promise.all(
-      nodes.map(async (node, index) => {
-        const p2p = node.getP2P();
-        await retryUntil(
-          async () => {
-            const peers = await p2p.getPeers();
-            // Each node should be connected to at least N-1 other nodes
-            return peers.length >= minPeerCount ? true : undefined;
-          },
-          `Node ${index} to connect to at least ${minPeerCount} peers`,
-          timeoutSeconds,
-          checkIntervalSeconds,
-        );
-      }),
-    );
-
-    this.logger.warn('All nodes connected to P2P mesh');
-  }
-
   async teardown() {
     await this.monitor.stop();
     await tryStop(this.bootstrapNode, this.logger);

package/src/e2e_p2p/shared.ts

@@ -1,23 +1,29 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type SentTx, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
-import { Fr } from '@aztec/aztec.js/fields';
-import type { Logger } from '@aztec/aztec.js/log';
-import { Tx, TxStatus } from '@aztec/aztec.js/tx';
+import {
+  AztecAddress,
+  Fr,
+  type Logger,
+  ProvenTx,
+  type SentTx,
+  TxStatus,
+  getContractInstanceFromInstantiationParams,
+  retryUntil,
+} from '@aztec/aztec.js';
 import type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
 import { timesAsync, unique } from '@aztec/foundation/collection';
-import { retryUntil } from '@aztec/foundation/retry';
 import { pluralize } from '@aztec/foundation/string';
+import type { TestDateProvider } from '@aztec/foundation/timer';
 import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
-import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
+import { PXEService, createPXEService, getPXEServiceConfig as getRpcConfig } from '@aztec/pxe/server';
 import { getRoundForOffense } from '@aztec/slasher';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
-import { TestWallet, proveInteraction } from '@aztec/test-wallet/server';
 
+import type { NodeContext } from '../fixtures/setup_p2p_test.js';
 import { submitTxsTo } from '../shared/submit-transactions.js';
 
 // submits a set of transactions to the provided Private eXecution Environment (PXE)
@@ -50,46 +56,56 @@ export const submitComplexTxsTo = async (
   return txs;
 };
 
-// creates a wallet and submit a given number of transactions through it.
-export const submitTransactions = async (
+// creates an instance of the PXE and submit a given number of transactions to it.
+export const createPXEServiceAndSubmitTransactions = async (
   logger: Logger,
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<SentTx[]> => {
+): Promise<NodeContext> => {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
-  return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
+  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);
+  return { txs, pxeService, node };
 };
 
-export async function prepareTransactions(
+export async function createPXEServiceAndPrepareTransactions(
   logger: Logger,
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<Tx[]> {
+): Promise<{ pxeService: PXEService; txs: ProvenTx[]; node: AztecNodeService }> {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
+  const pxe = await createPXEService(node, rpcConfig, { useLogSuffix: true });
 
-  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
-  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+  const account = await getSchnorrAccount(pxe, fundedAccount.secret, fundedAccount.signingKey, fundedAccount.salt);
+  await account.register();
+  const wallet = await account.getWallet();
 
-  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
-    salt: Fr.random(),
-  });
-  await wallet.registerContract(testContractInstance, TestContractArtifact);
+  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {});
+  await wallet.registerContract({ instance: testContractInstance, artifact: TestContractArtifact });
   const contract = await TestContract.at(testContractInstance.address, wallet);
 
-  return timesAsync(numTxs, async () => {
-    const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
-      from: fundedAccountManager.address,
-    });
+  const txs = await timesAsync(numTxs, async () => {
+    const tx = await contract.methods.emit_nullifier(Fr.random()).prove({ from: account.getAddress() });
     const txHash = tx.getTxHash();
     logger.info(`Tx prepared with hash ${txHash}`);
     return tx;
   });
+
+  return { txs, pxeService: pxe, node };
 }
 
 export function awaitProposalExecution(
@@ -150,14 +166,12 @@ export async function awaitOffenseDetected({
   slashingRoundSize,
   epochDuration,
   waitUntilOffenseCount,
-  timeoutSeconds = 120,
 }: {
   nodeAdmin: AztecNodeAdmin;
   logger: Logger;
   slashingRoundSize: number;
   epochDuration: number;
   waitUntilOffenseCount?: number;
-  timeoutSeconds?: number;
 }) {
   const targetOffenseCount = waitUntilOffenseCount ?? 1;
   logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
@@ -169,11 +183,11 @@ export async function awaitOffenseDetected({
       }
     },
     'non-empty offenses',
-    timeoutSeconds,
+    60,
   );
   logger.info(
     `Hit ${offenses.length} offenses on rounds ${unique(offenses.map(o => getRoundForOffense(o, { slashingRoundSize, epochDuration })))}`,
-    { offenses },
+    offenses,
   );
   return offenses;
 }
@@ -190,9 +204,8 @@ export async function awaitCommitteeKicked({
   slashingProposer,
   slashingRoundSize,
   aztecSlotDuration,
-  aztecEpochDuration,
   logger,
-  offenseEpoch,
+  dateProvider,
 }: {
   rollup: RollupContract;
   cheatCodes: RollupCheatCodes;
@@ -201,22 +214,21 @@ export async function awaitCommitteeKicked({
   slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
   slashingRoundSize: number;
   aztecSlotDuration: number;
-  aztecEpochDuration: number;
+  dateProvider: TestDateProvider;
   logger: Logger;
-  offenseEpoch: number;
 }) {
   if (!slashingProposer) {
     throw new Error('No slashing proposer configured. Cannot test slashing.');
   }
 
+  logger.info(`Advancing epochs so we start slashing`);
   await cheatCodes.debugRollup();
+  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') {
-    // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
-    const targetEpoch = (await cheatCodes.getEpoch()) + (await rollup.getLagInEpochs()) + 1n;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(targetEpoch);
-
     const slashPayloadEvents = await retryUntil(
       async () => {
         const events = await slashFactory.getSlashPayloadCreatedEvents();
@@ -231,15 +243,6 @@ export async function awaitCommitteeKicked({
     expect(unique(slashPayloadEvents[0].slashes.map(slash => slash.validator.toString()))).toHaveLength(
       committee.length,
     );
-  } else {
-    // Use the slash offset to ensure we are in the right epoch for tally
-    const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
-    const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
-    const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
-    const firstEpochInOffenseRound = offenseEpoch - (offenseEpoch % slashingRoundSizeInEpochs);
-    const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
-    logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(targetEpoch, { offset: -aztecSlotDuration / 2 });
   }
 
   const attestersPre = await rollup.getAttesters();
@@ -250,7 +253,7 @@ export async function awaitCommitteeKicked({
     expect(attesterInfo.status).toEqual(1); // Validating
   }
 
-  const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
+  const timeout = slashingRoundSize * 2 * aztecSlotDuration;
   logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
   await awaitProposalExecution(slashingProposer, timeout, logger);
 
@@ -269,7 +272,9 @@ export async function awaitCommitteeKicked({
 
   logger.info(`Advancing to check current committee`);
   await cheatCodes.debugRollup();
-  await cheatCodes.advanceToEpoch((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochs()) + 1n);
+  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,9 +1,7 @@
-import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { type Logger, createLogger } from '@aztec/aztec.js/log';
-import type { AztecNode } from '@aztec/aztec.js/node';
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
+import { type AccountWallet, AztecAddress, type AztecNode, type Logger, createLogger } from '@aztec/aztec.js';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { InvalidAccountContract } from '@aztec/noir-test-contracts.js/InvalidAccount';
-import type { TestWallet } from '@aztec/test-wallet/server';
 
 import { jest } from '@jest/globals';
 
@@ -30,9 +28,11 @@ export class TokenContractTest {
   node!: AztecNode;
 
   badAccount!: InvalidAccountContract;
-  wallet!: TestWallet;
+  admin!: AccountWallet;
   adminAddress!: AztecAddress;
+  account1!: AccountWallet;
   account1Address!: AztecAddress;
+  account2!: AccountWallet;
   account2Address!: AztecAddress;
 
   constructor(testName: string) {
@@ -54,11 +54,11 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       '3_accounts',
       deployAccounts(3, this.logger),
-      ({ deployedAccounts }, { wallet, aztecNode }) => {
+      async ({ deployedAccounts }, { pxe, aztecNode }) => {
         this.node = aztecNode;
-        this.wallet = wallet;
-        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
-        return Promise.resolve();
+        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());
       },
     );
 
@@ -68,11 +68,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.wallet, [this.adminAddress, this.account1Address]);
+        await publicDeployAccounts(this.admin, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallet,
+          this.admin,
           this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
@@ -83,22 +83,22 @@ export class TokenContractTest {
         this.logger.verbose(`Token deployed to ${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}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.wallet);
+        this.asset = await TokenContract.at(tokenContractAddress, this.admin);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
+        this.tokenSim = new TokenSimulator(this.asset, this.admin, this.adminAddress, this.logger, [
           this.adminAddress,
           this.account1Address,
         ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.admin);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
@@ -131,14 +131,14 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, adminAddress } = this;
+        const { asset, admin, 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, adminAddress, amount);
+        await mintTokensToPrivate(asset, adminAddress, admin, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };