@aztec/aztec 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/cli/cmds/start_archiver.ts

@@ -1,16 +1,9 @@
-import {
-  Archiver,
-  type ArchiverConfig,
-  KVArchiverDataStore,
-  archiverConfigMappings,
-  getArchiverConfigFromEnv,
-} from '@aztec/archiver';
-import { createLogger } from '@aztec/aztec.js';
-import { type BlobSinkConfig, blobSinkConfigMapping, createBlobSinkClient } from '@aztec/blob-sink/client';
+import { type ArchiverConfig, archiverConfigMappings, createArchiver, getArchiverConfigFromEnv } from '@aztec/archiver';
+import { createLogger } from '@aztec/aztec.js/log';
+import { type BlobClientConfig, blobClientConfigMapping, createBlobClient } from '@aztec/blob-client/client';
 import { getL1Config } from '@aztec/cli/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { ArchiverApiSchema } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
 
@@ -25,9 +18,9 @@ export async function startArchiver(
   services: NamespacedApiHandlers,
 ): Promise<{ config: ArchiverConfig & DataStoreConfig }> {
   const envConfig = getArchiverConfigFromEnv();
-  const cliOptions = extractRelevantOptions<ArchiverConfig & DataStoreConfig & BlobSinkConfig>(
+  const cliOptions = extractRelevantOptions<ArchiverConfig & DataStoreConfig & BlobClientConfig>(
     options,
-    { ...archiverConfigMappings, ...dataConfigMappings, ...blobSinkConfigMapping },
+    { ...archiverConfigMappings, ...dataConfigMappings, ...blobClientConfigMapping },
     'archiver',
   );
 
@@ -47,13 +40,9 @@ export async function startArchiver(
   archiverConfig.l1Contracts = addresses;
   archiverConfig = { ...archiverConfig, ...l1Config };
 
-  const storeLog = createLogger('archiver:lmdb');
-  const store = await createStore('archiver', KVArchiverDataStore.SCHEMA_VERSION, archiverConfig, storeLog);
-  const archiverStore = new KVArchiverDataStore(store, archiverConfig.maxLogs);
-
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  const blobSinkClient = createBlobSinkClient(archiverConfig, { logger: createLogger('archiver:blob-sink:client') });
-  const archiver = await Archiver.createAndSync(archiverConfig, archiverStore, { telemetry, blobSinkClient }, true);
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  const blobClient = createBlobClient(archiverConfig, { logger: createLogger('archiver:blob-client:client') });
+  const archiver = await createArchiver(archiverConfig, { telemetry, blobClient }, { blockUntilSync: true });
   services.archiver = [archiver, ArchiverApiSchema];
   signalHandlers.push(archiver.stop);
 

package/src/cli/cmds/start_bot.ts

@@ -1,15 +1,18 @@
-import { type BotConfig, BotRunner, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
+import { type BotConfig, BotRunner, BotStore, botConfigMappings, getBotRunnerApiHandler } from '@aztec/bot';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
-import { type AztecNode, type PXE, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import { createStore, openTmpStore } from '@aztec/kv-store/lmdb-v2';
+import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
+import { type AztecNode, type AztecNodeAdmin, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 import {
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
   makeTracedFetch,
 } from '@aztec/telemetry-client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, stringifyConfig } from '../util.js';
 import { getVersions } from '../versioning.js';
 
 export async function startBot(
@@ -32,28 +35,37 @@ export async function startBot(
     throw new Error('The bot requires access to a Node');
   }
 
-  const node = createAztecNodeClient(config.nodeUrl, getVersions(), fetch);
+  const aztecNode = createAztecNodeClient(config.nodeUrl, getVersions(), fetch);
 
-  // Start a PXE client that is used by the bot if required
-  let pxe: PXE | undefined;
-  if (options.pxe) {
-    const { addPXE } = await import('./start_pxe.js');
-    ({ pxe } = await addPXE(options, signalHandlers, services, userLog, { node }));
-  }
+  const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+  userLog(`Creating bot wallet with config ${stringifyConfig(pxeConfig)}`);
+  const wallet = await EmbeddedWallet.create(aztecNode, { pxeConfig });
 
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  await addBot(options, signalHandlers, services, { pxe, telemetry, node });
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  await addBot(options, signalHandlers, services, wallet, aztecNode, telemetry, undefined, userLog);
 }
 
-export function addBot(
+export async function addBot(
   options: any,
   signalHandlers: (() => Promise<void>)[],
   services: NamespacedApiHandlers,
-  deps: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+  wallet: EmbeddedWallet,
+  aztecNode: AztecNode,
+  telemetry: TelemetryClient,
+  aztecNodeAdmin?: AztecNodeAdmin,
+  userLog?: LogFn,
 ) {
   const config = extractRelevantOptions<BotConfig>(options, botConfigMappings, 'bot');
+  userLog?.(`Starting bot with config ${stringifyConfig(config)}`);
+
+  const db = await (config.dataDirectory
+    ? createStore('bot', BotStore.SCHEMA_VERSION, config)
+    : openTmpStore('bot', true, config.dataStoreMapSizeKb));
+
+  const store = new BotStore(db);
+  await store.cleanupOldClaims();
 
-  const botRunner = new BotRunner(config, deps);
+  const botRunner = new BotRunner(config, wallet, aztecNode, telemetry, aztecNodeAdmin, store);
   if (!config.noStart) {
     void botRunner.start(); // Do not block since bot setup takes time
   }

package/src/cli/cmds/start_node.ts

@@ -1,28 +1,35 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type AztecNodeConfig, aztecNodeConfigMappings, getConfigEnvVars } from '@aztec/aztec-node';
-import { Fr } from '@aztec/aztec.js';
+import { Fr } from '@aztec/aztec.js/fields';
 import { getSponsoredFPCAddress } from '@aztec/cli/cli-utils';
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum';
+import { getPublicClient } from '@aztec/ethereum/client';
 import { SecretValue } from '@aztec/foundation/config';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
+import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
-import { AztecNodeAdminApiSchema, AztecNodeApiSchema, type PXE } from '@aztec/stdlib/interfaces/client';
-import { P2PApiSchema } from '@aztec/stdlib/interfaces/server';
+import { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
+import { type CliPXEOptions, type PXEConfig, allPxeConfigMappings } from '@aztec/pxe/config';
+import { AztecNodeAdminApiSchema, AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import {
   type TelemetryClientConfig,
   initTelemetryClient,
+  makeTracedFetch,
   telemetryClientConfigMappings,
 } from '@aztec/telemetry-client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { createAztecNode } from '../../sandbox/index.js';
+import { createAztecNode } from '../../local-network/index.js';
 import {
   extractNamespacedOptions,
   extractRelevantOptions,
   preloadCrsDataForVerifying,
   setupUpdateMonitor,
 } from '../util.js';
+import { getVersions } from '../versioning.js';
+import { startProverBroker } from './start_prover_broker.js';
 
 export async function startNode(
   options: any,
@@ -43,14 +50,37 @@ export async function startNode(
     ...relevantOptions,
   };
 
+  // Prover node configuration and broker setup
+  // REFACTOR: Move the broker setup out of here and into the prover-node factory
+  let broker: ProvingJobBroker | undefined = undefined;
   if (options.proverNode) {
-    userLog(`Running a Prover Node within a Node is not yet supported`);
-    process.exit(1);
+    nodeConfig.enableProverNode = true;
+    if (nodeConfig.proverAgentCount === 0) {
+      userLog(
+        `Running prover node without local prover agent. Connect prover agents or pass --proverAgent.proverAgentCount`,
+      );
+    }
+    if (nodeConfig.proverBrokerUrl) {
+      // at 1TPS we'd enqueue ~1k chonk verifier proofs and ~1k AVM proofs immediately
+      // set a lower connection limit such that we don't overload the server
+      // Keep retrying up to 30s
+      const fetch = makeTracedFetch(
+        [1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3],
+        false,
+        makeUndiciFetch(new Agent({ connections: 100 })),
+      );
+      broker = createProvingJobBrokerClient(nodeConfig.proverBrokerUrl, getVersions(nodeConfig), fetch);
+    } else if (options.proverBroker) {
+      ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
+    } else {
+      userLog(`--prover-broker-url or --prover-broker is required to start a Prover Node`);
+      process.exit(1);
+    }
   }
 
   await preloadCrsDataForVerifying(nodeConfig, userLog);
 
-  const testAccounts = nodeConfig.testAccounts ? (await getInitialTestAccounts()).map(a => a.address) : [];
+  const testAccounts = nodeConfig.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
   const sponsoredFPCAccounts = nodeConfig.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
   const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts);
 
@@ -91,7 +121,7 @@ export async function startNode(
     ...config,
   };
 
-  if (!options.sequencer) {
+  if (!options.sequencer && !nodeConfig.fishermanMode) {
     nodeConfig.disableValidator = true;
   } else {
     const sequencerConfig = {
@@ -99,12 +129,17 @@ export async function startNode(
       ...extractNamespacedOptions(options, 'sequencer'),
     };
     // If no publisher private keys have been given, use the first validator key
-    if (sequencerConfig.publisherPrivateKeys === undefined || !sequencerConfig.publisherPrivateKeys.length) {
+    if (
+      sequencerConfig.sequencerPublisherPrivateKeys === undefined ||
+      !sequencerConfig.sequencerPublisherPrivateKeys.length
+    ) {
       if (sequencerConfig.validatorPrivateKeys?.getValue().length) {
-        sequencerConfig.publisherPrivateKeys = [new SecretValue(sequencerConfig.validatorPrivateKeys.getValue()[0])];
+        sequencerConfig.sequencerPublisherPrivateKeys = [
+          new SecretValue(sequencerConfig.validatorPrivateKeys.getValue()[0]),
+        ];
       }
     }
-    nodeConfig.publisherPrivateKeys = sequencerConfig.publisherPrivateKeys;
+    nodeConfig.sequencerPublisherPrivateKeys = sequencerConfig.sequencerPublisherPrivateKeys;
   }
 
   if (nodeConfig.p2pEnabled) {
@@ -115,30 +150,36 @@ export async function startNode(
   }
 
   const telemetryConfig = extractRelevantOptions<TelemetryClientConfig>(options, telemetryClientConfigMappings, 'tel');
-  const telemetry = initTelemetryClient(telemetryConfig);
+  const telemetry = await initTelemetryClient(telemetryConfig);
 
   // Create and start Aztec Node
-  const node = await createAztecNode(nodeConfig, { telemetry }, { prefilledPublicData });
+  const node = await createAztecNode(nodeConfig, { telemetry, proverBroker: broker }, { prefilledPublicData });
 
   // Add node and p2p to services list
   services.node = [node, AztecNodeApiSchema];
   services.p2p = [node.getP2P(), P2PApiSchema];
   adminServices.nodeAdmin = [node, AztecNodeAdminApiSchema];
 
+  // Register prover-node services if the prover node subsystem is running
+  const proverNode = node.getProverNode();
+  if (proverNode) {
+    services.prover = [proverNode, ProverNodeApiSchema];
+    if (!nodeConfig.proverBrokerUrl) {
+      services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
+    }
+  }
+
   // Add node stop function to signal handlers
   signalHandlers.push(node.stop.bind(node));
 
-  // Add a PXE client that connects to this node if requested
-  let pxe: PXE | undefined;
-  if (options.pxe) {
-    const { addPXE } = await import('./start_pxe.js');
-    ({ pxe } = await addPXE(options, signalHandlers, services, userLog, { node }));
-  }
-
   // Add a txs bot if requested
   if (options.bot) {
     const { addBot } = await import('./start_bot.js');
-    await addBot(options, signalHandlers, services, { pxe, node, telemetry });
+
+    const pxeConfig = extractRelevantOptions<PXEConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
+    const wallet = await EmbeddedWallet.create(node, { pxeConfig });
+
+    await addBot(options, signalHandlers, services, wallet, node, telemetry, undefined);
   }
 
   if (nodeConfig.autoUpdate !== 'disabled' && nodeConfig.autoUpdateUrl) {

package/src/cli/cmds/start_p2p_bootstrap.ts

@@ -1,6 +1,6 @@
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { type BootnodeConfig, BootstrapNode, bootnodeConfigMappings } from '@aztec/p2p';
 import { emptyChainConfig } from '@aztec/stdlib/config';
@@ -25,9 +25,9 @@ export async function startP2PBootstrap(
   userLog(`Starting P2P bootstrap node with config: ${jsonStringify(safeConfig)}`);
 
   const telemetryConfig = extractRelevantOptions<TelemetryClientConfig>(options, telemetryClientConfigMappings, 'tel');
-  const telemetryClient = initTelemetryClient(telemetryConfig);
+  const telemetryClient = await initTelemetryClient(telemetryConfig);
 
-  const store = await createStore('p2p-bootstrap', 1, config, createLogger('p2p:bootstrap:store'));
+  const store = await createStore('p2p-bootstrap', 1, config);
   const node = new BootstrapNode(store, telemetryClient);
   await node.start(config);
   signalHandlers.push(() => node.stop());

package/src/cli/cmds/start_prover_agent.ts

@@ -4,9 +4,9 @@ import { Agent, makeUndiciFetch } from '@aztec/foundation/json-rpc/undici';
 import type { LogFn } from '@aztec/foundation/log';
 import { buildServerCircuitProver } from '@aztec/prover-client';
 import {
-  InlineProofStore,
   type ProverAgentConfig,
   ProvingAgent,
+  createProofStore,
   createProvingJobBrokerClient,
   proverAgentConfigMappings,
 } from '@aztec/prover-client/broker';
@@ -53,20 +53,12 @@ export async function startProverAgent(
   );
   const broker = createProvingJobBrokerClient(config.proverBrokerUrl, getVersions(), fetch);
 
-  const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+  const telemetry = await initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
   const prover = await buildServerCircuitProver(config, telemetry);
-  const proofStore = new InlineProofStore();
+  const proofStore = await createProofStore(config.proofStore);
   const agents = times(
     config.proverAgentCount,
-    () =>
-      new ProvingAgent(
-        broker,
-        proofStore,
-        prover,
-        config.proverAgentProofTypes,
-        config.proverAgentPollIntervalMs,
-        telemetry,
-      ),
+    () => new ProvingAgent(broker, proofStore, prover, config.proverAgentProofTypes, config.proverAgentPollIntervalMs),
   );
 
   // expose all agents as individual services

package/src/cli/cmds/start_prover_broker.ts

@@ -1,10 +1,11 @@
 import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum';
+import { getPublicClient } from '@aztec/ethereum/client';
 import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
 import type { LogFn } from '@aztec/foundation/log';
 import {
   type ProverBrokerConfig,
   ProvingJobBrokerSchema,
+  ProvingJobBrokerSchemaWithDebug,
   createAndStartProvingBroker,
   proverBrokerConfigMappings,
 } from '@aztec/prover-client/broker';
@@ -45,7 +46,7 @@ export async function startProverBroker(
   config.l1Contracts = addresses;
   config.rollupVersion = rollupConfig.rollupVersion;
 
-  const client = initTelemetryClient(getTelemetryClientConfig());
+  const client = await initTelemetryClient(getTelemetryClientConfig());
   const broker = await createAndStartProvingBroker(config, client);
 
   if (options.autoUpdate !== 'disabled' && options.autoUpdateUrl) {
@@ -59,7 +60,10 @@ export async function startProverBroker(
     );
   }
 
-  services.proverBroker = [broker, ProvingJobBrokerSchema];
+  services.proverBroker = [
+    broker,
+    config.proverBrokerDebugReplayEnabled ? ProvingJobBrokerSchemaWithDebug : ProvingJobBrokerSchema,
+  ];
   signalHandlers.push(() => broker.stop());
 
   return { broker, config };

package/src/cli/util.ts

@@ -1,13 +1,14 @@
 import type { AztecNodeConfig } from '@aztec/aztec-node';
-import type { AccountManager, EthAddress, Fr } from '@aztec/aztec.js';
-import type { ViemClient } from '@aztec/ethereum';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import type { ViemClient } from '@aztec/ethereum/types';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+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 { PXEService } from '@aztec/pxe/server';
 import type { ProverConfig } from '@aztec/stdlib/interfaces/server';
-import { UpdateChecker } from '@aztec/stdlib/update-checker';
-import { getTelemetryClient } from '@aztec/telemetry-client';
+import { getTelemetryClient } from '@aztec/telemetry-client/start';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
@@ -35,7 +36,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
@@ -67,30 +68,19 @@ export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<voi
 /**
  * Creates logs for the initial accounts
  * @param accounts - The initial accounts
- * @param pxe - A PXE 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;
-  }[],
-  pxe: PXEService,
-) {
-  const registeredAccounts = await pxe.getRegisteredAccounts();
+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();
-    if (registeredAccounts.find(a => a.equals(completeAddress))) {
+  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`,
       );
@@ -271,7 +261,7 @@ export const extractRelevantOptions = <T>(
 };
 
 /**
- * Downloads just enough points to be able to verify ClientIVC proofs.
+ * Downloads just enough points to be able to verify Chonk proofs.
  * @param opts - Whether proof are to be verifier
  * @param log - Logging function
  */
@@ -310,6 +300,7 @@ export async function setupUpdateMonitor(
   updateNodeConfig?: (config: object) => Promise<void>,
 ) {
   const logger = createLogger('update-check');
+  const { UpdateChecker } = await import('@aztec/stdlib/update-checker');
   const checker = await UpdateChecker.new({
     baseURL: updatesLocation,
     publicClient,
@@ -386,3 +377,9 @@ export async function setupUpdateMonitor(
 
   checker.start();
 }
+
+export function stringifyConfig(config: object): string {
+  return Object.entries(config)
+    .map(([key, value]) => `${key}=${jsonStringify(value)}`)
+    .join(' ');
+}

package/src/cli/versioning.ts

@@ -1,13 +1,13 @@
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type ComponentsVersions, getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
 
 export function getVersions(config?: ChainConfig): Partial<ComponentsVersions> {
   return config
-    ? getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot())
+    ? getComponentsVersionsFromConfig(config, protocolContractsHash, getVKTreeRoot())
     : {
         l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
-        l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+        l2ProtocolContractsHash: protocolContractsHash.toString(),
       };
 }

package/src/examples/token.ts

@@ -1,13 +1,14 @@
-import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
-import { createPXEClient } from '@aztec/aztec.js';
+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 { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 const logger = createLogger('example:token');
 
-const url = 'http://localhost:8080';
+const nodeUrl = 'http://localhost:8080';
 
-const pxe = createPXEClient(url);
+const node = createAztecNodeClient(nodeUrl);
 
 const ALICE_MINT_BALANCE = 333n;
 const TRANSFER_AMOUNT = 33n;
@@ -18,40 +19,40 @@ const TRANSFER_AMOUNT = 33n;
 async function main() {
   logger.info('Running token contract test on HTTP interface.');
 
-  const [aliceWallet, bobWallet] = await getDeployedTestAccountsWallets(pxe);
-  const alice = aliceWallet.getAddress();
-  const bob = bobWallet.getAddress();
+  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();
+  await wallet.createSchnorrAccount(aliceInitialAccountData.secret, aliceInitialAccountData.salt);
+  await wallet.createSchnorrAccount(bobInitialAccountData.secret, bobInitialAccountData.salt);
+
+  const alice = aliceInitialAccountData.address;
+  const bob = bobInitialAccountData.address;
 
   logger.info(`Fetched Alice and Bob accounts: ${alice.toString()}, ${bob.toString()}`);
 
   logger.info('Deploying Token...');
-  const token = await TokenContract.deploy(aliceWallet, alice, 'TokenName', 'TokenSymbol', 18)
-    .send({ from: alice })
-    .deployed();
+  const token = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18).send({ from: alice });
   logger.info('Token deployed');
 
-  // Create the contract abstraction and link it to Alice's and Bob's wallet for future signing
-  const tokenAlice = await TokenContract.at(token.address, aliceWallet);
-  const tokenBob = await TokenContract.at(token.address, bobWallet);
-
   // Mint tokens to Alice
   logger.info(`Minting ${ALICE_MINT_BALANCE} more coins to Alice...`);
-  await tokenAlice.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 tokenAlice.methods.balance_of_private(alice).simulate({ from: alice });
+  const 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 tokenAlice.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 tokenAlice.methods.balance_of_private(alice).simulate({ from: alice });
+  const aliceBalance = await token.methods.balance_of_private(alice).simulate({ from: alice });
   logger.info(`Alice's balance ${aliceBalance}`);
 
-  const bobBalance = await tokenBob.methods.balance_of_private(bob).simulate({ from: bob });
+  const 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';
-import type { ExtendedViemWalletClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import type { Abi, Narrow } from 'abitype';

package/src/index.ts

@@ -1,6 +1,6 @@
 export {
-  createSandbox,
-  getDeployedBananaCoinAddress,
-  getDeployedBananaFPCAddress,
-  getDeployedSponsoredFPCAddress,
-} from './sandbox/index.js';
+  createLocalNetwork,
+  registerDeployedBananaCoinInWalletAndGetAddress,
+  registerDeployedBananaFPCInWalletAndGetAddress,
+  registerDeployedSponsoredFPCInWalletAndGetAddress,
+} from './local-network/index.js';