@aztec/end-to-end 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/{e2e_prover → fixtures}/e2e_prover_test.ts

@@ -1,51 +1,47 @@
-import {
-  SchnorrAccountContractArtifact,
-  getSchnorrAccount,
-  getSchnorrWalletWithSecretKey,
-} from '@aztec/accounts/schnorr';
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
+import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { CheatCodes } from '@aztec/aztec/testing';
 import {
-  type AccountWalletWithSecretKey,
-  type AztecNode,
-  type CheatCodes,
-  type CompleteAddress,
-  type DeployL1ContractsReturnType,
-  EthAddress,
-  type Logger,
-  type PXE,
-  createLogger,
-  deployL1Contract,
-} from '@aztec/aztec.js';
-import { BBCircuitVerifier, type ClientProtocolCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import type { BlobSinkServer } from '@aztec/blob-sink/server';
+  BBCircuitVerifier,
+  type ClientProtocolCircuitVerifier,
+  QueuedIVCVerifier,
+  TestCircuitVerifier,
+} from '@aztec/bb-prover';
+import { BackendType, Barretenberg } from '@aztec/bb.js';
+import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import type { DeployAztecL1ContractsReturnType } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { HonkVerifierAbi, HonkVerifierBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+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 { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+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';
 import { privateKeyToAddress } from 'viem/accounts';
 
-import { getACVMConfig } from '../fixtures/get_acvm_config.js';
-import { getBBConfig } from '../fixtures/get_bb_config.js';
+import { TokenSimulator } from '../simulators/token_simulator.js';
+import { getACVMConfig } from './get_acvm_config.js';
+import { getBBConfig } from './get_bb_config.js';
 import {
   type ISnapshotManager,
   type SubsystemsContext,
   createSnapshotManager,
   deployAccounts,
   publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex, setupPXEService } from '../fixtures/utils.js';
-import { TokenSimulator } from '../simulators/token_simulator.js';
+} from './snapshot_manager.js';
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEAndGetWallet } from './utils.js';
 
 const { E2E_DATA_PATH: dataPath } = process.env;
 
 type ProvenSetup = {
-  pxe: PXE;
+  wallet: TestWallet;
   teardown: () => Promise<void>;
 };
 
@@ -62,24 +58,25 @@ 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;
+  fakeProofsAssetInstance!: ContractInstanceWithAddress;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
-  pxe!: PXEService;
+  aztecNodeAdmin!: AztecNodeAdmin;
   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;
-  public l1Contracts!: DeployL1ContractsReturnType;
+  public l1Contracts!: DeployAztecL1ContractsReturnType;
   public proverAddress!: EthAddress;
 
   constructor(
@@ -92,8 +89,10 @@ export class FullProverTest {
     this.snapshotManager = createSnapshotManager(
       `full_prover_integration/${testName}`,
       dataPath,
-      { startProverNode: true, fundRewardDistributor: true, coinbase },
-      {},
+      { startProverNode: true, coinbase },
+      {
+        realVerifier: realProofs,
+      },
     );
   }
 
@@ -106,13 +105,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();
       },
     );
 
@@ -122,35 +119,39 @@ 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), false);
+        await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        const asset = await TokenContract.deploy(
-          this.wallets[0],
+        const { contract: asset, instance } = await TokenContract.deploy(
+          this.wallet,
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
           FullProverTest.TOKEN_SYMBOL,
           FullProverTest.TOKEN_DECIMALS,
         )
-          .send()
-          .deployed();
+          .send({ from: this.accounts[0] })
+          .wait();
         this.logger.verbose(`Token deployed to ${asset.address}`);
 
-        return { tokenContractAddress: asset.address };
+        return { tokenContractAddress: asset.address, tokenContractInstance: instance };
       },
-      async ({ tokenContractAddress }) => {
+      async ({ tokenContractAddress, tokenContractInstance }) => {
         // Restore the token contract state.
-        this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallets[0]);
+        this.fakeProofsAsset = TokenContract.at(tokenContractAddress, this.wallet);
+        this.fakeProofsAssetInstance = tokenContractInstance;
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
           this.fakeProofsAsset,
-          this.wallets[0],
+          this.wallet,
+          this.accounts[0],
           this.logger,
-          this.accounts.map(a => a.address),
+          this.accounts,
         );
 
-        expect(await this.fakeProofsAsset.methods.get_admin().simulate()).toBe(this.accounts[0].address.toBigInt());
+        expect(await this.fakeProofsAsset.methods.get_admin().simulate({ from: this.accounts[0] })).toBe(
+          this.accounts[0].toBigInt(),
+        );
       },
     );
   }
