@aztec/aztec 0.0.1-commit.fce3e4f → 0.0.1-commit.ffe5b04ea

package/src/cli/util.ts

@@ -1,18 +1,18 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
-import { Fr } from '@aztec/aztec.js/fields';
-import { AccountManager } from '@aztec/aztec.js/wallet';
-import type { ViemClient } from '@aztec/ethereum';
-import type { ConfigMappingsType } from '@aztec/foundation/config';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import { getNetworkConfig } from '@aztec/cli/config';
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
+import type { ConfigMappingsType, NetworkNames } from '@aztec/foundation/config';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { type LogFn, createLogger } from '@aztec/foundation/log';
-import type { SharedNodeConfig } from '@aztec/node-lib/config';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { UpdateChecker } from '@aztec/stdlib/update-checker';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import { type VersionCheck, getPackageVersion } from '@aztec/stdlib/update-checker';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
+import type { Hex } from 'viem';
 
 import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
 
@@ -37,7 +37,7 @@ export function shutdown(logFn: LogFn, exitCode: ExitCode, cb?: Array<() => Prom
 
   logFn('Shutting down...', { exitCode });
   if (cb) {
-    shutdownPromise = Promise.allSettled(cb).then(() => process.exit(exitCode));
+    shutdownPromise = Promise.allSettled(cb.map(fn => fn())).then(() => process.exit(exitCode));
   } else {
     // synchronously shuts down the process
     // no need to set shutdownPromise on this branch of the if statement because no more code will be executed
@@ -69,30 +69,19 @@ export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<voi
 /**
  * Creates logs for the initial accounts
  * @param accounts - The initial accounts
- * @param wallet - A TestWallet instance to get the registered accounts
+ * @param wallet - A EmbeddedWallet instance to get the registered accounts
  * @returns A string array containing the initial accounts details
  */
-export async function createAccountLogs(
-  accountsWithSecretKeys: {
-    /**
-     * The account object
-     */
-    account: AccountManager;
-    /**
-     * The secret key of the account
-     */
-    secretKey: Fr;
-  }[],
-  wallet: TestWallet,
-) {
+export async function createAccountLogs(accountManagers: AccountManager[], wallet: EmbeddedWallet) {
   const registeredAccounts = await wallet.getAccounts();
   const accountLogStrings = [`Initial Accounts:\n\n`];
-  for (const accountWithSecretKey of accountsWithSecretKeys) {
-    const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
+  for (const accountManager of accountManagers) {
+    const account = await accountManager.getAccount();
+    const completeAddress = account.getCompleteAddress();
     if (registeredAccounts.find(a => a.item.equals(completeAddress.address))) {
       accountLogStrings.push(` Address: ${completeAddress.address.toString()}\n`);
       accountLogStrings.push(` Partial Address: ${completeAddress.partialAddress.toString()}\n`);
-      accountLogStrings.push(` Secret Key: ${accountWithSecretKey.secretKey.toString()}\n`);
+      accountLogStrings.push(` Secret Key: ${account.getSecretKey().toString()}\n`);
       accountLogStrings.push(
         ` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
       );
@@ -283,7 +272,7 @@ export async function preloadCrsDataForVerifying(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 1, undefined, log), GrumpkinCrs.new(2 ** 16, undefined, log)]);
   }
 }
 
@@ -298,93 +287,66 @@ export async function preloadCrsDataForServerSideProving(
 ): Promise<void> {
   if (realProofs) {
     const { Crs, GrumpkinCrs } = await import('@aztec/bb.js');
-    await Promise.all([Crs.new(2 ** 25 + 1, undefined, log), GrumpkinCrs.new(2 ** 18 + 1, undefined, log)]);
+    await Promise.all([Crs.new(2 ** 25, undefined, log), GrumpkinCrs.new(2 ** 18, undefined, log)]);
   }
 }
 
-export async function setupUpdateMonitor(
-  autoUpdateMode: SharedNodeConfig['autoUpdate'],
-  updatesLocation: URL,
+export async function setupVersionChecker(
+  network: NetworkNames,
   followsCanonicalRollup: boolean,
   publicClient: ViemClient,
-  registryContractAddress: EthAddress,
   signalHandlers: Array<() => Promise<void>>,
-  updateNodeConfig?: (config: object) => Promise<void>,
-) {
-  const logger = createLogger('update-check');
-  const checker = await UpdateChecker.new({
-    baseURL: updatesLocation,
-    publicClient,
-    registryContractAddress,
-  });
+  cacheDir?: string,
+): Promise<void> {
+  const networkConfig = await getNetworkConfig(network, cacheDir);
+  if (!networkConfig) {
+    return;
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newRollupVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
+  const { VersionChecker } = await import('@aztec/stdlib/update-checker');
 
-    // if node follows canonical rollup then this is equivalent to a config update
-    if (!followsCanonicalRollup) {
-      return;
-    }
+  const logger = createLogger('version_check');
+  const registry = new RegistryContract(publicClient, networkConfig.registryAddress as Hex);
 
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.info(`New rollup version detected. Please restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.ROLLUP_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.warn(`New rollup detected. Please restart the node`, { latestVersion, currentVersion });
-    }
+  const checks: Array<VersionCheck> = [];
+  checks.push({
+    name: 'node',
+    currentVersion: getPackageVersion() ?? 'unknown',
+    getLatestVersion: async () => {
+      const cfg = await getNetworkConfig(network, cacheDir);
+      return cfg?.nodeVersion;
+    },
   });
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('newNodeVersion', async ({ latestVersion, currentVersion }) => {
-    if (isShuttingDown()) {
-      return;
-    }
-    if (autoUpdateMode === 'config-and-version') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
-      await shutdown(logger.info, ExitCode.VERSION_UPGRADE, signalHandlers);
-    } else if (autoUpdateMode === 'notify') {
-      logger.info(`New node version detected. Please update and restart the node`, { latestVersion, currentVersion });
+  if (followsCanonicalRollup) {
+    const getLatestVersion = async () => {
+      const version = (await registry.getRollupVersions()).at(-1);
+      return version !== undefined ? String(version) : undefined;
+    };
+    const currentVersion = await getLatestVersion();
+    if (currentVersion !== undefined) {
+      checks.push({
+        name: 'rollup',
+        currentVersion,
+        getLatestVersion,
+      });
     }
-  });
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  checker.on('updateNodeConfig', async config => {
+  const checker = new VersionChecker(checks, 600_000, logger);
+  checker.on('newVersion', ({ name, latestVersion, currentVersion }) => {
     if (isShuttingDown()) {
       return;
     }
 
-    if ((autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') && updateNodeConfig) {
-      logger.warn(`Config change detected. Updating node`, config);
-      try {
-        await updateNodeConfig(config);
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
+    logger.warn(`New ${name} version available`, { latestVersion, currentVersion });
   });
-
-  checker.on('updatePublicTelemetryConfig', config => {
-    if (autoUpdateMode === 'config' || autoUpdateMode === 'config-and-version') {
-      logger.warn(`Public telemetry config change detected. Updating telemetry client`, config);
-      try {
-        const publicIncludeMetrics: unknown = (config as any).publicIncludeMetrics;
-        if (Array.isArray(publicIncludeMetrics) && publicIncludeMetrics.every(m => typeof m === 'string')) {
-          getTelemetryClient().setExportedPublicTelemetry(publicIncludeMetrics);
-        }
-        const publicMetricsCollectFrom: unknown = (config as any).publicMetricsCollectFrom;
-        if (Array.isArray(publicMetricsCollectFrom) && publicMetricsCollectFrom.every(m => typeof m === 'string')) {
-          getTelemetryClient().setPublicTelemetryCollectFrom(publicMetricsCollectFrom);
-        }
-      } catch (err) {
-        logger.warn('Failed to update config', { err });
-      }
-    }
-    // don't notify on these config changes
-  });
-
   checker.start();
+  signalHandlers.push(() => checker.stop());
+}
+
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
 }

package/src/examples/token.ts

@@ -2,7 +2,7 @@ import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { createLogger } from '@aztec/foundation/log';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { TestWallet } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 const logger = createLogger('example:token');
 
@@ -19,7 +19,7 @@ const TRANSFER_AMOUNT = 33n;
 async function main() {
   logger.info('Running token contract test on HTTP interface.');
 
-  const wallet = await TestWallet.create(node);
+  const wallet = await EmbeddedWallet.create(node);
 
   // During local network setup we deploy a few accounts. Below we add them to our wallet.
   const [aliceInitialAccountData, bobInitialAccountData] = await getInitialTestAccountsData();
@@ -32,29 +32,29 @@ async function main() {
   logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
 
   logger.info('Deploying Token...');
-  const token = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: alice })
-    .deployed();
+  const { contract: token } = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({
+    from: alice,
+  });
   logger.info('Token deployed');
 
   // Mint tokens to Alice
   logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
-  await token.methods.mint_to_private(alice, ALICE_MINT_BALANCE).send({ from: alice }).wait();
+  await token.methods.mint_to_private(alice, ALICE_MINT_BALANCE).send({ from: alice });
 
   logger.info(`${ALICE_MINT_BALANCE} tokens were successfully minted by Alice and transferred to private`);
 
-  const balanceAfterMint = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  const { result: balanceAfterMint } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Tokens successfully minted. New Alice's balance: ${balanceAfterMint}`);
 
   // We will now transfer tokens from Alice to Bob
   logger.info(`Transferring ${TRANSFER_AMOUNT} tokens from Alice to Bob...`);
-  await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice }).wait();
+  await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice });
 
   // Check the new balances
-  const aliceBalance = await token.methods.balance_of_private(alice).simulate({ from: alice });
+  const { result: aliceBalance } = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Alice's balance ${aliceBalance}`);
 
-  const bobBalance = await token.methods.balance_of_private(bob).simulate({ from: bob });
+  const { result: bobBalance } = await token.methods.balance_of_private(bob).simulate({ from: bob });
   logger.info(`Bob's balance ${bobBalance}`);
 }
 

package/src/examples/util.ts

@@ -1,5 +1,5 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
-import type { ExtendedViemWalletClient } from '@aztec/ethereum';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import type { Abi, Narrow } from 'abitype';

package/src/local-network/banana_fpc.ts

@@ -1,6 +1,6 @@
 import { type InitialAccountData, getInitialTestAccountsData } from '@aztec/accounts/testing';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
@@ -48,13 +48,17 @@ export async function getBananaFPCAddress(initialAccounts: InitialAccountData[])
 export async function setupBananaFPC(initialAccounts: InitialAccountData[], wallet: Wallet, log: LogFn) {
   const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
   const admin = getBananaAdmin(initialAccounts);
-  const [bananaCoin, fpc] = await Promise.all([
-    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal)
-      .send({ from: admin, contractAddressSalt: BANANA_COIN_SALT, universalDeploy: true })
-      .deployed(),
-    FPCContract.deploy(wallet, bananaCoinAddress, admin)
-      .send({ from: admin, contractAddressSalt: BANANA_FPC_SALT, universalDeploy: true })
-      .deployed(),
+  const [{ contract: bananaCoin }, { contract: fpc }] = await Promise.all([
+    TokenContract.deploy(wallet, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal).send({
+      from: admin,
+      contractAddressSalt: BANANA_COIN_SALT,
+      universalDeploy: true,
+    }),
+    FPCContract.deploy(wallet, bananaCoinAddress, admin).send({
+      from: admin,
+      contractAddressSalt: BANANA_FPC_SALT,
+      universalDeploy: true,
+    }),
   ]);
 
   log(`BananaCoin: ${bananaCoin.address}`);

package/src/local-network/local-network.ts

@@ -1,40 +1,45 @@
 #!/usr/bin/env -S node --no-warnings
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
+import { AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import {
-  NULL_KEY,
-  createEthereumChain,
-  deployL1Contracts,
-  deployMulticall3,
-  getL1ContractsConfigEnvVars,
-  waitForPublicClient,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { waitForPublicClient } 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 { EthCheatCodes } from '@aztec/ethereum/test';
 import { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { SequencerState } from '@aztec/sequencer-client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
 } from '@aztec/telemetry-client';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { type HDAccount, type PrivateKeyAccount, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
 import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
 import { createAccountLogs } from '../cli/util.js';
 import { DefaultMnemonic } from '../mnemonic.js';
 import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
+import { EpochTestSettler } from '../testing/epoch_test_settler.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
@@ -49,42 +54,25 @@ const localAnvil = foundry;
  */
 export async function deployContractsToL1(
   aztecNodeConfig: AztecNodeConfig,
-  hdAccount: HDAccount | PrivateKeyAccount,
-  contractDeployLogger = logger,
+  privateKey: Hex,
   opts: {
-    assumeProvenThroughBlockNumber?: number;
-    salt?: number;
     genesisArchiveRoot?: Fr;
     feeJuicePortalInitialBalance?: bigint;
   } = {},
 ) {
-  const chain =
-    aztecNodeConfig.l1RpcUrls.length > 0
-      ? createEthereumChain(aztecNodeConfig.l1RpcUrls, aztecNodeConfig.l1ChainId)
-      : { chainInfo: localAnvil };
-
   await waitForPublicClient(aztecNodeConfig);
 
-  const l1Contracts = await deployL1Contracts(
-    aztecNodeConfig.l1RpcUrls,
-    hdAccount,
-    chain.chainInfo,
-    contractDeployLogger,
-    {
-      ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
-      ...aztecNodeConfig,
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractsHash,
-      genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-      salt: opts.salt,
-      feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
-      aztecTargetCommitteeSize: 0, // no committee in local network
-      slasherFlavor: 'none', // no slashing in local network
-      realVerifier: false,
-    },
-  );
-
-  await deployMulticall3(l1Contracts.l1Client, logger);
+  const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+    ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+    ...aztecNodeConfig,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+    feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+    aztecTargetCommitteeSize: 0, // no committee in local network
+    slasherFlavor: 'none', // no slashing in local network
+    realVerifier: false,
+  });
 
   aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
   aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
@@ -96,8 +84,6 @@ export async function deployContractsToL1(
 export type LocalNetworkConfig = AztecNodeConfig & {
   /** Mnemonic used to derive the L1 deployer private key.*/
   l1Mnemonic: string;
-  /** Salt used to deploy L1 contracts.*/
-  deployAztecContractsSalt: string;
   /** Whether to deploy test accounts on local network start.*/
   testAccounts: boolean;
 };
@@ -116,15 +102,26 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   if ((config.l1RpcUrls?.length || 0) > 1) {
     logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
   }
-  const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
+
+  // The local network deploys a banana FPC with Token contracts, so include Token entries
+  // in the setup allowlist so FPC-based fee payments work out of the box.
+  const tokenAllowList = await getTokenAllowedSetupFunctions();
+
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...getConfigEnvVars(),
+    ...config,
+    txPublicSetupAllowListExtend: [...tokenAllowList, ...(config.txPublicSetupAllowListExtend ?? [])],
+  };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
   if (
-    aztecNodeConfig.publisherPrivateKeys == undefined ||
-    !aztecNodeConfig.publisherPrivateKeys.length ||
-    aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY
+    aztecNodeConfig.sequencerPublisherPrivateKeys == undefined ||
+    !aztecNodeConfig.sequencerPublisherPrivateKeys.length ||
+    aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY
   ) {
     const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKeys = [new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const)];
+    aztecNodeConfig.sequencerPublisherPrivateKeys = [
+      new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const),
+    ];
   }
   if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
     const privKey = hdAccount.getHdKey().privateKey;
@@ -148,20 +145,28 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
 
   const bananaFPC = await getBananaFPCAddress(initialAccounts);
   const sponsoredFPC = await getSponsoredFPCAddress();
-  const fundedAddresses = initialAccounts.length
-    ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
-    : [];
+  const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map(a => AztecAddress.fromString(a));
+  const fundedAddresses = [
+    ...initialAccounts.map(a => a.address),
+    ...(initialAccounts.length ? [bananaFPC, sponsoredFPC] : []),
+    ...prefundAddresses,
+  ];
   const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
 
-  let watcher: AnvilTestWatcher | undefined = undefined;
   const dateProvider = new TestDateProvider();
+
+  let cheatcodes: EthCheatCodes | undefined;
+  let rollupAddress: EthAddress | undefined;
+  let watcher: AnvilTestWatcher | undefined;
   if (!aztecNodeConfig.p2pEnabled) {
-    const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
-      assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
-      genesisArchiveRoot,
-      salt: config.deployAztecContractsSalt ? parseInt(config.deployAztecContractsSalt) : undefined,
-      feeJuicePortalInitialBalance: fundingNeeded,
-    });
+    ({ rollupAddress } = await deployContractsToL1(
+      aztecNodeConfig,
+      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
+      {
+        genesisArchiveRoot,
+        feeJuicePortalInitialBalance: fundingNeeded,
+      },
+    ));
 
     const chain =
       aztecNodeConfig.l1RpcUrls.length > 0
@@ -173,36 +178,56 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
       transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
     });
 
-    watcher = new AnvilTestWatcher(
-      new EthCheatCodes([l1RpcUrl], dateProvider),
-      l1ContractAddresses.rollupAddress,
-      publicClient,
-      dateProvider,
-    );
+    cheatcodes = new EthCheatCodes([l1RpcUrl], dateProvider);
+
+    watcher = new AnvilTestWatcher(cheatcodes, rollupAddress, publicClient, dateProvider);
     watcher.setisLocalNetwork(true);
+    watcher.setIsMarkingAsProven(false); // Do not mark as proven in the watcher. It's marked in the epochTestSettler after the out hash is set.
+
     await watcher.start();
   }
 
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  // Create a local blob sink client inside the local network, no http connectivity
-  const blobSinkClient = createBlobSinkClient();
-  const node = await createAztecNode(
-    aztecNodeConfig,
-    { telemetry, blobSinkClient, dateProvider },
-    { prefilledPublicData },
-  );
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob client client inside the local network, no http connectivity
+  const blobClient = createBlobClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { prefilledPublicData });
+
+  // Now that the node is up, let the watcher check for pending txs so it can skip unfilled slots faster when
+  // transactions are waiting in the mempool. Also let it check if the sequencer is actively building, to avoid
+  // warping time out from under an in-progress block.
+  watcher?.setGetPendingTxCount(() => node.getPendingTxCount());
+  const sequencer = node.getSequencer()?.getSequencer();
+  if (sequencer) {
+    const idleStates: Set<string> = new Set([
+      SequencerState.STOPPED,
+      SequencerState.STOPPING,
+      SequencerState.IDLE,
+      SequencerState.SYNCHRONIZING,
+    ]);
+    watcher?.setIsSequencerBuilding(() => !idleStates.has(sequencer.getState()));
+  }
+
+  let epochTestSettler: EpochTestSettler | undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    epochTestSettler = new EpochTestSettler(
+      cheatcodes!,
+      rollupAddress!,
+      node.getBlockSource(),
+      logger.createChild('epoch-settler'),
+      { pollingIntervalMs: 200 },
+    );
+    await epochTestSettler.start();
+  }
 
   if (initialAccounts.length) {
-    const PXEConfig = { proverEnabled: aztecNodeConfig.realProofs };
-    const wallet = await TestWallet.create(node, PXEConfig);
+    const wallet = await EmbeddedWallet.create(node, {
+      pxeConfig: { proverEnabled: aztecNodeConfig.realProofs },
+      ephemeral: true,
+    });
 
     userLog('Setting up funded test accounts...');
-    const accountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccounts);
-    const accountsWithSecrets = accountManagers.map((manager, i) => ({
-      account: manager,
-      secretKey: initialAccounts[i].secret,
-    }));
-    const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, initialAccounts);
+    const accLogs = await createAccountLogs(accountManagers, wallet);
     userLog(accLogs.join(''));
 
     await setupBananaFPC(initialAccounts, wallet, userLog);
@@ -216,6 +241,7 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
   const stop = async () => {
     await node.stop();
     await watcher?.stop();
+    await epochTestSettler?.stop();
   };
 
   return { node, stop };
@@ -227,7 +253,12 @@ export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {
  */
 export async function createAztecNode(
   config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface; dateProvider?: DateProvider } = {},
+  deps: {
+    telemetry?: TelemetryClient;
+    blobClient?: BlobClientInterface;
+    dateProvider?: DateProvider;
+    proverBroker?: ProvingJobBroker;
+  } = {},
   options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
@@ -237,6 +268,10 @@ export async function createAztecNode(
     ...config,
     l1Contracts: { ...l1Contracts, ...config.l1Contracts },
   };
-  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+  const node = await AztecNodeService.createAndSync(
+    aztecNodeConfig,
+    { ...deps, proverNodeDeps: { broker: deps.proverBroker } },
+    options,
+  );
   return node;
 }