@aztec/end-to-end 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/fixtures/utils.ts

@@ -1,48 +1,27 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import {
-  type InitialAccountData,
-  deployFundedSchnorrAccounts,
-  generateSchnorrAccounts,
-  getDeployedTestAccounts,
-  getDeployedTestAccountsWallets,
-} from '@aztec/accounts/testing';
+import { type InitialAccountData, generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type Archiver, createArchiver } from '@aztec/archiver';
 import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import {
-  AccountManager,
-  type AccountWalletWithSecretKey,
-  type AztecAddress,
-  type AztecNode,
-  BatchCall,
-  type ContractMethod,
-  type Logger,
-  type PXE,
-  type Wallet,
-  createAztecNodeClient,
-  createLogger,
-  createPXEClient,
-  makeFetch,
-  sleep,
-  waitForPXE,
-} from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, type ContractMethod } from '@aztec/aztec.js/contracts';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { Fr } from '@aztec/aztec.js/fields';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import { type AztecNode, createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
+import type { Wallet } from '@aztec/aztec.js/wallet';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { type BlobSinkServer, createBlobSinkServer } from '@aztec/blob-sink/server';
-import { GENESIS_ARCHIVE_ROOT, SPONSORED_FPC_SALT } from '@aztec/constants';
+import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
+import { SPONSORED_FPC_SALT } from '@aztec/constants';
+import { isAnvilTestChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { NULL_KEY } from '@aztec/ethereum/constants';
 import {
-  type DeployL1ContractsArgs,
-  type DeployL1ContractsReturnType,
-  FeeAssetArtifact,
-  NULL_KEY,
+  type DeployAztecL1ContractsReturnType,
   type Operator,
-  RollupContract,
-  createExtendedL1Client,
-  deployL1Contracts,
-  deployMulticall3,
-  getL1ContractsConfigEnvVars,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
+  type ZKPassportArgs,
+  deployAztecL1Contracts,
+} from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import {
   DelayedTxUtils,
   EthCheatCodes,
@@ -50,31 +29,24 @@ import {
   createDelayedL1TxUtilsFromViemWallet,
   startAnvil,
 } from '@aztec/ethereum/test';
+import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
-import { randomBytes } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { tryRmDir } from '@aztec/foundation/fs';
 import { withLogNameSuffix } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { P2PClientDeps } from '@aztec/p2p';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { type ProverNode, type ProverNodeConfig, type ProverNodeDeps, createProverNode } from '@aztec/prover-node';
-import {
-  type PXEService,
-  type PXEServiceConfig,
-  createPXEServiceWithSimulator,
-  getPXEServiceConfig,
-} from '@aztec/pxe/server';
+import { type PXEConfig, getPXEConfig } from '@aztec/pxe/server';
 import type { SequencerClient } from '@aztec/sequencer-client';
 import type { TestSequencerClient } from '@aztec/sequencer-client/test';
-import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
-import { FileCircuitRecorder } from '@aztec/simulator/testing';
 import {
   type ContractInstanceWithAddress,
   getContractClassFromArtifact,
@@ -91,16 +63,23 @@ import {
   initTelemetryClient,
 } from '@aztec/telemetry-client';
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import type { Anvil } from '@viem/anvil';
+import { randomBytes } from 'crypto';
 import fs from 'fs/promises';
-import getPort from 'get-port';
 import { tmpdir } from 'os';
 import * as path from 'path';
-import { type Chain, type HDAccount, type Hex, type PrivateKeyAccount, getContract } from 'viem';
-import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
+import type { Hex } from 'viem';
+import {
+  type HDAccount,
+  type PrivateKeyAccount,
+  generatePrivateKey,
+  mnemonicToAccount,
+  privateKeyToAccount,
+} from 'viem/accounts';
+import { type Chain, foundry } from 'viem/chains';
 
 import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
@@ -110,14 +89,24 @@ import { isMetricsLoggingRequested, setupMetricsLogger } from './logging.js';
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 export { startAnvil };
 
-const { PXE_URL = '' } = process.env;
-const getAztecUrl = () => PXE_URL;
+/**
+ * Sets up shared blob storage using FileStore in the data directory.
+ */
+export async function setupSharedBlobStorage(config: { dataDirectory?: string } & Record<string, any>): Promise<void> {
+  const sharedBlobPath = path.join(config.dataDirectory!, 'shared-blobs');
+  await fs.mkdir(sharedBlobPath, { recursive: true });
+  config.blobFileStoreUrls = [`file://${sharedBlobPath}`];
+  config.blobFileStoreUploadUrl = `file://${sharedBlobPath}`;
+}
+
+const { AZTEC_NODE_URL = '' } = process.env;
+const getAztecUrl = () => AZTEC_NODE_URL;
 
 let telemetry: TelemetryClient | undefined = undefined;
-function getTelemetryClient(partialConfig: Partial<TelemetryClientConfig> & { benchmark?: boolean } = {}) {
+async function getTelemetryClient(partialConfig: Partial<TelemetryClientConfig> & { benchmark?: boolean } = {}) {
   if (!telemetry) {
     const config = { ...getTelemetryConfig(), ...partialConfig };
-    telemetry = config.benchmark ? new BenchmarkTelemetryClient() : initTelemetryClient(config);
+    telemetry = config.benchmark ? new BenchmarkTelemetryClient() : await initTelemetryClient(config);
   }
   return telemetry;
 }
@@ -133,45 +122,24 @@ export const getPrivateKeyFromIndex = (index: number): Buffer | null => {
   return privKeyRaw === null ? null : Buffer.from(privKeyRaw);
 };
 
-export const setupL1Contracts = async (
-  l1RpcUrls: string[],
-  account: HDAccount | PrivateKeyAccount,
-  logger: Logger,
-  args: Partial<DeployL1ContractsArgs> = {},
-  chain: Chain = foundry,
-) => {
-  const l1Data = await deployL1Contracts(l1RpcUrls, account, chain, logger, {
-    vkTreeRoot: getVKTreeRoot(),
-    protocolContractTreeRoot,
-    genesisArchiveRoot: args.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-    salt: args.salt,
-    initialValidators: args.initialValidators,
-    ...getL1ContractsConfigEnvVars(),
-    realVerifier: false,
-    ...args,
-  });
-
-  return l1Data;
-};
-
 /**
- * Sets up Private eXecution Environment (PXE).
+ * Sets up Private eXecution Environment (PXE) and returns the corresponding test wallet.
  * @param aztecNode - An instance of Aztec Node.
- * @param opts - Partial configuration for the PXE service.
+ * @param opts - Partial configuration for the PXE.
  * @param logger - The logger to be used.
  * @param useLogSuffix - Whether to add a randomly generated suffix to the PXE debug logs.
- * @returns Private eXecution Environment (PXE), logger and teardown function.
+ * @returns A test wallet, logger and teardown function.
  */
-export async function setupPXEService(
+export async function setupPXEAndGetWallet(
   aztecNode: AztecNode,
-  opts: Partial<PXEServiceConfig> = {},
+  opts: Partial<PXEConfig> = {},
   logger = getLogger(),
   useLogSuffix = false,
 ): Promise<{
   /**
-   * The PXE instance.
+   * The wallet instance.
    */
-  pxe: PXEService;
+  wallet: TestWallet;
   /**
    * Logger instance named as the current test.
    */
@@ -181,29 +149,24 @@ export async function setupPXEService(
    */
   teardown: () => Promise<void>;
 }> {
-  const pxeServiceConfig = { ...getPXEServiceConfig(), ...opts };
+  const PXEConfig = { ...getPXEConfig(), ...opts };
   // For tests we only want proving enabled if specifically requested
-  pxeServiceConfig.proverEnabled = !!opts.proverEnabled;
+  PXEConfig.proverEnabled = !!opts.proverEnabled;
 
   // If no data directory provided, create a temp directory and clean up afterwards
-  const configuredDataDirectory = pxeServiceConfig.dataDirectory;
+  const configuredDataDirectory = PXEConfig.dataDirectory;
   if (!configuredDataDirectory) {
-    pxeServiceConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
+    PXEConfig.dataDirectory = path.join(tmpdir(), randomBytes(8).toString('hex'));
   }
 
-  const simulator = new WASMSimulator();
-  const recorder = process.env.CIRCUIT_RECORD_DIR
-    ? new FileCircuitRecorder(process.env.CIRCUIT_RECORD_DIR)
-    : new MemoryCircuitRecorder();
-  const simulatorWithRecorder = new SimulatorRecorderWrapper(simulator, recorder);
-  const pxe = await createPXEServiceWithSimulator(aztecNode, simulatorWithRecorder, pxeServiceConfig, {
+  const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(PXEConfig.dataDirectory!);
+
+  const wallet = await TestWallet.create(aztecNode, PXEConfig, {
     useLogSuffix,
   });
 
-  const teardown = configuredDataDirectory ? () => Promise.resolve() : () => tryRmDir(pxeServiceConfig.dataDirectory!);
-
   return {
-    pxe,
+    wallet,
     logger,
     teardown,
   };
@@ -228,45 +191,48 @@ async function setupWithRemoteEnvironment(
   const aztecNodeUrl = getAztecUrl();
   logger.verbose(`Creating Aztec Node client to remote host ${aztecNodeUrl}`);
   const aztecNode = createAztecNodeClient(aztecNodeUrl);
-  logger.verbose(`Creating PXE client to remote host ${PXE_URL}`);
-  const pxeClient = createPXEClient(PXE_URL, {}, makeFetch([1, 2, 3], true));
-  await waitForPXE(pxeClient, logger);
-  logger.verbose('JSON RPC client connected to PXE');
-  logger.verbose(`Retrieving contract addresses from ${PXE_URL}`);
-  const { l1ContractAddresses, rollupVersion } = await pxeClient.getNodeInfo();
+  await waitForNode(aztecNode, logger);
+  logger.verbose('JSON RPC client connected to Aztec Node');
+  logger.verbose(`Retrieving contract addresses from ${aztecNodeUrl}`);
+  const { l1ContractAddresses, rollupVersion } = await aztecNode.getNodeInfo();
 
   const l1Client = createExtendedL1Client(config.l1RpcUrls, account, foundry);
 
-  const deployL1ContractsValues: DeployL1ContractsReturnType = {
+  const deployL1ContractsValues: DeployAztecL1ContractsReturnType = {
     l1ContractAddresses,
     l1Client,
     rollupVersion,
   };
-  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls);
-  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxeClient!);
+  const ethCheatCodes = new EthCheatCodes(config.l1RpcUrls, new DateProvider());
+  const wallet = await TestWallet.create(aztecNode);
+  const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, new DateProvider());
   const teardown = () => Promise.resolve();
 
-  logger.verbose('Constructing available wallets from already registered accounts...');
-  const initialFundedAccounts = await getDeployedTestAccounts(pxeClient);
-  const wallets = await getDeployedTestAccountsWallets(pxeClient);
+  logger.verbose('Populating wallet from already registered accounts...');
+  const initialFundedAccounts = await getInitialTestAccountsData();
 
-  if (wallets.length < numberOfAccounts) {
-    throw new Error(`Required ${numberOfAccounts} accounts. Found ${wallets.length}.`);
+  if (initialFundedAccounts.length < numberOfAccounts) {
+    throw new Error(`Required ${numberOfAccounts} accounts. Found ${initialFundedAccounts.length}.`);
     // Deploy new accounts if there's a test that requires more funded accounts in the remote environment.
   }
 
+  const testAccounts = await Promise.all(
+    initialFundedAccounts.slice(0, numberOfAccounts).map(async account => {
+      const accountManager = await wallet.createSchnorrAccount(account.secret, account.salt, account.signingKey);
+      return accountManager.address;
+    }),
+  );
+
   return {
     aztecNode,
     aztecNodeAdmin: undefined,
     sequencer: undefined,
     proverNode: undefined,
-    pxe: pxeClient,
     deployL1ContractsValues,
     config,
     initialFundedAccounts,
-    wallets,
-    wallet: wallets[0],
-    accounts: wallets.slice(0, numberOfAccounts).map(w => w.getAddress()),
+    wallet,
+    accounts: testAccounts,
     logger,
     cheatCodes,
     ethCheatCodes,
@@ -274,7 +240,6 @@ async function setupWithRemoteEnvironment(
     mockGossipSubNetwork: undefined,
     watcher: undefined,
     dateProvider: undefined,
-    blobSink: undefined,
     telemetryClient: undefined,
     teardown,
   };
@@ -287,17 +252,13 @@ export type SetupOptions = {
   /** Whether to enable metrics collection, if undefined, metrics collection is disabled */
   metricsPort?: number | undefined;
   /** Previously deployed contracts on L1 */
-  deployL1ContractsValues?: DeployL1ContractsReturnType;
-  /** Whether to skip deployment of protocol contracts (auth registry, etc) */
-  skipProtocolContracts?: boolean;
+  deployL1ContractsValues?: DeployAztecL1ContractsReturnType;
   /** Initial fee juice for default accounts */
   initialAccountFeeJuice?: Fr;
   /** Number of initial accounts funded with fee juice */
   numberOfInitialFundedAccounts?: number;
   /** Data of the initial funded accounts */
   initialFundedAccounts?: InitialAccountData[];
-  /** Salt to use in L1 contract deployment */
-  salt?: number;
   /** An initial set of validators */
   initialValidators?: (Operator & { privateKey: `0x${string}` })[];
   /** Anvil Start time */
@@ -306,8 +267,6 @@ export type SetupOptions = {
   l2StartTime?: number;
   /** Whether to start a prover node */
   startProverNode?: boolean;
-  /** Whether to fund the rewardDistributor */
-  fundRewardDistributor?: boolean;
   /** Manual config for the telemetry client */
   telemetryConfig?: Partial<TelemetryClientConfig> & { benchmark?: boolean };
   /** Public data that will be inserted in the tree in genesis */
@@ -326,6 +285,8 @@ export type SetupOptions = {
   anvilPort?: number;
   /** Key to use for publishing L1 contracts */
   l1PublisherKey?: SecretValue<`0x${string}`>;
+  /** ZkPassport configuration (domain, scope, mock verifier) */
+  zkPassportArgs?: ZKPassportArgs;
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
@@ -338,19 +299,15 @@ export type EndToEndContext = {
   proverNode: ProverNode | undefined;
   /** A client to the sequencer service (undefined if connected to remote environment) */
   sequencer: SequencerClient | undefined;
-  /** The Private eXecution Environment (PXE). */
-  pxe: PXE;
-  /** Return values from deployL1Contracts function. */
-  deployL1ContractsValues: DeployL1ContractsReturnType;
+  /** Return values from deployAztecL1Contracts function. */
+  deployL1ContractsValues: DeployAztecL1ContractsReturnType;
   /** The Aztec Node configuration. */
   config: AztecNodeConfig;
   /** The data for the initial funded accounts. */
   initialFundedAccounts: InitialAccountData[];
-  /* Wallets created for the initial funded accounts, with secret keys. */
-  wallets: AccountWalletWithSecretKey[];
-  /** The first wallet to be used. */
-  wallet: AccountWalletWithSecretKey;
-  /** The accounts to be used. */
+  /** The wallet to be used. */
+  wallet: TestWallet;
+  /** The wallets to be used. */
   accounts: AztecAddress[];
   /** Logger instance named as the current test. */
   logger: Logger;
@@ -362,8 +319,6 @@ export type EndToEndContext = {
   watcher: AnvilTestWatcher | undefined;
   /** Allows tweaking current system time, used by the epoch cache only (undefined if connected to remote environment) */
   dateProvider: TestDateProvider | undefined;
-  /** The blob sink (undefined if connected to remote environment) */
-  blobSink: BlobSinkServer | undefined;
   /** Telemetry client */
   telemetryClient: TelemetryClient | undefined;
   /** Mock gossip sub network used for gossipping messages (only if mockGossipSubNetwork was set to true in opts) */
@@ -383,7 +338,7 @@ export type EndToEndContext = {
 export async function setup(
   numberOfAccounts = 1,
   opts: SetupOptions = {},
-  pxeOpts: Partial<PXEServiceConfig> = {},
+  pxeOpts: Partial<PXEConfig> = {},
   chain: Chain = foundry,
 ): Promise<EndToEndContext> {
   let anvil: Anvil | undefined;
@@ -414,9 +369,9 @@ export async function setup(
       if (!isAnvilTestChain(chain.id)) {
         throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
       }
-      if (PXE_URL) {
+      if (AZTEC_NODE_URL) {
         throw new Error(
-          `PXE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
+          `AZTEC_NODE_URL provided but no ETHEREUM_HOSTS set. Refusing to run, please set both variables so tests can deploy L1 contracts to the same Anvil instance`,
         );
       }
 
@@ -436,7 +391,8 @@ export async function setup(
       setupMetricsLogger(filename);
     }
 
-    const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls);
+    const dateProvider = new TestDateProvider();
+    const ethCheatCodes = new EthCheatCodesWithState(config.l1RpcUrls, dateProvider);
 
     if (opts.stateLoad) {
       await ethCheatCodes.loadChainState(opts.stateLoad);
@@ -446,29 +402,34 @@ export async function setup(
       await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
     }
 
-    let publisherPrivKey = undefined;
-    let publisherHdAccount = undefined;
+    let publisherPrivKeyHex: `0x${string}` | undefined = undefined;
+    let publisherHdAccount: HDAccount | PrivateKeyAccount | undefined = undefined;
 
     if (opts.l1PublisherKey && opts.l1PublisherKey.getValue() && opts.l1PublisherKey.getValue() != NULL_KEY) {
-      publisherHdAccount = privateKeyToAccount(opts.l1PublisherKey.getValue());
+      publisherPrivKeyHex = opts.l1PublisherKey.getValue();
+      publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (
       config.publisherPrivateKeys &&
       config.publisherPrivateKeys.length > 0 &&
       config.publisherPrivateKeys[0].getValue() != NULL_KEY
     ) {
-      publisherHdAccount = privateKeyToAccount(config.publisherPrivateKeys[0].getValue());
+      publisherPrivKeyHex = config.publisherPrivateKeys[0].getValue();
+      publisherHdAccount = privateKeyToAccount(publisherPrivKeyHex);
     } else if (!MNEMONIC) {
       throw new Error(`Mnemonic not provided and no publisher private key`);
     } else {
       publisherHdAccount = mnemonicToAccount(MNEMONIC, { addressIndex: 0 });
       const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
-      publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
-      config.publisherPrivateKeys = [new SecretValue(`0x${publisherPrivKey!.toString('hex')}` as const)];
+      const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
+      publisherPrivKeyHex = `0x${publisherPrivKey!.toString('hex')}` as const;
+      config.publisherPrivateKeys = [new SecretValue(publisherPrivKeyHex)];
     }
 
-    config.coinbase = EthAddress.fromString(publisherHdAccount.address);
+    if (config.coinbase === undefined) {
+      config.coinbase = EthAddress.fromString(publisherHdAccount.address);
+    }
 
-    if (PXE_URL) {
+    if (AZTEC_NODE_URL) {
       // we are setting up against a remote environment, l1 contracts are assumed to already be deployed
       return await setupWithRemoteEnvironment(publisherHdAccount!, config, logger, numberOfAccounts);
     }
@@ -489,54 +450,30 @@ export async function setup(
     }
 
     const l1Client = createExtendedL1Client(config.l1RpcUrls, publisherHdAccount!, chain);
-    await deployMulticall3(l1Client, logger);
-
-    const deployL1ContractsValues =
-      opts.deployL1ContractsValues ??
-      (await setupL1Contracts(
-        config.l1RpcUrls,
-        publisherHdAccount!,
-        logger,
-        {
-          ...opts,
-          genesisArchiveRoot,
-          feeJuicePortalInitialBalance: fundingNeeded,
-          initialValidators: opts.initialValidators,
-        },
-        chain,
-      ));
+
+    const deployL1ContractsValues: DeployAztecL1ContractsReturnType = await deployAztecL1Contracts(
+      config.l1RpcUrls[0],
+      publisherPrivKeyHex!,
+      chain.id,
+      {
+        ...getL1ContractsConfigEnvVars(),
+        ...opts,
+        vkTreeRoot: getVKTreeRoot(),
+        protocolContractsHash,
+        genesisArchiveRoot,
+        initialValidators: opts.initialValidators,
+        feeJuicePortalInitialBalance: fundingNeeded,
+        realVerifier: false,
+      },
+    );
 
     config.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
     config.rollupVersion = deployL1ContractsValues.rollupVersion;
 
-    if (opts.fundRewardDistributor) {
-      // Mints block rewards for 10000 blocks to the rewardDistributor contract
-
-      const rollup = new RollupContract(
-        deployL1ContractsValues.l1Client,
-        deployL1ContractsValues.l1ContractAddresses.rollupAddress,
-      );
-
-      const blockReward = await rollup.getBlockReward();
-      const mintAmount = 10_000n * (blockReward as bigint);
-
-      const feeJuice = getContract({
-        address: deployL1ContractsValues.l1ContractAddresses.feeJuiceAddress.toString(),
-        abi: FeeAssetArtifact.contractAbi,
-        client: deployL1ContractsValues.l1Client,
-      });
-
-      const rewardDistributorMintTxHash = await feeJuice.write.mint(
-        [deployL1ContractsValues.l1ContractAddresses.rewardDistributorAddress.toString(), mintAmount],
-        {} as any,
-      );
-      await deployL1ContractsValues.l1Client.waitForTransactionReceipt({ hash: rewardDistributorMintTxHash });
-      logger.info(`Funding rewardDistributor in ${rewardDistributorMintTxHash}`);
-    }
-
     if (enableAutomine) {
       await ethCheatCodes.setAutomine(false);
       await ethCheatCodes.setIntervalMining(config.ethereumSlotDuration);
+      dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
     }
 
     if (opts.l2StartTime) {
@@ -545,11 +482,8 @@ export async function setup(
       await ethCheatCodes.warp(opts.l2StartTime, { resetBlockInterval: true });
     }
 
-    const dateProvider = new TestDateProvider();
-    dateProvider.setTime((await ethCheatCodes.timestamp()) * 1000);
-
     const watcher = new AnvilTestWatcher(
-      new EthCheatCodesWithState(config.l1RpcUrls),
+      new EthCheatCodesWithState(config.l1RpcUrls, dateProvider),
       deployL1ContractsValues.l1ContractAddresses.rollupAddress,
       deployL1ContractsValues.l1Client,
       dateProvider,
@@ -558,25 +492,11 @@ export async function setup(
       await watcher.start();
     }
 
-    const telemetry = getTelemetryClient(opts.telemetryConfig);
+    const telemetry = await getTelemetryClient(opts.telemetryConfig);
 
-    // Blob sink service - blobs get posted here and served from here
-    const blobSinkPort = await getPort();
-    const blobSink = await createBlobSinkServer(
-      {
-        l1ChainId: config.l1ChainId,
-        l1RpcUrls: config.l1RpcUrls,
-        l1Contracts: config.l1Contracts,
-        port: blobSinkPort,
-        dataDirectory: config.dataDirectory,
-        dataStoreMapSizeKB: config.dataStoreMapSizeKB,
-      },
-      telemetry,
-    );
-    await blobSink.start();
-    config.blobSinkUrl = `http://localhost:${blobSinkPort}`;
+    await setupSharedBlobStorage(config);
 
-    logger.verbose('Creating and synching an aztec node...');
+    logger.verbose('Creating and synching an aztec node', config);
 
     const acvmConfig = await getACVMConfig(logger);
     if (acvmConfig) {
@@ -589,9 +509,6 @@ export async function setup(
       config.bbBinaryPath = bbConfig.bbBinaryPath;
       config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
     }
-    config.l1PublishRetryIntervalMS = 100;
-
-    const blobSinkClient = createBlobSinkClient(config, { logger: createLogger('node:blob-sink:client') });
 
     let mockGossipSubNetwork: MockGossipSubNetwork | undefined;
     let p2pClientDeps: P2PClientDeps<P2PClientType.Full> | undefined = undefined;
@@ -631,7 +548,7 @@ export async function setup(
 
     const aztecNode = await AztecNodeService.createAndSync(
       config, // REFACTOR: createAndSync mutates this config
-      { dateProvider, blobSinkClient, telemetry, p2pClientDeps, logger: createLogger('node:MAIN-aztec-node') },
+      { dateProvider, telemetry, p2pClientDeps, logger: createLogger('node:MAIN-aztec-node') },
       { prefilledPublicData },
     );
     const sequencerClient = aztecNode.getSequencer();
@@ -658,39 +575,42 @@ export async function setup(
     }
 
     logger.verbose('Creating a pxe...');
-    const { pxe, teardown: pxeTeardown } = await setupPXEService(aztecNode!, pxeOpts, logger);
+    const { wallet, teardown: pxeTeardown } = await setupPXEAndGetWallet(aztecNode!, pxeOpts, logger);
 
-    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxe!);
+    const cheatCodes = await CheatCodes.create(config.l1RpcUrls, aztecNode, dateProvider);
 
     if (
       (opts.aztecTargetCommitteeSize && opts.aztecTargetCommitteeSize > 0) ||
       (opts.initialValidators && opts.initialValidators.length > 0)
     ) {
-      // We need to advance to epoch 2 such that the committee is set up.
-      logger.info(`Advancing to epoch 2`);
-      await cheatCodes.rollup.advanceToEpoch(2n, { updateDateProvider: dateProvider });
+      // We need to advance such that the committee is set up.
+      await cheatCodes.rollup.advanceToEpoch(
+        EpochNumber.fromBigInt(
+          BigInt(await cheatCodes.rollup.getEpoch()) + BigInt(config.lagInEpochsForValidatorSet + 1),
+        ),
+      );
       await cheatCodes.rollup.setupEpoch();
       await cheatCodes.rollup.debugRollup();
     }
-
+    let accounts: AztecAddress[] = [];
     // Below we continue with what we described in the long comment on line 571.
-    let accountManagers: AccountManager[] = [];
     if (numberOfAccounts === 0) {
       logger.info('No accounts are being deployed, waiting for an empty block 1 to be mined');
-      while ((await pxe.getBlockNumber()) === 0) {
+      while ((await aztecNode.getBlockNumber()) === 0) {
         await sleep(2000);
       }
     } else {
       logger.info(
         `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
       );
-      accountManagers = await deployFundedSchnorrAccounts(pxe, initialFundedAccounts.slice(0, numberOfAccounts));
+      const accountsData = initialFundedAccounts.slice(0, numberOfAccounts);
+      const accountManagers = await deployFundedSchnorrAccounts(wallet, aztecNode, accountsData);
+      accounts = accountManagers.map(accountManager => accountManager.address);
     }
 
     // Now we restore the original minTxsPerBlock setting.
     sequencerClient!.getSequencer().updateConfig({ minTxsPerBlock: originalMinTxsPerBlock });
 
-    const wallets = await Promise.all(accountManagers.map(account => account.getWallet()));
     if (initialFundedAccounts.length < numberOfAccounts) {
       // TODO: Create (numberOfAccounts - initialFundedAccounts.length) wallets without funds.
       throw new Error(
@@ -716,7 +636,6 @@ export async function setup(
         await tryStop(watcher, logger);
         await tryStop(anvil, logger);
 
-        await tryStop(blobSink, logger);
         await tryRmDir(directoryToCleanup, logger);
       } catch (err) {
         logger.error(`Error during e2e test teardown`, err);
@@ -726,7 +645,6 @@ export async function setup(
     return {
       aztecNode,
       aztecNodeAdmin: aztecNode,
-      blobSink,
       cheatCodes,
       ethCheatCodes,
       config,
@@ -737,13 +655,11 @@ export async function setup(
       mockGossipSubNetwork,
       prefilledPublicData,
       proverNode,
-      pxe,
       sequencer: sequencerClient,
       teardown,
       telemetryClient: telemetry,
-      wallets,
-      wallet: wallets[0],
-      accounts: wallets.map(w => w.getAddress()),
+      wallet,
+      accounts,
       watcher,
     };
   } catch (err) {
@@ -760,16 +676,14 @@ export async function setup(
  * @param accountsToDeploy - Which accounts to publicly deploy.
  */
 
-// docs:start:public_deploy_accounts
-export async function ensureAccountContractsPublished(sender: Wallet, accountsToDeploy: Wallet[]) {
+export async function ensureAccountContractsPublished(wallet: Wallet, accountsToDeploy: AztecAddress[]) {
   // We have to check whether the accounts are already deployed. This can happen if the test runs against
-  // the sandbox and the test accounts exist
+  // the local network and the test accounts exist
   const accountsAndAddresses = await Promise.all(
-    accountsToDeploy.map(async account => {
-      const address = account.getAddress();
+    accountsToDeploy.map(async address => {
       return {
         address,
-        deployed: (await sender.getContractMetadata(address)).isContractPublished,
+        deployed: (await wallet.getContractMetadata(address)).isContractPublished,
       };
     }),
   );
@@ -777,33 +691,18 @@ export async function ensureAccountContractsPublished(sender: Wallet, accountsTo
     await Promise.all(
       accountsAndAddresses
         .filter(({ deployed }) => !deployed)
-        .map(({ address }) => sender.getContractMetadata(address)),
+        .map(({ address }) => wallet.getContractMetadata(address)),
     )
   ).map(contractMetadata => contractMetadata.contractInstance);
   const contractClass = await getContractClassFromArtifact(SchnorrAccountContractArtifact);
-  if (!(await sender.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
-    await (await publishContractClass(sender, SchnorrAccountContractArtifact))
-      .send({ from: accountsToDeploy[0].getAddress() })
+  if (!(await wallet.getContractClassMetadata(contractClass.id, true)).isContractClassPubliclyRegistered) {
+    await (await publishContractClass(wallet, SchnorrAccountContractArtifact))
+      .send({ from: accountsToDeploy[0] })
       .wait();
   }
-  const requests = await Promise.all(instances.map(async instance => await publishInstance(sender, instance!)));
-  const batch = new BatchCall(sender, requests);
-  await batch.send({ from: accountsToDeploy[0].getAddress() }).wait();
-}
-// docs:end:public_deploy_accounts
-
-/**
- * Sets the timestamp of the next block.
- * @param rpcUrl - rpc url of the blockchain instance to connect to
- * @param timestamp - the timestamp for the next block
- */
-export async function setNextBlockTimestamp(rpcUrl: string, timestamp: number) {
-  const params = `[${timestamp}]`;
-  await fetch(rpcUrl, {
-    body: `{"jsonrpc":"2.0", "method": "evm_setNextBlockTimestamp", "params": ${params}, "id": 1}`,
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-  });
+  const requests = await Promise.all(instances.map(async instance => await publishInstance(wallet, instance!)));
+  const batch = new BatchCall(wallet, requests);
+  await batch.send({ from: accountsToDeploy[0] }).wait();
 }
 
 /** Returns the job name for the current test. */
@@ -869,7 +768,7 @@ export async function expectMappingDelta<K, V extends number | bigint>(
 }
 
 /**
- * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
+ * Computes the address of the "canonical" SponsoredFPCContract. This is not a protocol contract
  * but by conventions its address is computed with a salt of 0.
  * @returns The address of the sponsored FPC contract
  */
@@ -882,7 +781,7 @@ export function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress>
 }
 
 /**
- * Computes the address of the "canonical" SponosoredFPCContract. This is not a protocol contract
+ * Computes the address of the "canonical" SponsoredFPCContract. This is not a protocol contract
  * but by conventions its address is computed with a salt of 0.
  * @returns The address of the sponsored FPC contract
  */
@@ -894,25 +793,25 @@ export async function getSponsoredFPCAddress() {
 /**
  * Deploy a sponsored FPC contract to a running instance.
  */
-export async function setupSponsoredFPC(pxe: PXE) {
+export async function setupSponsoredFPC(wallet: Wallet) {
   const instance = await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
     salt: new Fr(SPONSORED_FPC_SALT),
   });
 
-  await pxe.registerContract({ instance, artifact: SponsoredFPCContract.artifact });
+  await wallet.registerContract(instance, SponsoredFPCContract.artifact);
   getLogger().info(`SponsoredFPC: ${instance.address}`);
   return instance;
 }
 
 /**
  * Registers the SponsoredFPC in this PXE instance
- * @param pxe - The pxe client
+ * @param wallet - The wallet
  */
-export async function registerSponsoredFPC(pxe: PXE): Promise<void> {
-  await pxe.registerContract({ instance: await getSponsoredFPCInstance(), artifact: SponsoredFPCContract.artifact });
+export async function registerSponsoredFPC(wallet: Wallet): Promise<void> {
+  await wallet.registerContract(await getSponsoredFPCInstance(), SponsoredFPCContract.artifact);
 }
 
-export async function waitForProvenChain(node: AztecNode, targetBlock?: number, timeoutSec = 60, intervalSec = 1) {
+export async function waitForProvenChain(node: AztecNode, targetBlock?: BlockNumber, timeoutSec = 60, intervalSec = 1) {
   targetBlock ??= await node.getBlockNumber();
 
   await retryUntil(
@@ -926,7 +825,7 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: number,
 export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
   aztecNodeConfig: AztecNodeConfig,
-  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'>,
+  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'> & { dontStart?: boolean },
   aztecNode: AztecNode | undefined,
   prefilledPublicData: PublicDataTreeLeaf[] = [],
   proverNodeDeps: ProverNodeDeps = {},
@@ -940,11 +839,15 @@ export function createAndSyncProverNode(
       stop: () => Promise.resolve(),
     };
 
-    const blobSinkClient = createBlobSinkClient(aztecNodeConfig);
+    const blobClient = await createBlobClientWithFileStores(aztecNodeConfig, createLogger('blob-client:prover-node'));
 
     // Creating temp store and archiver for simulated prover node
     const archiverConfig = { ...aztecNodeConfig, dataDirectory: proverNodeConfig.dataDirectory };
-    const archiver = await createArchiver(archiverConfig, { blobSinkClient }, { blockUntilSync: true });
+    const archiver = await createArchiver(
+      archiverConfig,
+      { blobClient, dateProvider: proverNodeDeps.dateProvider },
+      { blockUntilSync: true },
+    );
 
     // Prover node config is for simulated proofs
     const proverConfig: ProverNodeConfig = {
@@ -962,6 +865,7 @@ export function createAndSyncProverNode(
       txGatheringTimeoutMs: 24_000,
       proverNodeFailedEpochStore: undefined,
       proverId: EthAddress.fromNumber(1),
+      proverNodeEpochProvingDelayMs: undefined,
       ...proverNodeConfig,
     };
 
@@ -978,7 +882,9 @@ export function createAndSyncProverNode(
       { prefilledPublicData },
     );
     getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
-    await proverNode.start();
+    if (!proverNodeConfig.dontStart) {
+      await proverNode.start();
+    }
     return proverNode;
   });
 }