@aztec/end-to-end 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/e2e_p2p/shared.ts

@@ -1,28 +1,23 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
-import {
-  AztecAddress,
-  Fr,
-  type Logger,
-  ProvenTx,
-  type SentTx,
-  TxStatus,
-  getContractInstanceFromInstantiationParams,
-  retryUntil,
-} from '@aztec/aztec.js';
+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 type { RollupCheatCodes } from '@aztec/aztec/testing';
 import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum';
 import { timesAsync, unique } from '@aztec/foundation/collection';
-import type { TestDateProvider } from '@aztec/foundation/timer';
+import { retryUntil } from '@aztec/foundation/retry';
+import { pluralize } from '@aztec/foundation/string';
 import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
-import { PXEService, createPXEService, getPXEServiceConfig as getRpcConfig } from '@aztec/pxe/server';
+import { getPXEConfig, getPXEConfig 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)
@@ -55,56 +50,46 @@ export const submitComplexTxsTo = async (
   return txs;
 };
 
-// creates an instance of the PXE and submit a given number of transactions to it.
-export const createPXEServiceAndSubmitTransactions = async (
+// creates a wallet and submit a given number of transactions through it.
+export const submitTransactions = async (
   logger: Logger,
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<NodeContext> => {
+): Promise<SentTx[]> => {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const pxeService = await createPXEService(node, rpcConfig, { useLogSuffix: true });
-
-  const account = await getSchnorrAccount(
-    pxeService,
-    fundedAccount.secret,
-    fundedAccount.signingKey,
-    fundedAccount.salt,
-  );
-  await account.register();
-  const wallet = await account.getWallet();
-
-  const txs = await submitTxsTo(pxeService, numTxs, wallet, logger);
-  return { txs, pxeService, node };
+  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);
 };
 
-export async function createPXEServiceAndPrepareTransactions(
+export async function prepareTransactions(
   logger: Logger,
   node: AztecNodeService,
   numTxs: number,
   fundedAccount: InitialAccountData,
-): Promise<{ pxeService: PXEService; txs: ProvenTx[]; node: AztecNodeService }> {
+): Promise<Tx[]> {
   const rpcConfig = getRpcConfig();
   rpcConfig.proverEnabled = false;
-  const pxe = await createPXEService(node, rpcConfig, { useLogSuffix: true });
 
-  const account = await getSchnorrAccount(pxe, fundedAccount.secret, fundedAccount.signingKey, fundedAccount.salt);
-  await account.register();
-  const wallet = await account.getWallet();
+  const wallet = await TestWallet.create(node, { ...getPXEConfig(), proverEnabled: false }, { useLogSuffix: true });
+  const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
 
-  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {});
-  await wallet.registerContract({ instance: testContractInstance, artifact: TestContractArtifact });
+  const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
+    salt: Fr.random(),
+  });
+  await wallet.registerContract(testContractInstance, TestContractArtifact);
   const contract = await TestContract.at(testContractInstance.address, wallet);
 
-  const txs = await timesAsync(numTxs, async () => {
-    const tx = await contract.methods.emit_nullifier(Fr.random()).prove({ from: account.getAddress() });
+  return timesAsync(numTxs, async () => {
+    const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
+      from: fundedAccountManager.address,
+    });
     const txHash = tx.getTxHash();
     logger.info(`Tx prepared with hash ${txHash}`);
     return tx;
   });
