@aztec/end-to-end 0.0.1-commit.24de95ac → 0.0.1-commit.5daedc8

package/src/bench/client_flows/data_extractor.ts

@@ -1,6 +1,4 @@
-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 { BBBundlePrivateKernelProver } from '@aztec/bb-prover/client/bundle';
 import { createLogger, logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import { WASMSimulator } from '@aztec/simulator/client';
@@ -11,26 +9,7 @@ import { Decoder } from 'msgpackr';
 import { readFile, readdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
-import { type Log, type ProverType, ProxyLogger, generateBenchmark } from './benchmark.js';
-
-type NativeProverConfig = { bbBinaryPath?: string; bbWorkingDirectory?: string };
-
-async function createProver(config: NativeProverConfig = {}, log: Logger) {
-  const simulator = new WASMSimulator();
-  if (!config.bbBinaryPath || !config.bbWorkingDirectory) {
-    return { prover: new BBWASMBundlePrivateKernelProver(simulator, 16, log), type: 'wasm' as ProverType };
-  } else {
-    const bbConfig = config as Required<NativeProverConfig>;
-    return {
-      prover: await BBNativePrivateKernelProver.new(
-        { bbSkipCleanup: false, numConcurrentIVCVerifiers: 1, bbIVCConcurrency: 1, ...bbConfig },
-        simulator,
-        log,
-      ),
-      type: 'native' as ProverType,
-    };
-  }
-}
+import { type Log, ProxyLogger, generateBenchmark } from './benchmark.js';
 
 async function main() {
   ProxyLogger.create();
@@ -41,10 +20,9 @@ async function main() {
   }
   const flows = await readdir(ivcFolder);
   logger.info(`Flows in ${ivcFolder}: \n${flows.map(flowName => `\t- ${flowName}`).join('\n')}`);
-  const { prover, type: proverType } = await createProver(
-    { bbBinaryPath: process.env.BB_BINARY_PATH, bbWorkingDirectory: process.env.BB_WORKING_DIRECTORY },
-    proxyLogger.createLogger('bb:prover'),
-  );
+  const simulator = new WASMSimulator();
+  const log = proxyLogger.createLogger('bb:prover');
+  const prover = new BBBundlePrivateKernelProver(simulator, log);
 
   const userLog = createLogger('chonk_flows:data_processor');
 
@@ -96,7 +74,7 @@ async function main() {
     if (!(profile.stats.timings as ProvingTimings).proving) {
       (profile.stats.timings as ProvingTimings).proving = provingTime;
     }
-    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, proverType, error);
+    const benchmark = generateBenchmark(flow, currentLogs, profile.stats, privateExecutionSteps, 'native', error);
     await writeFile(join(ivcFolder, flow, 'benchmark.json'), JSON.stringify(benchmark, null, 2));
     proxyLogger.flushLogs();
   }

package/src/e2e_blacklist_token_contract/blacklist_token_contract_test.ts

@@ -130,7 +130,7 @@ export class BlacklistTokenContractTest {
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenBlacklistContract.at(tokenContractAddress, this.wallet);
+        this.asset = TokenBlacklistContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
         this.tokenSim = new TokenSimulator(
@@ -141,7 +141,7 @@ export class BlacklistTokenContractTest {
           [this.adminAddress, this.otherAddress, this.blacklistedAddress],
         );
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
+        this.badAccount = 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(

package/src/e2e_cross_chain_messaging/cross_chain_messaging_test.ts

@@ -134,9 +134,9 @@ export class CrossChainMessagingTest {
 
         return this.crossChainTestHarness.toCrossChainContext();
       },
-      async crossChainContext => {
-        this.l2Token = await TokenContract.at(crossChainContext.l2Token, this.wallet);
-        this.l2Bridge = await TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
+      crossChainContext => {
+        this.l2Token = TokenContract.at(crossChainContext.l2Token, this.wallet);
+        this.l2Bridge = TokenBridgeContract.at(crossChainContext.l2Bridge, this.wallet);
 
         // There is an issue with the reviver so we are getting strings sometimes. Working around it here.
         this.ethAccount = EthAddress.fromString(crossChainContext.ethAccount.toString());
@@ -172,6 +172,7 @@ export class CrossChainMessagingTest {
         this.l1Client = l1Client;
         this.inbox = inbox;
         this.outbox = outbox;
+        return Promise.resolve();
       },
     );
   }

package/src/e2e_deploy_contract/deploy_test.ts

@@ -73,6 +73,6 @@ export class DeployTest {
 export type StatefulContractCtorArgs = Parameters<StatefulTestContract['methods']['constructor']>;
 
 export type ContractArtifactClass<T extends ContractBase> = {
-  at(address: AztecAddress, wallet: Wallet): Promise<T>;
+  at(address: AztecAddress, wallet: Wallet): T;
   artifact: ContractArtifact;
 };

package/src/e2e_epochs/epochs_test.ts

@@ -9,6 +9,7 @@ import { EpochCache } from '@aztec/epoch-cache';
 import { DefaultL1ContractsConfig, type ExtendedViemWalletClient, createExtendedL1Client } from '@aztec/ethereum';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import { ChainMonitor, DelayedTxUtils, type Delayer, waitUntilL1Timestamp, withDelayer } from '@aztec/ethereum/test';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { withLogNameSuffix } from '@aztec/foundation/log';
@@ -279,7 +280,7 @@ export class EpochsTestContext {
 
   /** Waits until the epoch begins (ie until the immediately previous L1 block is mined). */
   public async waitUntilEpochStarts(epoch: number) {
-    const [start] = getTimestampRangeForEpoch(BigInt(epoch), this.constants);
+    const [start] = getTimestampRangeForEpoch(EpochNumber(epoch), this.constants);
     this.logger.info(`Waiting until L1 timestamp ${start} is reached as the start of epoch ${epoch}`);
     await waitUntilL1Timestamp(
       this.l1Client,
@@ -293,7 +294,7 @@ export class EpochsTestContext {
   /** Waits until the given L2 block number is mined. */
   public async waitUntilL2BlockNumber(target: number, timeout = 60) {
     await retryUntil(
-      () => Promise.resolve(target <= this.monitor.l2BlockNumber),
+      () => Promise.resolve(target <= this.monitor.checkpointNumber),
       `Wait until L2 block ${target}`,
       timeout,
       0.1,
@@ -303,17 +304,17 @@ export class EpochsTestContext {
   /** Waits until the given L2 block number is marked as proven. */
   public async waitUntilProvenL2BlockNumber(t: number, timeout = 60) {
     await retryUntil(
-      () => Promise.resolve(t <= this.monitor.l2ProvenBlockNumber),
+      () => Promise.resolve(t <= this.monitor.provenCheckpointNumber),
       `Wait proven L2 block ${t}`,
       timeout,
       0.1,
     );
-    return this.monitor.l2ProvenBlockNumber;
+    return this.monitor.provenCheckpointNumber;
   }
 
   /** Waits until the last slot of the proof submission window for a given epoch. */
   public async waitUntilLastSlotOfProofSubmissionWindow(epochNumber: number | bigint) {
-    const deadline = getProofSubmissionDeadlineTimestamp(BigInt(epochNumber), this.constants);
+    const deadline = getProofSubmissionDeadlineTimestamp(EpochNumber.fromBigInt(BigInt(epochNumber)), this.constants);
     const oneSlotBefore = deadline - BigInt(this.constants.slotDuration);
     const date = new Date(Number(oneSlotBefore) * 1000);
     this.logger.info(`Waiting until last slot of submission window for epoch ${epochNumber} at ${date}`, {

package/src/e2e_fees/bridging_race.notest.ts

@@ -60,7 +60,7 @@ describe('e2e_fees bridging_race', () => {
     const origApprove = l1TokenManager.approve.bind(l1TokenManager);
     l1TokenManager.approve = async (amount: bigint, address: Hex, addressName = '') => {
       await origApprove(amount, address, addressName);
-      const sleepTime = (Number(t.chainMonitor.l2BlockTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
+      const sleepTime = (Number(t.chainMonitor.checkpointTimestamp) + AZTEC_SLOT_DURATION) * 1000 - Date.now() - 500;
       logger.info(`Sleeping for ${sleepTime}ms until near end of L2 slot before sending L1 fee juice to L2 inbox`);
       await sleep(sleepTime);
     };

package/src/e2e_fees/fees_test.ts

@@ -136,7 +136,7 @@ export class FeesTest {
   }
 
   async getBlockRewards() {
-    const blockReward = await this.rollupContract.getBlockReward();
+    const blockReward = await this.rollupContract.getCheckpointReward();
     const rewardConfig = await this.rollupContract.getRewardConfig();
 
     const balance = await this.feeJuiceBridgeTestHarness.getL1FeeJuiceBalance(
@@ -197,7 +197,7 @@ export class FeesTest {
         this.fpcAdmin = this.aliceAddress;
 
         const canonicalFeeJuice = await getCanonicalFeeJuice();
-        this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
+        this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
       },
     );
   }
@@ -215,7 +215,7 @@ export class FeesTest {
       async (_data, context) => {
         this.context = context;
 
-        this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
+        this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
 
         this.getGasBalanceFn = getBalancesFn(
           '⛽',
@@ -245,8 +245,8 @@ export class FeesTest {
         this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
         return { bananaCoinAddress: bananaCoin.address };
       },
-      async ({ bananaCoinAddress }) => {
-        this.bananaCoin = await BananaCoin.at(bananaCoinAddress, this.wallet);
+      ({ bananaCoinAddress }) => {
+        this.bananaCoin = BananaCoin.at(bananaCoinAddress, this.wallet);
         const logger = this.logger;
         this.getBananaPublicBalanceFn = getBalancesFn(
           '🍌.public',
@@ -260,6 +260,7 @@ export class FeesTest {
           this.aliceAddress,
           logger,
         );
+        return Promise.resolve();
       },
     );
   }
@@ -287,8 +288,8 @@ export class FeesTest {
           rollupAddress: context.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
         };
       },
-      async (data, context) => {
-        const bananaFPC = await FPCContract.at(data.bananaFPCAddress, this.wallet);
+      (data, context) => {
+        const bananaFPC = FPCContract.at(data.bananaFPCAddress, this.wallet);
         this.bananaFPC = bananaFPC;
 
         this.getCoinbaseBalance = async () => {
@@ -328,6 +329,7 @@ export class FeesTest {
           const mana = block!.header.totalManaUsed.toBigInt();
           return mulDiv(mana * proverCost, price, 10n ** 9n);
         };
+        return Promise.resolve();
       },
     );
   }
@@ -346,8 +348,9 @@ export class FeesTest {
           sponsoredFPCAddress: sponsoredFPC.address,
         };
       },
-      async data => {
-        this.sponsoredFPC = await SponsoredFPCContract.at(data.sponsoredFPCAddress, this.wallet);
+      data => {
+        this.sponsoredFPC = SponsoredFPCContract.at(data.sponsoredFPCAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }

package/src/e2e_l1_publisher/write_json.ts

@@ -1,7 +1,7 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { L2Block } from '@aztec/aztec.js/block';
 import { Fr } from '@aztec/aztec.js/fields';
-import { BatchedBlob, Blob, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { BatchedBlob, Blob, getEthBlobEvaluationInputs, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 import { writeFile } from 'fs/promises';
@@ -41,16 +41,17 @@ export async function writeJson(
     messages: {
       l2ToL1Messages: block.body.txEffects.flatMap(txEffect => txEffect.l2ToL1Msgs).map(value => asHex(value)),
     },
-    block: {
+    checkpoint: {
       // The json formatting in forge is a bit brittle, so we convert Fr to a number in the few values below.
       // This should not be a problem for testing as long as the values are not larger than u32.
       archive: asHex(block.archive.root),
       blobCommitments: getPrefixedEthBlobCommitments(blobs),
-      batchedBlobInputs: batchedBlob.getEthBlobEvaluationInputs(),
-      blockNumber: block.number,
+      batchedBlobInputs: getEthBlobEvaluationInputs(batchedBlob),
+      checkpointNumber: block.number,
       body: `0x${block.body.toBuffer().toString('hex')}`,
       header: {
         lastArchiveRoot: asHex(block.header.lastArchive.root),
+        blockHeadersHash: asHex(block.header.blockHeadersHash),
         contentCommitment: {
           blobsHash: asHex(block.header.contentCommitment.blobsHash),
           inHash: asHex(block.header.contentCommitment.inHash),

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -86,9 +86,10 @@ export class NestedContractTest {
           .deployed();
         return { parentContractAddress: parentContract.address, childContractAddress: childContract.address };
       },
-      async ({ parentContractAddress, childContractAddress }) => {
-        this.parentContract = await ParentContract.at(parentContractAddress, this.wallet);
-        this.childContract = await ChildContract.at(childContractAddress, this.wallet);
+      ({ parentContractAddress, childContractAddress }) => {
+        this.parentContract = ParentContract.at(parentContractAddress, this.wallet);
+        this.childContract = ChildContract.at(childContractAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -1,6 +1,7 @@
 import type { AztecNodeService } from '@aztec/aztec-node';
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import { RollupContract } from '@aztec/ethereum';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 
 import fs from 'fs';
 import 'jest-extended';
@@ -150,8 +151,11 @@ export class P2PInactivityTest {
     // 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);
+    const ethereumSlotDuration = this.test.ctx.aztecNodeConfig.ethereumSlotDuration!;
+    this.test.logger.warn(`Advancing to the L1 slot before epoch ${SETUP_EPOCH_DURATION + 1} to start slashing`);
+    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(EpochNumber(SETUP_EPOCH_DURATION + 1), {
+      offset: -ethereumSlotDuration,
+    });
 
     return this;
   }

package/src/e2e_p2p/p2p_network.ts

@@ -16,6 +16,7 @@ import {
   getL1ContractsConfigEnvVars,
 } from '@aztec/ethereum';
 import { ChainMonitor } from '@aztec/ethereum/test';
+import { EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
@@ -292,7 +293,9 @@ export class P2PNetworkTest {
       });
 
       await cheatCodes.rollup.advanceToEpoch(
-        (await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochs()) + 1n,
+        EpochNumber.fromBigInt(
+          BigInt(await cheatCodes.rollup.getEpoch()) + (await rollup.read.getLagInEpochsForValidatorSet()) + 1n,
+        ),
       );
 
       // Send and await a tx to make sure we mine a block for the warp to correctly progress.
@@ -326,11 +329,12 @@ export class P2PNetworkTest {
           .deployed();
         return { contractAddress: spamContract.address };
       },
-      async ({ contractAddress }) => {
+      ({ contractAddress }) => {
         if (!this.wallet) {
           throw new Error('Call snapshot t.setupAccount before deploying account contract');
         }
-        this.spamContract = await SpamContract.at(contractAddress, this.wallet);
+        this.spamContract = SpamContract.at(contractAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }

package/src/e2e_p2p/shared.ts

@@ -7,6 +7,7 @@ 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 { EpochNumber } from '@aztec/foundation/branded-types';
 import { timesAsync, unique } from '@aztec/foundation/collection';
 import { retryUntil } from '@aztec/foundation/retry';
 import { pluralize } from '@aztec/foundation/string';
@@ -80,7 +81,7 @@ export async function prepareTransactions(
     salt: Fr.random(),
   });
   await wallet.registerContract(testContractInstance, TestContractArtifact);
-  const contract = await TestContract.at(testContractInstance.address, wallet);
+  const contract = TestContract.at(testContractInstance.address, wallet);
 
   return timesAsync(numTxs, async () => {
     const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
@@ -213,9 +214,9 @@ export async function awaitCommitteeKicked({
 
   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;
+    const targetEpoch = BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n;
     logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
-    await cheatCodes.advanceToEpoch(targetEpoch);
+    await cheatCodes.advanceToEpoch(EpochNumber.fromBigInt(targetEpoch));
 
     const slashPayloadEvents = await retryUntil(
       async () => {
@@ -239,7 +240,7 @@ export async function awaitCommitteeKicked({
     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 });
+    await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), { offset: -aztecSlotDuration / 2 });
   }
 
   const attestersPre = await rollup.getAttesters();
@@ -269,7 +270,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(
+    EpochNumber.fromBigInt(BigInt(await cheatCodes.getEpoch()) + (await rollup.getLagInEpochsForValidatorSet()) + 1n),
+  );
   await cheatCodes.debugRollup();
 
   const committeeNextEpoch = await rollup.getCurrentEpochCommittee();

package/src/e2e_token_contract/token_contract_test.ts

@@ -90,7 +90,7 @@ export class TokenContractTest {
       },
       async ({ tokenContractAddress, badAccountAddress }) => {
         // Restore the token contract state.
-        this.asset = await TokenContract.at(tokenContractAddress, this.wallet);
+        this.asset = TokenContract.at(tokenContractAddress, this.wallet);
         this.logger.verbose(`Token contract address: ${this.asset.address}`);
 
         this.tokenSim = new TokenSimulator(this.asset, this.wallet, this.adminAddress, this.logger, [
@@ -98,7 +98,7 @@ export class TokenContractTest {
           this.account1Address,
         ]);
 
-        this.badAccount = await InvalidAccountContract.at(badAccountAddress, this.wallet);
+        this.badAccount = 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(

package/src/fixtures/e2e_prover_test.ts

@@ -10,6 +10,7 @@ import {
   QueuedIVCVerifier,
   TestCircuitVerifier,
 } from '@aztec/bb-prover';
+import { BackendType, Barretenberg } from '@aztec/bb.js';
 import { createBlobSinkClient } from '@aztec/blob-sink/client';
 import type { BlobSinkServer } from '@aztec/blob-sink/server';
 import type { DeployL1ContractsReturnType } from '@aztec/ethereum';
@@ -18,6 +19,7 @@ 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 { 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';
@@ -62,6 +64,7 @@ export class FullProverTest {
   accounts: AztecAddress[] = [];
   deployedAccounts!: InitialAccountData[];
   fakeProofsAsset!: TokenContract;
+  fakeProofsAssetInstance!: ContractInstanceWithAddress;
   tokenSim!: TokenSimulator;
   aztecNode!: AztecNode;
   aztecNodeAdmin!: AztecNodeAdmin;
@@ -121,7 +124,7 @@ export class FullProverTest {
         await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
 
         this.logger.verbose(`Deploying TokenContract...`);
-        const asset = await TokenContract.deploy(
+        const { contract: asset, instance } = await TokenContract.deploy(
           this.wallet,
           this.accounts[0],
           FullProverTest.TOKEN_NAME,
@@ -129,14 +132,15 @@ export class FullProverTest {
           FullProverTest.TOKEN_DECIMALS,
         )
           .send({ from: this.accounts[0] })
-          .deployed();
+          .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.wallet);
+        this.fakeProofsAsset = TokenContract.at(tokenContractAddress, this.wallet);
+        this.fakeProofsAssetInstance = tokenContractInstance;
         this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
 
         this.tokenSim = new TokenSimulator(
@@ -183,9 +187,7 @@ 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 });
 
       const verifier = await BBCircuitVerifier.new(bbConfig);
       this.circuitProofVerifier = new QueuedIVCVerifier(bbConfig, verifier);
@@ -212,23 +214,19 @@ export class FullProverTest {
     this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
     const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(
       this.aztecNode,
-      {
-        proverEnabled: this.realProofs,
-        bbBinaryPath: bbConfig?.bbBinaryPath,
-        bbWorkingDirectory: bbConfig?.bbWorkingDirectory,
-      },
+      { proverEnabled: this.realProofs },
       undefined,
       true,
     );
     this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
-    await provenWallet.registerContract(this.fakeProofsAsset);
+    await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
 
     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);
+    const asset = TokenContract.at(this.fakeProofsAsset.address, provenWallet);
     this.provenComponents.push({
       wallet: provenWallet,
       teardown: provenTeardown,
@@ -245,7 +243,7 @@ export class FullProverTest {
     this.logger.verbose('Starting archiver for new prover node');
     const archiver = await createArchiver(
       { ...this.context.aztecNodeConfig, dataDirectory: undefined },
-      { blobSinkClient },
+      { blobSinkClient, dateProvider: this.context.dateProvider },
       { blockUntilSync: true },
     );
 
@@ -321,6 +319,7 @@ export class FullProverTest {
     // clean up the full prover node
     await this.proverNode.stop();
 
+    await Barretenberg.destroySingleton();
     await this.bbConfigCleanup?.();
     await this.acvmConfigCleanup?.();
   }

package/src/fixtures/setup_p2p_test.ts

@@ -2,6 +2,7 @@
  * Test fixtures and utilities to set up and run a test using multiple validators
  */
 import { type AztecNodeConfig, AztecNodeService } from '@aztec/aztec-node';
+import { range } from '@aztec/foundation/array';
 import { SecretValue } from '@aztec/foundation/config';
 import { addLogNameHandler, removeLogNameHandler } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
@@ -40,6 +41,7 @@ export async function createNodes(
   dataDirectory?: string,
   metricsPort?: number,
   indexOffset = 0,
+  validatorsPerNode = 1,
 ): Promise<AztecNodeService[]> {
   const nodePromises: Promise<AztecNodeService>[] = [];
   const loggerIdStorage = new AsyncLocalStorage<string>();
@@ -52,13 +54,18 @@ export async function createNodes(
     // We run on ports from the bootnode upwards
     const port = bootNodePort + 1 + index;
 
+    // Determine validator indices for this node
+    const validatorIndices = validatorsPerNode === 1 ? index : range(validatorsPerNode, validatorsPerNode * index);
+
+    // Assign data directory
     const dataDir = dataDirectory ? `${dataDirectory}-${index}` : undefined;
+
     const nodePromise = createNode(
       config,
       dateProvider,
       port,
       bootstrapNodeEnr,
-      index,
+      validatorIndices,
       prefilledPublicData,
       dataDir,
       metricsPort,
@@ -84,7 +91,7 @@ export async function createNode(
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
-  addressIndex: number,
+  addressIndex: number | number[],
   prefilledPublicData?: PublicDataTreeLeaf[],
   dataDirectory?: string,
   metricsPort?: number,
@@ -188,16 +195,23 @@ export async function createValidatorConfig(
   config: AztecNodeConfig,
   bootstrapNodeEnr?: string,
   port?: number,
-  addressIndex: number = 1,
+  addressIndex: number | number[] = 1,
   dataDirectory?: string,
 ) {
-  const attesterPrivateKey = bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + addressIndex)!);
+  const addressIndices = Array.isArray(addressIndex) ? addressIndex : [addressIndex];
+  if (addressIndices.length === 0) {
+    throw new Error('At least one address index must be provided to create a validator config');
+  }
+
+  const attesterPrivateKeys = addressIndices.map(index =>
+    bufferToHex(getPrivateKeyFromIndex(ATTESTER_PRIVATE_KEYS_START_INDEX + index)!),
+  );
   const p2pConfig = await createP2PConfig(config, bootstrapNodeEnr, port, dataDirectory);
   const nodeConfig: AztecNodeConfig = {
     ...config,
     ...p2pConfig,
-    validatorPrivateKeys: new SecretValue([attesterPrivateKey]),
-    publisherPrivateKeys: [new SecretValue(attesterPrivateKey)],
+    validatorPrivateKeys: new SecretValue(attesterPrivateKeys),
+    publisherPrivateKeys: [new SecretValue(attesterPrivateKeys[0])],
   };
 
   return nodeConfig;

package/src/fixtures/token_utils.ts

@@ -6,9 +6,9 @@ import { TokenContract } from '@aztec/noir-contracts.js/Token';
 
 export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAdminBalance: bigint, logger: Logger) {
   logger.info(`Deploying Token contract...`);
-  const contract = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
+  const { contract, instance } = await TokenContract.deploy(wallet, admin, 'TokenName', 'TokenSymbol', 18)
     .send({ from: admin })
-    .deployed();
+    .wait();
 
   if (initialAdminBalance > 0n) {
     await mintTokensToPrivate(contract, admin, admin, initialAdminBalance);
@@ -16,7 +16,7 @@ export async function deployToken(wallet: Wallet, admin: AztecAddress, initialAd
 
   logger.info('L2 contract deployed');
 
-  return contract;
+  return { contract, instance };
 }
 
 export async function mintTokensToPrivate(
@@ -36,7 +36,7 @@ export async function expectTokenBalance(
   logger: Logger,
 ) {
   // Then check the balance
-  const contractWithWallet = await TokenContract.at(token.address, wallet);
+  const contractWithWallet = TokenContract.at(token.address, wallet);
   const balance = await contractWithWallet.methods.balance_of_private(owner).simulate({ from: owner });
   logger.info(`Account ${owner} balance: ${balance}`);
   expect(balance).toBe(expectedBalance);