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

package/dest/fixtures/utils.js

@@ -1,41 +1,45 @@
 import { SchnorrAccountContractArtifact } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, generateSchnorrAccounts, getDeployedTestAccounts, getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import { generateSchnorrAccounts, getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { createArchiver } from '@aztec/archiver';
 import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { BatchCall, createAztecNodeClient, createLogger, createPXEClient, makeFetch, sleep, waitForPXE } from '@aztec/aztec.js';
+import { BatchCall } from '@aztec/aztec.js/contracts';
 import { publishContractClass, publishInstance } from '@aztec/aztec.js/deployment';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { createAztecNodeClient, waitForNode } from '@aztec/aztec.js/node';
 import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
-import { createBlobSinkServer } from '@aztec/blob-sink/server';
-import { GENESIS_ARCHIVE_ROOT, SPONSORED_FPC_SALT } from '@aztec/constants';
-import { FeeAssetArtifact, NULL_KEY, RollupContract, createExtendedL1Client, deployL1Contracts, deployMulticall3, getL1ContractsConfigEnvVars, isAnvilTestChain } from '@aztec/ethereum';
+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 { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { DelayedTxUtils, EthCheatCodes, EthCheatCodesWithState, createDelayedL1TxUtilsFromViemWallet, startAnvil } from '@aztec/ethereum/test';
+import { 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 { TestDateProvider } from '@aztec/foundation/timer';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { MockGossipSubNetwork, getMockPubSubP2PServiceFactory } from '@aztec/p2p/test-helpers';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { createProverNode } from '@aztec/prover-node';
-import { createPXEServiceWithSimulator, getPXEServiceConfig } from '@aztec/pxe/server';
-import { MemoryCircuitRecorder, SimulatorRecorderWrapper, WASMSimulator } from '@aztec/simulator/client';
-import { FileCircuitRecorder } from '@aztec/simulator/testing';
+import { getPXEConfig } from '@aztec/pxe/server';
 import { getContractClassFromArtifact, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, 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 { randomBytes } from 'crypto';
 import fs from 'fs/promises';
-import getPort from 'get-port';
 import { tmpdir } from 'os';
 import * as path from 'path';
-import { getContract } from 'viem';
 import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
@@ -44,16 +48,28 @@ import { getBBConfig } from './get_bb_config.js';
 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) {
+    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 = undefined;
-function getTelemetryClient(partialConfig = {}) {
+async function getTelemetryClient(partialConfig = {}) {
     if (!telemetry) {
         const config = {
             ...getTelemetryConfig(),
             ...partialConfig
         };
-        telemetry = config.benchmark ? new BenchmarkTelemetryClient() : initTelemetryClient(config);
+        telemetry = config.benchmark ? new BenchmarkTelemetryClient() : await initTelemetryClient(config);
     }
     return telemetry;
 }
@@ -69,47 +85,31 @@ export const getPrivateKeyFromIndex = (index)=>{
     const privKeyRaw = hdAccount.getHdKey().privateKey;
     return privKeyRaw === null ? null : Buffer.from(privKeyRaw);
 };
-export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, 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.
- */ export async function setupPXEService(aztecNode, opts = {}, logger = getLogger(), useLogSuffix = false) {
-    const pxeServiceConfig = {
-        ...getPXEServiceConfig(),
+ * @returns A test wallet, logger and teardown function.
+ */ export async function setupPXEAndGetWallet(aztecNode, opts = {}, logger = getLogger(), useLogSuffix = false) {
+    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
     };
@@ -127,44 +127,40 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
     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 = {
         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);
-    if (wallets.length < numberOfAccounts) {
-        throw new Error(`Required ${numberOfAccounts} accounts. Found ${wallets.length}.`);
+    logger.verbose('Populating wallet from already registered accounts...');
+    const initialFundedAccounts = await getInitialTestAccountsData();
+    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,
@@ -172,7 +168,6 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
         mockGossipSubNetwork: undefined,
         watcher: undefined,
         dateProvider: undefined,
-        blobSink: undefined,
         telemetryClient: undefined,
         teardown
     };
@@ -211,8 +206,8 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             if (!isAnvilTestChain(chain.id)) {
                 throw new Error(`No ETHEREUM_HOSTS set but non anvil chain requested`);
             }
-            if (PXE_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`);
+            if (AZTEC_NODE_URL) {
+                throw new Error(`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`);
             }
             const res = await startAnvil({
                 l1BlockTime: opts.ethereumSlotDuration,
@@ -230,7 +225,8 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             logger.info(`Logging metrics to ${filename}`);
             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);
         }
@@ -239,12 +235,14 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
                 resetBlockInterval: true
             });
         }
-        let publisherPrivKey = undefined;
+        let publisherPrivKeyHex = undefined;
         let publisherHdAccount = 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 {
@@ -252,13 +250,16 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
                 addressIndex: 0
             });
             const publisherPrivKeyRaw = publisherHdAccount.getHdKey().privateKey;
-            publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
+            const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
+            publisherPrivKeyHex = `0x${publisherPrivKey.toString('hex')}`;
             config.publisherPrivateKeys = [
-                new SecretValue(`0x${publisherPrivKey.toString('hex')}`)
+                new SecretValue(publisherPrivKeyHex)
             ];
         }
-        config.coinbase = EthAddress.fromString(publisherHdAccount.address);
-        if (PXE_URL) {
+        if (config.coinbase === undefined) {
+            config.coinbase = EthAddress.fromString(publisherHdAccount.address);
+        }
+        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);
         }
@@ -270,37 +271,22 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             await ethCheatCodes.setAutomine(true);
         }
         const l1Client = createExtendedL1Client(config.l1RpcUrls, publisherHdAccount, chain);
-        await deployMulticall3(l1Client, logger);
-        const deployL1ContractsValues = opts.deployL1ContractsValues ?? await setupL1Contracts(config.l1RpcUrls, publisherHdAccount, logger, {
+        const deployL1ContractsValues = await deployAztecL1Contracts(config.l1RpcUrls[0], publisherPrivKeyHex, chain.id, {
+            ...getL1ContractsConfigEnvVars(),
             ...opts,
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractsHash,
             genesisArchiveRoot,
+            initialValidators: opts.initialValidators,
             feeJuicePortalInitialBalance: fundingNeeded,
-            initialValidators: opts.initialValidators
-        }, chain);
+            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;
-            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
-            ], {});
-            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) {
             // This should only be used in synching test or when you need to have a stable
@@ -309,26 +295,13 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
                 resetBlockInterval: true
             });
         }
-        const dateProvider = new TestDateProvider();
-        dateProvider.setTime(await ethCheatCodes.timestamp() * 1000);
-        const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(config.l1RpcUrls), deployL1ContractsValues.l1ContractAddresses.rollupAddress, deployL1ContractsValues.l1Client, dateProvider);
+        const watcher = new AnvilTestWatcher(new EthCheatCodesWithState(config.l1RpcUrls, dateProvider), deployL1ContractsValues.l1ContractAddresses.rollupAddress, deployL1ContractsValues.l1Client, dateProvider);
         if (!opts.disableAnvilTestWatcher) {
             await watcher.start();
         }
-        const telemetry = 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}`;
-        logger.verbose('Creating and synching an aztec node...');
+        const telemetry = await getTelemetryClient(opts.telemetryConfig);
+        await setupSharedBlobStorage(config);
+        logger.verbose('Creating and synching an aztec node', config);
         const acvmConfig = await getACVMConfig(logger);
         if (acvmConfig) {
             config.acvmWorkingDirectory = acvmConfig.acvmWorkingDirectory;
@@ -339,10 +312,6 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             config.bbBinaryPath = bbConfig.bbBinaryPath;
             config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
         }
-        config.l1PublishRetryIntervalMS = 100;
-        const blobSinkClient = createBlobSinkClient(config, {
-            logger: createLogger('node:blob-sink:client')
-        });
         let mockGossipSubNetwork;
         let p2pClientDeps = undefined;
         if (opts.mockGossipSubNetwork) {
@@ -380,7 +349,6 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
         }
         const aztecNode = await AztecNodeService.createAndSync(config, {
             dateProvider,
-            blobSinkClient,
             telemetry,
             p2pClientDeps,
             logger: createLogger('node:MAIN-aztec-node')
@@ -405,33 +373,31 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             proverNode = await createAndSyncProverNode(proverNodePrivateKeyHex, config, proverNodeConfig, aztecNode, prefilledPublicData);
         }
         logger.verbose('Creating a pxe...');
-        const { pxe, teardown: pxeTeardown } = await setupPXEService(aztecNode, pxeOpts, logger);
-        const cheatCodes = await CheatCodes.create(config.l1RpcUrls, pxe);
+        const { wallet, teardown: pxeTeardown } = await setupPXEAndGetWallet(aztecNode, pxeOpts, logger);
+        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 = [];
         // Below we continue with what we described in the long comment on line 571.
-        let accountManagers = [];
         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(`Unable to deploy ${numberOfAccounts} accounts. Only ${initialFundedAccounts.length} accounts were funded.`);
@@ -449,7 +415,6 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
                 }
                 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);
@@ -458,7 +423,6 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
         return {
             aztecNode,
             aztecNodeAdmin: aztecNode,
-            blobSink,
             cheatCodes,
             ethCheatCodes,
             config,
@@ -469,13 +433,11 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
             mockGossipSubNetwork,
             prefilledPublicData,
             proverNode,
-            pxe,
             sequencer: sequencerClient,
             teardown,
             telemetryClient: telemetry,
-            wallets,
-            wallet: wallets[0],
-            accounts: wallets.map((w)=>w.getAddress()),
+            wallet,
+            accounts,
             watcher
         };
     } catch (err) {
@@ -489,45 +451,28 @@ export const setupL1Contracts = async (l1RpcUrls, account, logger, args = {}, ch
  * Use this when you need to make a public call to an account contract, such as for requesting a public authwit.
  * @param sender - Wallet to send the deployment tx.
  * @param accountsToDeploy - Which accounts to publicly deploy.
- */ // docs:start:public_deploy_accounts
-export async function ensureAccountContractsPublished(sender, accountsToDeploy) {
+ */ export async function ensureAccountContractsPublished(wallet, accountsToDeploy) {
     // 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
-    const accountsAndAddresses = await Promise.all(accountsToDeploy.map(async (account)=>{
-        const address = account.getAddress();
+    // the local network and the test accounts exist
+    const accountsAndAddresses = await Promise.all(accountsToDeploy.map(async (address)=>{
         return {
             address,
-            deployed: (await sender.getContractMetadata(address)).isContractPublished
+            deployed: (await wallet.getContractMetadata(address)).isContractPublished
         };
     }));
-    const instances = (await Promise.all(accountsAndAddresses.filter(({ deployed })=>!deployed).map(({ address })=>sender.getContractMetadata(address)))).map((contractMetadata)=>contractMetadata.contractInstance);
+    const instances = (await Promise.all(accountsAndAddresses.filter(({ deployed })=>!deployed).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);
+    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].getAddress()
+        from: accountsToDeploy[0]
     }).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, timestamp) {
-    const params = `[${timestamp}]`;
-    await fetch(rpcUrl, {
-        body: `{"jsonrpc":"2.0", "method": "evm_setNextBlockTimestamp", "params": ${params}, "id": 1}`,
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        }
-    });
-}
 /** Returns the job name for the current test. */ function getJobName() {
     return process.env.JOB_NAME ?? expect.getState().currentTestName?.split(' ')[0].replaceAll('/', '_') ?? 'unknown';
 }
@@ -566,7 +511,7 @@ export async function expectMappingDelta(initialValues, fn, inputs, expectedDiff
     expect(diffs).toEqual(expectedDiffs);
 }
 /**
- * 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
  */ export function getSponsoredFPCInstance() {
@@ -575,7 +520,7 @@ export async function expectMappingDelta(initialValues, fn, inputs, expectedDiff
     }));
 }
 /**
- * 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
  */ export async function getSponsoredFPCAddress() {
@@ -584,25 +529,19 @@ export async function expectMappingDelta(initialValues, fn, inputs, expectedDiff
 }
 /**
  * Deploy a sponsored FPC contract to a running instance.
- */ export async function setupSponsoredFPC(pxe) {
+ */ export async function setupSponsoredFPC(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
- */ export async function registerSponsoredFPC(pxe) {
-    await pxe.registerContract({
-        instance: await getSponsoredFPCInstance(),
-        artifact: SponsoredFPCContract.artifact
-    });
+ * @param wallet - The wallet
+ */ export async function registerSponsoredFPC(wallet) {
+    await wallet.registerContract(await getSponsoredFPCInstance(), SponsoredFPCContract.artifact);
 }
 export async function waitForProvenChain(node, targetBlock, timeoutSec = 60, intervalSec = 1) {
     targetBlock ??= await node.getBlockNumber();
@@ -617,14 +556,15 @@ export function createAndSyncProverNode(proverNodePrivateKey, aztecNodeConfig, p
             getTxsByHash: aztecNode.getTxsByHash.bind(aztecNode),
             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
+            blobClient,
+            dateProvider: proverNodeDeps.dateProvider
         }, {
             blockUntilSync: true
         });
@@ -646,6 +586,7 @@ export function createAndSyncProverNode(proverNodePrivateKey, aztecNodeConfig, p
             txGatheringTimeoutMs: 24_000,
             proverNodeFailedEpochStore: undefined,
             proverId: EthAddress.fromNumber(1),
+            proverNodeEpochProvingDelayMs: undefined,
             ...proverNodeConfig
         };
         const l1TxUtils = createDelayedL1TxUtils(aztecNodeConfig, proverNodePrivateKey, 'prover-node', proverNodeDeps.dateProvider);
@@ -660,7 +601,9 @@ export function createAndSyncProverNode(proverNodePrivateKey, aztecNodeConfig, p
         getLogger().info(`Created and synced prover node`, {
             publisherAddress: l1TxUtils.client.account.address
         });
-        await proverNode.start();
+        if (!proverNodeConfig.dontStart) {
+            await proverNode.start();
+        }
         return proverNode;
     });
 }

package/dest/fixtures/web3signer.d.ts

@@ -0,0 +1,5 @@
+export declare function createWeb3SignerKeystore(dir: string, ...privateKeys: string[]): Promise<void>;
+export declare function refreshWeb3Signer(url: string, ...expectedAddresses: string[]): Promise<void>;
+export declare function getWeb3SignerTestKeystoreDir(): string;
+export declare function getWeb3SignerUrl(): string;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViM3NpZ25lci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpeHR1cmVzL3dlYjNzaWduZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0Esd0JBQXNCLHdCQUF3QixDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsR0FBRyxXQUFXLEVBQUUsTUFBTSxFQUFFLGlCQWNuRjtBQUVELHdCQUFzQixpQkFBaUIsQ0FBQyxHQUFHLEVBQUUsTUFBTSxFQUFFLEdBQUcsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLGlCQW9CbEY7QUFFRCx3QkFBZ0IsNEJBQTRCLElBQUksTUFBTSxDQU9yRDtBQUVELHdCQUFnQixnQkFBZ0IsSUFBSSxNQUFNLENBTXpDIn0=

package/dest/fixtures/web3signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web3signer.d.ts","sourceRoot":"","sources":["../../src/fixtures/web3signer.ts"],"names":[],"mappings":"AASA,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,MAAM,EAAE,iBAcnF;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,MAAM,EAAE,iBAoBlF;AAED,wBAAgB,4BAA4B,IAAI,MAAM,CAOrD;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAMzC"}