-
-  return { txs, pxeService: pxe, node };
 }
 
 export function awaitProposalExecution(
@@ -164,26 +149,31 @@ export async function awaitOffenseDetected({
   nodeAdmin,
   slashingRoundSize,
   epochDuration,
+  waitUntilOffenseCount,
+  timeoutSeconds = 120,
 }: {
   nodeAdmin: AztecNodeAdmin;
   logger: Logger;
   slashingRoundSize: number;
   epochDuration: number;
+  waitUntilOffenseCount?: number;
+  timeoutSeconds?: number;
 }) {
-  logger.info(`Waiting for an offense to be detected`);
+  const targetOffenseCount = waitUntilOffenseCount ?? 1;
+  logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
   const offenses = await retryUntil(
     async () => {
       const offenses = await nodeAdmin.getSlashOffenses('all');
-      if (offenses.length > 0) {
+      if (offenses.length >= targetOffenseCount) {
         return offenses;
       }
     },
     'non-empty offenses',
-    60,
+    timeoutSeconds,
   );
   logger.info(
     `Hit ${offenses.length} offenses on rounds ${unique(offenses.map(o => getRoundForOffense(o, { slashingRoundSize, epochDuration })))}`,
-    offenses,
+    { offenses },
   );
   return offenses;
 }
@@ -200,8 +190,9 @@ export async function awaitCommitteeKicked({
   slashingProposer,
   slashingRoundSize,
   aztecSlotDuration,
+  aztecEpochDuration,
   logger,
-  dateProvider,
+  offenseEpoch,
 }: {
   rollup: RollupContract;
   cheatCodes: RollupCheatCodes;
@@ -210,20 +201,22 @@ export async function awaitCommitteeKicked({
   slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
   slashingRoundSize: number;
   aztecSlotDuration: number;
-  dateProvider: TestDateProvider;
+  aztecEpochDuration: number;
   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.advanceToNextEpoch({ updateDateProvider: dateProvider });
-  await cheatCodes.advanceToNextEpoch({ 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();
@@ -238,6 +231,15 @@ 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();
@@ -248,7 +250,7 @@ export async function awaitCommitteeKicked({
     expect(attesterInfo.status).toEqual(1); // Validating
   }
 
-  const timeout = slashingRoundSize * 2 * aztecSlotDuration;
+  const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
   logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
   await awaitProposalExecution(slashingProposer, timeout, logger);
 
@@ -265,10 +267,9 @@ export async function awaitCommitteeKicked({
     expect(attesterInfo.status).toEqual(2); // Living
   }
 
-  logger.info(`Advancing two epochs to check current committee`);
+  logger.info(`Advancing to check current committee`);
   await cheatCodes.debugRollup();
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
-  await cheatCodes.advanceToNextEpoch({ updateDateProvider: dateProvider });
+  await cheatCodes.advanceToEpoch((await cheatCodes.getEpoch()) + (await rollup.getLagInEpochs()) + 1n);
   await cheatCodes.debugRollup();
 
   const committeeNextEpoch = await rollup.getCurrentEpochCommittee();

package/src/e2e_token_contract/token_contract_test.ts

@@ -1,7 +1,9 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, AztecAddress, type AztecNode, type Logger, createLogger } from '@aztec/aztec.js';
+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 { 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';
 
@@ -28,11 +30,9 @@ export class TokenContractTest {
   node!: AztecNode;
 
   badAccount!: InvalidAccountContract;
-  admin!: AccountWallet;
+  wallet!: TestWallet;
   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),
-      async ({ deployedAccounts }, { pxe, aztecNode }) => {
+      ({ deployedAccounts }, { wallet, aztecNode }) => {
         this.node = aztecNode;
-        const wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        [this.admin, this.account1, this.account2] = wallets;
-        [this.adminAddress, this.account1Address, this.account2Address] = wallets.map(w => w.getAddress());
+        this.wallet = wallet;
+        [this.adminAddress, this.account1Address, this.account2Address] = deployedAccounts.map(acc => acc.address);
+        return Promise.resolve();
       },
     );
 
@@ -68,11 +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.admin, [this.adminAddress, this.account1Address]);
+        await publicDeployAccounts(this.wallet, [this.adminAddress, this.account1Address]);
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.admin,
+          this.wallet,
           this.adminAddress,
           TokenContractTest.TOKEN_NAME,
           TokenContractTest.TOKEN_SYMBOL,
@@ -83,22 +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.admin).send({ from: this.adminAddress }).deployed();
+        this.badAccount = await InvalidAccountContract.deploy(this.wallet).send({ from: this.adminAddress }).deployed();
         this.logger.verbose(`Deployed to ${this.badAccount.address}.`);
 
         return { tokenContractAddress: asset.address, badAccountAddress: this.badAccount.address };
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.admin);
+        this.asset = await TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
-        this.tokenSim = new TokenSimulator(this.asset, this.admin, this.adminAddress, this.logger, [
+        this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
           this.adminAddress,
           this.account1Address,
         ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.admin);
+        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
         this.logger.verbose(`Bad account address: ${this.badAccount.address}`);
 
         expect(await this.asset.methods.get_admin().simulate({ from: this.adminAddress })).toBe(
@@ -131,14 +131,14 @@ export class TokenContractTest {
     await this.snapshotManager.snapshot(
       'mint',
       async () => {
-        const { asset, admin, adminAddress } = this;
+        const { asset, adminAddress } = this;
         const amount = 10000n;
 
         this.logger.verbose(`Minting ${amount} publicly...`);
         await asset.methods.mint_to_public(adminAddress, amount).send({ from: adminAddress }).wait();
 
         this.logger.verbose(`Minting ${amount} privately...`);
-        await mintTokensToPrivate(asset, adminAddress, admin, adminAddress, amount);
+        await mintTokensToPrivate(asset, adminAddress, adminAddress, amount);
         this.logger.verbose(`Minting complete.`);
 
         return { amount };

package/src/fixtures/e2e_prover_test.ts

@@ -1,19 +1,8 @@
-import {
-  SchnorrAccountContractArtifact,
-  getSchnorrAccount,
-  getSchnorrWalletWithSecretKey,
-} from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
-import {
-  type AccountWalletWithSecretKey,
-  type AztecNode,
-  type CompleteAddress,
-  EthAddress,
-  type Logger,
-  type PXE,
-  createLogger,
-} from '@aztec/aztec.js';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
 import { CheatCodes } from '@aztec/aztec/testing';
 import {
   BBCircuitVerifier,
@@ -29,8 +18,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';
@@ -46,12 +35,12 @@ import {
   deployAccounts,
   publicDeployAccounts,
 } from './snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEService } from './utils.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEAndGetWallet } from './utils.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
 
 type ProvenSetup = {
-  pxe: PXE;
+  wallet: TestWallet;
   teardown: () => Promise<void>;
 };
 
@@ -68,21 +57,21 @@ export class FullProverTest {
   static TOKEN_DECIMALS = 18n;
   private snapshotManager: ISnapshotManager;
   logger: Logger;
-  deployedAccounts: InitialAccountData[] = [];
-  wallets: AccountWalletWithSecretKey[] = [];
-  accounts: CompleteAddress[] = [];
+  wallet!: TestWallet;
+  provenWallet!: TestWallet;
+  accounts: AztecAddress[] = [];
+  deployedAccounts!: InitialAccountData[];
   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;
-  provenAssets: TokenContract[] = [];
+  provenAsset!: TokenContract;
   private context!: SubsystemsContext;
   private proverNode!: ProverNode;
   private simulatedProverNode!: ProverNode;
@@ -115,13 +104,11 @@ export class FullProverTest {
     await this.snapshotManager.snapshot(
       '2_accounts',
       deployAccounts(2, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
+      ({ deployedAccounts }, { wallet }) => {
         this.deployedAccounts = deployedAccounts;
-        this.wallets = await Promise.all(
-          deployedAccounts.map(a => getSchnorrWalletWithSecretKey(pxe, a.secret, a.signingKey, a.salt)),
-        );
-        this.accounts = this.wallets.map(w => w.getCompleteAddress());
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
+        this.accounts = deployedAccounts.map(a => a.address);
+        this.wallet = wallet;
+        return Promise.resolve();
       },
     );
 
@@ -131,17 +118,17 @@ export class FullProverTest {
         // Create the token contract state.
         // Move this account thing to addAccounts above?
         this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
+        await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
         const asset = await TokenContract.deploy(
-          this.wallets[0],
+          this.wallet,
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send({ from: this.wallets[0].getAddress() })
+          .send({ from: this.accounts[0] })
           .deployed();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
@@ -149,19 +136,19 @@ export class FullProverTest {
       },
       async ({ tokenContractAddress }) => {
         // Restore the token contract state.
-        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
-          this.wallets[0],
-          this.wallets[0].getAddress(),
+          this.wallet,
+          this.accounts[0],
           this.logger,
-          this.accounts.map(a => a.address),
+          this.accounts,
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0].address })).toBe(
-          this.accounts[0].address.toBigInt(),
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
+          this.accounts[0].toBigInt(),
         );
       },
     );
@@ -175,7 +162,6 @@ export class FullProverTest {
 
     this.simulatedProverNode = this.context.proverNode!;
     ({
-      pxe: this.pxe,
       aztecNode: this.aztecNode,
       deployL1ContractsValues: this.l1Contracts,
       cheatCodes: this.cheatCodes,
@@ -224,51 +210,31 @@ export class FullProverTest {
     await this.context.cheatCodes.rollup.markAsProven();
 
     this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
-    for (let i = 0; i < 2; i++) {
-      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 { 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);
 
-      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);
+    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 asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
+    this.provenComponents.push({
+      wallet: provenWallet,
+      teardown: provenTeardown,
+    });
+    this.provenAsset = asset;
+    this.provenWallet = provenWallet;
     this.logger.info(`Full prover PXE started`);
 
     // Shutdown the current, simulated prover node
@@ -308,6 +274,7 @@ export class FullProverTest {
       txGatheringMaxParallelRequestsPerNode: 100,
       txGatheringTimeoutMs: 24_000,
       proverNodeFailedEpochStore: undefined,
+      proverNodeEpochProvingDelayMs: undefined,
     };
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
     const { prefilledPublicData } = await getGenesisValues(
@@ -368,15 +335,12 @@ export class FullProverTest {
 
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
-          .mint_to_public(accounts[0].address, privateAmount + publicAmount)
-          .send({ from: accounts[0].address })
+          .mint_to_public(accounts[0], privateAmount + publicAmount)
+          .send({ from: accounts[0] })
           .wait();
 
         this.logger.verbose(`Transferring ${privateAmount} to private...`);
-        await asset.methods
-          .transfer_to_private(accounts[0].address, privateAmount)
-          .send({ from: accounts[0].address })
-          .wait();
+        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] }).wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -385,7 +349,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';
+import type { Logger } from '@aztec/aztec.js/log';
 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,10 +1,11 @@
-import { type Logger, fileURLToPath } from '@aztec/aztec.js';
+import type { Logger } from '@aztec/aztec.js/log';
 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',
@@ -22,7 +23,7 @@ export const getBBConfig = async (
   try {
     const bbBinaryPath =
       BB_BINARY_PATH ??
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb');
+      path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../', BB_RELEASE_DIR, 'bb-avm');
     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';
+import type { Logger } from '@aztec/aztec.js/log';
 import { type DeployL1ContractsArgs, type L1ContractsConfig, deployL1Contracts } from '@aztec/ethereum';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } 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(),
-    protocolContractTreeRoot,
+    protocolContractsHash,
     salt: undefined,
     realVerifier: false,
     ...args,