@aztec/aztec 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/cli/cmds/start_prover_node.ts

@@ -1,5 +1,8 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { NULL_KEY } from '@aztec/ethereum';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+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/client';
 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';
@@ -10,15 +13,11 @@ import {
   getProverNodeConfigFromEnv,
   proverNodeConfigMappings,
 } from '@aztec/prover-node';
-import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
 import { P2PApiSchema, ProverNodeApiSchema, type ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
 import { initTelemetryClient, makeTracedFetch, telemetryClientConfigMappings } from '@aztec/telemetry-client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { mnemonicToAccount } from 'viem/accounts';
-
-import { getL1Config } from '../get_l1_config.js';
-import { extractRelevantOptions } from '../util.js';
+import { extractRelevantOptions, preloadCrsDataForVerifying, setupUpdateMonitor } from '../util.js';
 import { getVersions } from '../versioning.js';
 import { startProverBroker } from './start_prover_broker.js';
 
@@ -38,53 +37,48 @@ export async function startProverNode(
     ...extractRelevantOptions<ProverNodeConfig>(options, proverNodeConfigMappings, 'proverNode'), // override with command line options
   };
 
-  if (!options.archiver && !proverConfig.archiverUrl) {
-    userLog('--archiver.archiverUrl is required to start a Prover Node without --archiver option');
-    process.exit(1);
-  }
-
-  if (!proverConfig.publisherPrivateKey || proverConfig.publisherPrivateKey === NULL_KEY) {
-    if (!options.l1Mnemonic) {
-      userLog(`--l1-mnemonic is required to start a Prover Node without --node.publisherPrivateKey`);
-      process.exit(1);
-    }
-    const hdAccount = mnemonicToAccount(options.l1Mnemonic);
-    const privKey = hdAccount.getHdKey().privateKey;
-    proverConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
-  }
-
-  // TODO(palla/prover-node) L1 contract addresses should not silently default to zero,
-  // they should be undefined if not set and fail loudly.
-  // Load l1 contract addresses from aztec node if not set.
-  const isRollupAddressSet =
-    proverConfig.l1Contracts?.rollupAddress && !proverConfig.l1Contracts.rollupAddress.isZero();
-  const nodeUrl = proverConfig.nodeUrl ?? proverConfig.proverCoordinationNodeUrl;
-  if (nodeUrl && !isRollupAddressSet) {
-    userLog(`Loading L1 contract addresses from aztec node at ${nodeUrl}`);
-    proverConfig.l1Contracts = await createAztecNodeClient(nodeUrl).getL1ContractAddresses();
+  if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
+    throw new Error('L1 registry address is required to start a Prover Node');
   }
 
-  // If we create an archiver here, validate the L1 config
-  if (options.archiver) {
-    if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
-      throw new Error('L1 registry address is required to start a Prover Node with --archiver option');
-    }
-    const { addresses, config } = await getL1Config(
-      proverConfig.l1Contracts.registryAddress,
-      proverConfig.l1RpcUrls,
-      proverConfig.l1ChainId,
+  const followsCanonicalRollup = typeof proverConfig.rollupVersion !== 'number';
+  const { addresses, config } = await getL1Config(
+    proverConfig.l1Contracts.registryAddress,
+    proverConfig.l1RpcUrls,
+    proverConfig.l1ChainId,
+    proverConfig.rollupVersion,
+  );
+  process.env.ROLLUP_CONTRACT_ADDRESS ??= addresses.rollupAddress.toString();
+  proverConfig.l1Contracts = addresses;
+  proverConfig = { ...proverConfig, ...config };
+
+  const testAccounts = proverConfig.testAccounts ? (await getInitialTestAccountsData()).map(a => a.address) : [];
+  const sponsoredFPCAccounts = proverConfig.sponsoredFPC ? [await getSponsoredFPCAddress()] : [];
+  const initialFundedAccounts = testAccounts.concat(sponsoredFPCAccounts);
+
+  userLog(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+  const { genesisArchiveRoot, prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
+
+  userLog(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+
+  if (!Fr.fromHexString(config.genesisArchiveTreeRoot).equals(genesisArchiveRoot)) {
+    throw new Error(
+      `The computed genesis archive tree root ${genesisArchiveRoot} does not match the expected genesis archive tree root ${config.genesisArchiveTreeRoot} for the rollup deployed at ${addresses.rollupAddress}`,
     );
-    proverConfig.l1Contracts = addresses;
-    proverConfig = { ...proverConfig, ...config };
   }
 
-  const telemetry = initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
+  const telemetry = await initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
 
   let broker: ProvingJobBroker;
   if (proverConfig.proverBrokerUrl) {
-    // at 1TPS we'd enqueue ~1k tube proofs and ~1k AVM proofs immediately
-    // set a lower connectio  limit such that we don't overload the server
-    const fetch = makeTracedFetch([1, 2, 3], false, makeUndiciFetch(new Agent({ connections: 100 })));
+    // 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(proverConfig.proverBrokerUrl, getVersions(proverConfig), fetch);
   } else if (options.proverBroker) {
     ({ broker } = await startProverBroker(options, signalHandlers, services, userLog));
@@ -99,14 +93,12 @@ export async function startProverNode(
     );
   }
 
-  const initialFundedAccounts = proverConfig.testAccounts ? await getInitialTestAccounts() : [];
-  const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+  await preloadCrsDataForVerifying(proverConfig, userLog);
 
   const proverNode = await createProverNode(proverConfig, { telemetry, broker }, { prefilledPublicData });
   services.proverNode = [proverNode, ProverNodeApiSchema];
 
-  const p2p = proverNode.getP2P();
-  if (p2p) {
+  if (proverNode.getP2P()) {
     services.p2p = [proverNode.getP2P(), P2PApiSchema];
   }
 
@@ -116,6 +108,17 @@ export async function startProverNode(
 
   signalHandlers.push(proverNode.stop.bind(proverNode));
 
-  proverNode.start();
+  await proverNode.start();
+
+  if (proverConfig.autoUpdate !== 'disabled' && proverConfig.autoUpdateUrl) {
+    await setupUpdateMonitor(
+      proverConfig.autoUpdate,
+      new URL(proverConfig.autoUpdateUrl),
+      followsCanonicalRollup,
+      getPublicClient(proverConfig),
+      proverConfig.l1Contracts.registryAddress,
+      signalHandlers,
+    );
+  }
   return { config: proverConfig };
 }

package/src/cli/preload_crs.ts

@@ -0,0 +1,7 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { preloadCrsDataForServerSideProving } from './util.js';
+
+export async function preloadCrs(_options: any, userLog: LogFn, _debugLogger: Logger) {
+  await preloadCrsDataForServerSideProving({ realProofs: true }, userLog);
+}

package/src/cli/release_version.ts

@@ -0,0 +1,21 @@
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+export const getCliVersion = () => {
+  const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+  const cliVersion: string = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+
+  // If the version is 0.1.0, this is a placeholder version and we are in a docker container; query release please for the latest version
+  if (cliVersion === '0.1.0') {
+    const releasePleasePath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      '../../../../.release-please-manifest.json',
+    );
+    const releaseVersion = JSON.parse(readFileSync(releasePleasePath).toString())['.'];
+    return releaseVersion;
+  }
+
+  return cliVersion;
+};

package/src/cli/util.ts

@@ -1,33 +1,74 @@
-import type { AccountManager, Fr } from '@aztec/aztec.js';
+import type { AztecNodeConfig } from '@aztec/aztec-node';
+import type { AccountManager } from '@aztec/aztec.js/wallet';
+import type { ViemClient } from '@aztec/ethereum/types';
 import type { ConfigMappingsType } from '@aztec/foundation/config';
-import type { LogFn } from '@aztec/foundation/log';
-import type { PXEService } from '@aztec/pxe/server';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+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 { getTelemetryClient } from '@aztec/telemetry-client/start';
+import type { TestWallet } from '@aztec/test-wallet/server';
 
 import chalk from 'chalk';
 import type { Command } from 'commander';
 
 import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
 
+export const enum ExitCode {
+  SUCCESS = 0,
+  ERROR = 1,
+  ROLLUP_UPGRADE = 78, // EX_CONFIG from FreeBSD (https://man.freebsd.org/cgi/man.cgi?query=sysexits)
+  VERSION_UPGRADE = 79, // prev + 1 because there's nothing better
+  // 128 + int(SIGNAL)
+  SIGHUP = 129,
+  SIGINT = 130,
+  SIGQUIT = 131,
+  SIGTERM = 143,
+}
+
+let shutdownPromise: Promise<never> | undefined;
+export function shutdown(logFn: LogFn, exitCode: ExitCode, cb?: Array<() => Promise<void>>): Promise<never> {
+  if (shutdownPromise) {
+    logFn('Already shutting down.');
+    return shutdownPromise;
+  }
+
+  logFn('Shutting down...', { exitCode });
+  if (cb) {
+    shutdownPromise = Promise.allSettled(cb).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
+    process.exit(exitCode);
+  }
+
+  return shutdownPromise;
+}
+
+export function isShuttingDown(): boolean {
+  return shutdownPromise !== undefined;
+}
+
 export const installSignalHandlers = (logFn: LogFn, cb?: Array<() => Promise<void>>) => {
-  const shutdown = async () => {
-    logFn('Shutting down...');
-    if (cb) {
-      await Promise.all(cb);
-    }
-    process.exit(0);
-  };
-  process.removeAllListeners('SIGINT');
-  process.removeAllListeners('SIGTERM');
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  process.once('SIGINT', shutdown);
-  // eslint-disable-next-line @typescript-eslint/no-misused-promises
-  process.once('SIGTERM', shutdown);
+  const signals = [
+    ['SIGINT', ExitCode.SIGINT],
+    ['SIGTERM', ExitCode.SIGTERM],
+    ['SIGHUP', ExitCode.SIGHUP],
+    ['SIQUIT', ExitCode.SIGQUIT],
+  ] as const;
+
+  for (const [signal, exitCode] of signals) {
+    process.removeAllListeners(signal);
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    process.once(signal, () => shutdown(logFn, exitCode, cb));
+  }
 };
 
 /**
  * Creates logs for the initial accounts
  * @param accounts - The initial accounts
- * @param pxe - A PXE instance to get the registered accounts
+ * @param wallet - A TestWallet instance to get the registered accounts
  * @returns A string array containing the initial accounts details
  */
 export async function createAccountLogs(
@@ -41,13 +82,13 @@ export async function createAccountLogs(
      */
     secretKey: Fr;
   }[],
-  pxe: PXEService,
+  wallet: TestWallet,
 ) {
-  const registeredAccounts = await pxe.getRegisteredAccounts();
+  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))) {
+    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`);
@@ -102,18 +143,32 @@ export function formatHelpLine(
 
 const getDefaultOrEnvValue = (opt: AztecStartOption) => {
   let val;
-  // if the option is set in the environment, use that & parse it
-  if (opt.envVar && process.env[opt.envVar]) {
-    val = process.env[opt.envVar];
-    if (val && opt.parseVal) {
-      return opt.parseVal(val);
+
+  // if the option is set in the environment, use that
+  if (opt.env) {
+    val = process.env[opt.env];
+  }
+
+  // if we have fallback env vars, check those
+  if (!val && opt.fallback && opt.fallback.length > 0) {
+    for (const fallback of opt.fallback) {
+      val = process.env[fallback];
+      if (val) {
+        break;
+      }
     }
-    // if no env variable, use the default value
-  } else if (opt.defaultValue) {
-    val = opt.defaultValue;
   }
 
-  return val;
+  // if we have a value, optionally parse it and return
+  if (val) {
+    if (opt.parseVal) {
+      return opt.parseVal(val);
+    }
+    return val;
+  } else if (opt.defaultValue !== undefined) {
+    return opt.defaultValue;
+  }
+  return undefined;
 };
 
 // Function to add options dynamically
@@ -121,7 +176,7 @@ export const addOptions = (cmd: Command, options: AztecStartOption[]) => {
   options.forEach(opt => {
     cmd.option(
       opt.flag,
-      `${opt.description} (default: ${opt.defaultValue}) ($${opt.envVar})`,
+      `${opt.description} (default: ${opt.defaultValue}) ($${opt.env})`,
       opt.parseVal ? opt.parseVal : val => val,
       getDefaultOrEnvValue(opt),
     );
@@ -137,10 +192,11 @@ export const printAztecStartHelpText = () => {
     helpTextLines.push('');
 
     aztecStartOptions[category].forEach(opt => {
-      const defaultValueText = opt.defaultValue
-        ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
-        : '';
-      const envVarText = opt.envVar ? `($${opt.envVar})` : '';
+      const defaultValueText =
+        opt.defaultValue || (Array.isArray(opt.defaultValue) && opt.defaultValue.length > 0)
+          ? `(default: ${opt.printDefault ? opt.printDefault(opt.defaultValue) : opt.defaultValue})`
+          : '';
+      const envVarText = opt.env ? `($${opt.env})` : '';
       const flagText = `${opt.flag}`;
 
       const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
@@ -214,3 +270,121 @@ export const extractRelevantOptions = <T>(
 
   return relevantOptions;
 };
+
+/**
+ * Downloads just enough points to be able to verify Chonk proofs.
+ * @param opts - Whether proof are to be verifier
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForVerifying(
+  { realProofs }: Pick<AztecNodeConfig, 'realProofs'>,
+  log: LogFn,
+): 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)]);
+  }
+}
+
+/**
+ * Downloads enough points to be able to prove every server-side circuit
+ * @param opts - Whether real proof are to be generated
+ * @param log - Logging function
+ */
+export async function preloadCrsDataForServerSideProving(
+  { realProofs }: Pick<ProverConfig, 'realProofs'>,
+  log: LogFn,
+): 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)]);
+  }
+}
+
+export async function setupUpdateMonitor(
+  autoUpdateMode: SharedNodeConfig['autoUpdate'],
+  updatesLocation: URL,
+  followsCanonicalRollup: boolean,
+  publicClient: ViemClient,
+  registryContractAddress: EthAddress,
+  signalHandlers: Array<() => Promise<void>>,
+  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,
+    registryContractAddress,
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  checker.on('newRollupVersion', async ({ latestVersion, currentVersion }) => {
+    if (isShuttingDown()) {
+      return;
+    }
+
+    // if node follows canonical rollup then this is equivalent to a config update
+    if (!followsCanonicalRollup) {
+      return;
+    }
+
+    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 });
+    }
+  });
+
+  // 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 });
+    }
+  });
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  checker.on('updateNodeConfig', async config => {
+    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
+  });
+
+  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();
+}

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 { TestWallet } from '@aztec/test-wallet/server';
 
 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,39 +19,42 @@ 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.getCompleteAddress();
-  const bob = bobWallet.getCompleteAddress();
+  const wallet = await TestWallet.create(node);
 
-  logger.info(`Fetched Alice and Bob accounts: ${alice.address.toString()}, ${bob.address.toString()}`);
+  // 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().deployed();
+  const token = await TokenContract.deploy(wallet, alice, 'TokenName', 'TokenSymbol', 18)
+    .send({ from: alice })
+    .deployed();
   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...`);
-  const from = aliceWallet.getAddress(); // we are setting from to Alice here because we need a sender to calculate the tag
-  await tokenAlice.methods.mint_to_private(from, aliceWallet.getAddress(), ALICE_MINT_BALANCE).send().wait();
+  await token.methods.mint_to_private(alice, ALICE_MINT_BALANCE).send({ from: alice }).wait();
 
   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();
+  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().wait();
+  await token.methods.transfer(bob, TRANSFER_AMOUNT).send({ from: alice }).wait();
 
   // Check the new balances
-  const aliceBalance = await tokenAlice.methods.balance_of_private(alice).simulate();
+  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();
+  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 { ViemPublicClient, ViemWalletClient } 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';
@@ -7,27 +7,25 @@ import type { Hex } from 'viem';
 
 /**
  * Helper function to deploy ETH contracts.
- * @param walletClient - A viem WalletClient.
- * @param publicClient - A viem PublicClient.
+ * @param l1Client - A viem WalletClient extended with public actions.
  * @param abi - The ETH contract's ABI (as abitype's Abi).
  * @param bytecode  - The ETH contract's bytecode.
  * @param args - Constructor arguments for the contract.
  * @returns The ETH address the contract was deployed to.
  */
 export async function deployL1Contract(
-  walletClient: ViemWalletClient,
-  publicClient: ViemPublicClient,
+  l1Client: ExtendedViemWalletClient,
   abi: Narrow<Abi | readonly unknown[]>,
   bytecode: Hex,
   args: readonly unknown[] = [],
 ): Promise<EthAddress> {
-  const hash = await walletClient.deployContract({
+  const hash = await l1Client.deployContract({
     abi,
     bytecode,
     args,
   });
 
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const receipt = await l1Client.waitForTransactionReceipt({ hash });
   const contractAddress = receipt.contractAddress;
   if (!contractAddress) {
     throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);

package/src/index.ts

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