@@ -163,14 +164,14 @@ export class FullProverTest {
 
     this.simulatedProverNode = this.context.proverNode!;
     ({
-      pxe: this.pxe,
       aztecNode: this.aztecNode,
       deployL1ContractsValues: this.l1Contracts,
       cheatCodes: this.cheatCodes,
-      blobSink: this.blobSink,
     } = this.context);
+    this.aztecNodeAdmin = this.context.aztecNode;
 
-    const blobSinkClient = createBlobSinkClient({ blobSinkUrl: `http://localhost:${this.blobSink.port}` });
+    const config = this.context.aztecNodeConfig;
+    const blobClient = await createBlobClientWithFileStores(config, this.logger);
 
     // Configure a full prover PXE
     let acvmConfig: Awaited<ReturnType<typeof getACVMConfig>> | undefined;
@@ -184,21 +185,20 @@ export class FullProverTest {
       this.acvmConfigCleanup = acvmConfig.cleanup;
       this.bbConfigCleanup = bbConfig.cleanup;
 
-      if (!bbConfig?.bbWorkingDirectory || !bbConfig?.bbBinaryPath) {
-        throw new Error(`Test must be run with BB native configuration`);
-      }
+      await Barretenberg.initSingleton({ backend: BackendType.NativeUnixSocket });
 
-      this.circuitProofVerifier = await BBCircuitVerifier.new(bbConfig);
+      const verifier = await BBCircuitVerifier.new(bbConfig);
+      this.circuitProofVerifier = new QueuedIVCVerifier(bbConfig, verifier);
 
       this.logger.debug(`Configuring the node for real proofs...`);
-      await this.aztecNode.setConfig({
+      await this.aztecNodeAdmin.setConfig({
         realProofs: true,
         minTxsPerBlock: this.minNumberOfTxsPerBlock,
       });
     } else {
       this.logger.debug(`Configuring the node min txs per block ${this.minNumberOfTxsPerBlock}...`);
       this.circuitProofVerifier = new TestCircuitVerifier();
-      await this.aztecNode.setConfig({
+      await this.aztecNodeAdmin.setConfig({
         minTxsPerBlock: this.minNumberOfTxsPerBlock,
       });
     }
@@ -210,51 +210,27 @@ 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 },
+      undefined,
+      true,
+    );
+    this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
+    await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
 
-      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 = 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
@@ -265,7 +241,7 @@ export class FullProverTest {
     this.logger.verbose('Starting archiver for new prover node');
     const archiver = await createArchiver(
       { ...this.context.aztecNodeConfig, dataDirectory: undefined },
-      blobSinkClient,
+      { blobClient, dateProvider: this.context.dateProvider },
       { blockUntilSync: true },
     );
 
@@ -275,46 +251,53 @@ export class FullProverTest {
     this.proverAddress = EthAddress.fromString(proverNodeSenderAddress);
 
     this.logger.verbose(`Funding prover node at ${proverNodeSenderAddress}`);
-    await this.mintL1ERC20(proverNodeSenderAddress, 100_000_000n);
+    await this.mintFeeJuice(proverNodeSenderAddress);
 
     this.logger.verbose('Starting prover node');
     const proverConfig: ProverNodeConfig = {
       ...this.context.aztecNodeConfig,
-      proverCoordinationNodeUrl: undefined,
+      txCollectionNodeRpcUrls: [],
       dataDirectory: undefined,
-      proverId: this.proverAddress.toField(),
+      proverId: this.proverAddress,
       realProofs: this.realProofs,
       proverAgentCount: 2,
-      publisherPrivateKey: `0x${proverNodePrivateKey!.toString('hex')}`,
+      publisherPrivateKeys: [new SecretValue(`0x${proverNodePrivateKey!.toString('hex')}` as const)],
       proverNodeMaxPendingJobs: 100,
       proverNodeMaxParallelBlocksPerEpoch: 32,
       proverNodePollingIntervalMs: 100,
-      txGatheringTimeoutMs: 60000,
       txGatheringIntervalMs: 1000,
-      txGatheringMaxParallelRequests: 100,
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 100,
+      txGatheringTimeoutMs: 24_000,
+      proverNodeFailedEpochStore: undefined,
+      proverNodeEpochProvingDelayMs: undefined,
     };
-    const { prefilledPublicData } = await getGenesisValues(this.context.initialFundedAccounts.map(a => a.address));
+    const sponsoredFPCAddress = await getSponsoredFPCAddress();
+    const { prefilledPublicData } = await getGenesisValues(
+      this.context.initialFundedAccounts.map(a => a.address).concat(sponsoredFPCAddress),
+    );
     this.proverNode = await createProverNode(
       proverConfig,
       {
         aztecNodeTxProvider: this.aztecNode,
         archiver: archiver as Archiver,
-        blobSinkClient,
+        blobClient,
       },
       { prefilledPublicData },
     );
-    this.proverNode.start();
+    await this.proverNode.start();
 
     this.logger.warn(`Proofs are now enabled`);
     return this;
   }
 
-  private async mintL1ERC20(recipient: Hex, amount: bigint) {
-    const erc20Address = this.context.deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress;
-    const client = this.context.deployL1ContractsValues.walletClient;
-    const erc20 = getContract({ abi: TestERC20Abi, address: erc20Address.toString(), client });
-    const hash = await erc20.write.mint([recipient, amount]);
-    await this.context.deployL1ContractsValues.publicClient.waitForTransactionReceipt({ hash });
+  private async mintFeeJuice(recipient: Hex) {
+    const handlerAddress = this.context.deployL1ContractsValues.l1ContractAddresses.feeAssetHandlerAddress!;
+    this.logger.verbose(`Minting fee juice to ${recipient} using handler at ${handlerAddress}`);
+    const client = this.context.deployL1ContractsValues.l1Client;
+    const handler = getContract({ abi: FeeAssetHandlerAbi, address: handlerAddress.toString(), client });
+    const hash = await handler.write.mint([recipient]);
+    await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash });
   }
 
   snapshot = <T>(
@@ -334,6 +317,7 @@ export class FullProverTest {
     // clean up the full prover node
     await this.proverNode.stop();
 
+    await Barretenberg.destroySingleton();
     await this.bbConfigCleanup?.();
     await this.acvmConfigCleanup?.();
   }
@@ -346,16 +330,14 @@ export class FullProverTest {
         const privateAmount = 10000n;
         const publicAmount = 10000n;
 
-        const waitOpts = { proven: false };
-
         this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
         await asset.methods
-          .mint_to_public(accounts[0].address, privateAmount + publicAmount)
-          .send()
-          .wait(waitOpts);
+          .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().wait(waitOpts);
+        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({ from: accounts[0] }).wait();
 
         this.logger.verbose(`Minting complete.`);
 
@@ -364,21 +346,21 @@ export class FullProverTest {
       async ({ amount }) => {
         const {
           fakeProofsAsset: asset,
-          accounts: [{ address }],
+          accounts: [address],
           tokenSim,
         } = this;
         tokenSim.mintPublic(address, amount);
 
-        const publicBalance = await asset.methods.balance_of_public(address).simulate();
+        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(address));
 
         tokenSim.mintPrivate(address, amount);
-        const privateBalance = await asset.methods.balance_of_private(address).simulate();
+        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(address));
 
-        const totalSupply = await asset.methods.total_supply().simulate();
+        const totalSupply = await asset.methods.total_supply().simulate({ from: address });
         this.logger.verbose(`Total supply: ${totalSupply}`);
         expect(totalSupply).toEqual(tokenSim.totalSupply);
 
@@ -386,33 +368,4 @@ export class FullProverTest {
       },
     );
   }
-
-  async deployVerifier() {
-    if (!this.realProofs) {
-      return;
-    }
-
-    if (!this.circuitProofVerifier) {
-      throw new Error('No verifier');
-    }
-
-    const { walletClient, publicClient, l1ContractAddresses } = this.context.deployL1ContractsValues;
-    const rollup = getContract({
-      abi: RollupAbi,
-      address: l1ContractAddresses.rollupAddress.toString(),
-      client: walletClient,
-    });
-
-    const { address: verifierAddress } = await deployL1Contract(
-      walletClient,
-      publicClient,
-      HonkVerifierAbi,
-      HonkVerifierBytecode,
-    );
-    this.logger.info(`Deployed honk verifier at ${verifierAddress}`);
-
-    await rollup.write.setEpochVerifier([verifierAddress.toString()]);
-
-    this.logger.info('Rollup only accepts valid proofs now');
-  }
 }

package/src/fixtures/fixtures.ts

@@ -8,21 +8,19 @@ export const shouldCollectMetrics = () => {
 };
 
 export const TEST_PEER_CHECK_INTERVAL_MS = 1000;
+export const TEST_MAX_TX_POOL_SIZE = 2 * 1024 * 1024 * 1024; // 2GB
 
 export const MNEMONIC = 'test test test test test test test test test test test junk';
 export const privateKey = Buffer.from('ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', 'hex');
 export const privateKey2 = Buffer.from('59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d', 'hex');
 
 /// Common errors
-export const U128_UNDERFLOW_ERROR = "Assertion failed: attempt to subtract with overflow 'self - other'";
-export const U128_OVERFLOW_ERROR = "Assertion failed: attempt to add with overflow 'self + other'";
+export const U128_UNDERFLOW_ERROR = 'Assertion failed: attempt to subtract with overflow';
+export const U128_OVERFLOW_ERROR = 'Assertion failed: attempt to add with overflow';
 export const BITSIZE_TOO_BIG_ERROR = "Assertion failed: call to assert_max_bit_size 'self.__assert_max_bit_size'";
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): Make these a fixed error after transition.
-export const DUPLICATE_NULLIFIER_ERROR = /dropped|duplicate nullifier|reverted|Nullifier collision/;
+export const DUPLICATE_NULLIFIER_ERROR = /dropped|nullifier|reverted/i;
 export const NO_L1_TO_L2_MSG_ERROR =
   /No non-nullified L1 to L2 message found for message hash|Tried to consume nonexistent L1-to-L2 message/;
-export const STATIC_CALL_STATE_MODIFICATION_ERROR =
-  /Static call cannot update the state, emit L2->L1 messages or generate logs.*/;
+export const STATIC_CALL_STATE_MODIFICATION_ERROR = /Static call cannot update the state.*/;
 export const STATIC_CONTEXT_ASSERTION_ERROR = /Assertion failed: Function .* can only be called statically.*/;
-
-export const DEFAULT_BLOB_SINK_PORT = '5052';

package/src/fixtures/get_acvm_config.ts

@@ -1,6 +1,7 @@
-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 { randomBytes } from '@aztec/foundation/crypto/random';
+import { tryRmDir } from '@aztec/foundation/fs';
 
 import { promises as fs } from 'fs';
 
@@ -36,16 +37,7 @@ export async function getACVMConfig(logger: Logger): Promise<
 
     const directoryToCleanup = ACVM_WORKING_DIRECTORY ? undefined : tempWorkingDirectory;
 
-    const cleanup = async () => {
-      if (directoryToCleanup) {
-        try {
-          logger.info(`Cleaning up ACVM temp directory ${directoryToCleanup}`);
-          await fs.rm(directoryToCleanup, { recursive: true, force: true, maxRetries: 3 });
-        } catch (err) {
-          logger.warn(`Failed to delete ACVM temp directory at ${directoryToCleanup}: ${err}`);
-        }
-      }
-    };
+    const cleanup = () => tryRmDir(directoryToCleanup, logger);
 
     return {
       acvmWorkingDirectory,

package/src/fixtures/get_bb_config.ts

@@ -1,9 +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',
@@ -11,6 +13,8 @@ const {
   BB_SKIP_CLEANUP = '',
   TEMP_DIR = tmpdir(),
   BB_WORKING_DIRECTORY = '',
+  BB_NUM_IVC_VERIFIERS = '1',
+  BB_IVC_CONCURRENCY = '1',
 } = process.env;
 
 export const getBBConfig = async (
@@ -19,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;
@@ -35,18 +39,19 @@ export const getBBConfig = async (
     await fs.mkdir(bbWorkingDirectory, { recursive: true });
 
     const bbSkipCleanup = ['1', 'true'].includes(BB_SKIP_CLEANUP);
-
-    const cleanup = async () => {
-      if (directoryToCleanup && !bbSkipCleanup) {
-        try {
-          await fs.rm(directoryToCleanup, { recursive: true, force: true, maxRetries: 3 });
-        } catch (err) {
-          logger.warn(`Failed to delete bb working directory at ${directoryToCleanup}: ${err}`);
-        }
-      }
+    const cleanup = bbSkipCleanup ? () => Promise.resolve() : () => tryRmDir(directoryToCleanup);
+
+    const numIvcVerifiers = Number(BB_NUM_IVC_VERIFIERS);
+    const ivcConcurrency = Number(BB_IVC_CONCURRENCY);
+
+    return {
+      bbSkipCleanup,
+      bbBinaryPath,
+      bbWorkingDirectory,
+      cleanup,
+      numConcurrentIVCVerifiers: numIvcVerifiers,
+      bbIVCConcurrency: ivcConcurrency,
     };
-
-    return { bbSkipCleanup, bbBinaryPath, bbWorkingDirectory, cleanup };
   } catch (err) {
     logger.error(`Native BB not available, error: ${err}`);
     return undefined;