@aztec/aztec 0.0.0-test.0

package/src/cli/util.ts

@@ -0,0 +1,216 @@
+import type { AccountManager, Fr } from '@aztec/aztec.js';
+import type { ConfigMappingsType } from '@aztec/foundation/config';
+import type { LogFn } from '@aztec/foundation/log';
+import type { PXEService } from '@aztec/pxe/server';
+
+import chalk from 'chalk';
+import type { Command } from 'commander';
+
+import { type AztecStartOption, aztecStartOptions } from './aztec_start_options.js';
+
+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);
+};
+
+/**
+ * Creates logs for the initial accounts
+ * @param accounts - The initial accounts
+ * @param pxe - A PXE 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();
+  const accountLogStrings = [`Initial Accounts:\n\n`];
+  for (const accountWithSecretKey of accountsWithSecretKeys) {
+    const completeAddress = await accountWithSecretKey.account.getCompleteAddress();
+    if (registeredAccounts.find(a => a.equals(completeAddress))) {
+      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(
+        ` Master nullifier public key: ${completeAddress.publicKeys.masterNullifierPublicKey.toString()}\n`,
+      );
+      accountLogStrings.push(
+        ` Master incoming viewing public key: ${completeAddress.publicKeys.masterIncomingViewingPublicKey.toString()}\n\n`,
+      );
+      accountLogStrings.push(
+        ` Master outgoing viewing public key: ${completeAddress.publicKeys.masterOutgoingViewingPublicKey.toString()}\n\n`,
+      );
+      accountLogStrings.push(
+        ` Master tagging public key: ${completeAddress.publicKeys.masterTaggingPublicKey.toString()}\n\n`,
+      );
+    }
+  }
+  return accountLogStrings;
+}
+
+export function getMaxLengths(sections: { [key: string]: AztecStartOption[] }): [number, number] {
+  let maxFlagLength = 0;
+  let maxDefaultLength = 0;
+
+  Object.values(sections).forEach(options => {
+    options.forEach(option => {
+      if (option.flag.length > maxFlagLength) {
+        maxFlagLength = option.flag.length;
+      }
+      const defaultLength = option.defaultValue ? option.defaultValue.length : 0;
+      if (defaultLength > maxDefaultLength) {
+        maxDefaultLength = defaultLength;
+      }
+    });
+  });
+
+  return [maxFlagLength + 1, maxDefaultLength + 1];
+}
+
+export function formatHelpLine(
+  option: string,
+  defaultValue: string,
+  envVar: string,
+  maxOptionLength: number,
+  maxDefaultLength: number,
+): string {
+  const paddedOption = option.padEnd(maxOptionLength + 2, ' ');
+  const paddedDefault = defaultValue.padEnd(maxDefaultLength + 2, ' ');
+
+  return `${chalk.cyan(paddedOption)}${chalk.yellow(paddedDefault)}${chalk.green(envVar)}`;
+}
+
+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 no env variable, use the default value
+  } else if (opt.defaultValue) {
+    val = opt.defaultValue;
+  }
+
+  return val;
+};
+
+// Function to add options dynamically
+export const addOptions = (cmd: Command, options: AztecStartOption[]) => {
+  options.forEach(opt => {
+    cmd.option(
+      opt.flag,
+      `${opt.description} (default: ${opt.defaultValue}) ($${opt.envVar})`,
+      opt.parseVal ? opt.parseVal : val => val,
+      getDefaultOrEnvValue(opt),
+    );
+  });
+};
+
+export const printAztecStartHelpText = () => {
+  const helpTextLines: string[] = [''];
+  const [maxFlagLength, maxDefaultLength] = getMaxLengths(aztecStartOptions);
+
+  Object.keys(aztecStartOptions).forEach(category => {
+    helpTextLines.push(chalk.bold.blue(`  ${category}`));
+    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 flagText = `${opt.flag}`;
+
+      const paddedText = formatHelpLine(flagText, defaultValueText, envVarText, maxFlagLength, maxDefaultLength);
+
+      helpTextLines.push(`    ${paddedText}`);
+      helpTextLines.push(`          ${chalk.white(opt.description)}`);
+      helpTextLines.push('');
+    });
+  });
+
+  return helpTextLines.join('\n');
+};
+
+/**
+ * Extracts namespaced options from a key-value map.
+ * @param options - Key-value map of options.
+ * @param namespace - The namespace to extract.
+ * @returns Key-value map of namespaced options.
+ */
+export const extractNamespacedOptions = (options: Record<string, any>, namespace: string) => {
+  const extract = `${namespace}.`;
+  const namespacedOptions: Record<string, any> = {};
+  for (const key in options) {
+    if (key.startsWith(extract)) {
+      namespacedOptions[key.replace(extract, '')] = options[key];
+    }
+  }
+  return namespacedOptions;
+};
+
+/**
+ * Extracts relevant options from a key-value map.
+ * @template T - The type of the relevant options.
+ * @param options - Key-value map of options.
+ * @param mappings - The mappings to extract.
+ * @param namespace - The namespace to extract for.
+ * @returns Key-value map of relevant options.
+ */
+export const extractRelevantOptions = <T>(
+  options: Record<string, any>,
+  mappings: ConfigMappingsType<T>,
+  namespace: string,
+): T => {
+  const relevantOptions: T = {} as T;
+
+  // Iterate over each key in the options
+  Object.keys(options).forEach(optionKey => {
+    const keyParts = optionKey.split('.');
+    const optionNamespace = keyParts.length > 1 ? keyParts[0] : '';
+    const mainKey = keyParts.length > 1 ? keyParts[1] : keyParts[0];
+
+    // Check if the key exists in the mappings
+    if (mainKey in mappings) {
+      // Check for duplicates in the options
+      const duplicates = Object.keys(options).filter(optKey => {
+        const optKeyParts = optKey.split('.');
+        return optKeyParts[1] === mainKey || optKeyParts[0] === mainKey;
+      });
+
+      // If duplicates are found, use the namespace to differentiate
+      if (duplicates.length > 1) {
+        if (namespace === optionNamespace) {
+          relevantOptions[mainKey as keyof T] = options[optionKey];
+        }
+      } else {
+        // If no duplicates, extract the value without considering the namespace
+        relevantOptions[mainKey as keyof T] = options[optionKey];
+      }
+    }
+  });
+
+  return relevantOptions;
+};

package/src/cli/versioning.ts

@@ -0,0 +1,13 @@
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } 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())
+    : {
+        l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
+        l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+      };
+}

package/src/examples/token.ts

@@ -0,0 +1,65 @@
+import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import { createPXEClient } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/foundation/log';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+
+const logger = createLogger('example:token');
+
+const url = 'http://localhost:8080';
+
+const pxe = createPXEClient(url);
+
+const ALICE_MINT_BALANCE = 333n;
+const TRANSFER_AMOUNT = 33n;
+
+/**
+ * Main function.
+ */
+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();
+
+  logger.info(`Fetched Alice and Bob accounts: ${alice.address.toString()}, ${bob.address.toString()}`);
+
+  logger.info('Deploying Token...');
+  const token = await TokenContract.deploy(aliceWallet, alice, 'TokenName', 'TokenSymbol', 18).send().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();
+
+  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();
+  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();
+
+  // Check the new balances
+  const aliceBalance = await tokenAlice.methods.balance_of_private(alice).simulate();
+  logger.info(`Alice's balance ${aliceBalance}`);
+
+  const bobBalance = await tokenBob.methods.balance_of_private(bob).simulate();
+  logger.info(`Bob's balance ${bobBalance}`);
+}
+
+main()
+  .then(() => {
+    logger.info('Finished running successfully.');
+    process.exit(0);
+  })
+  .catch(err => {
+    logger.error('Error in main fn: ', err);
+    process.exit(1);
+  });

package/src/examples/util.ts

@@ -0,0 +1,45 @@
+import { EthAddress } from '@aztec/aztec.js';
+import type { ViemPublicClient, ViemWalletClient } from '@aztec/ethereum';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+
+import type { Abi, Narrow } from 'abitype';
+import type { Hex } from 'viem';
+
+/**
+ * Helper function to deploy ETH contracts.
+ * @param walletClient - A viem WalletClient.
+ * @param publicClient - A viem PublicClient.
+ * @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,
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[] = [],
+): Promise<EthAddress> {
+  const hash = await walletClient.deployContract({
+    abi,
+    bytecode,
+    args,
+  });
+
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const contractAddress = receipt.contractAddress;
+  if (!contractAddress) {
+    throw new Error(`No contract address found in receipt: ${jsonStringify(receipt)}`);
+  }
+
+  return EthAddress.fromString(receipt.contractAddress!);
+}
+
+/**
+ * Sleep for a given number of milliseconds.
+ * @param ms - the number of milliseconds to sleep for
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise<void>(resolve => setTimeout(resolve, ms));
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export {
+  createSandbox,
+  getDeployedBananaCoinAddress,
+  getDeployedBananaFPCAddress,
+  getDeployedSponsoredFPCAddress,
+  SponsoredFeePaymentMethod,
+} from './sandbox/index.js';

package/src/mnemonic.ts

@@ -0,0 +1 @@
+export const DefaultMnemonic = 'test test test test test test test test test test test junk';

package/src/sandbox/banana_fpc.ts

@@ -0,0 +1,83 @@
+import { type InitialAccountData, getInitialTestAccounts } from '@aztec/accounts/testing';
+import type { Wallet } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+import { FPCContract } from '@aztec/noir-contracts.js/FPC';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractInstanceWithAddress, getContractInstanceFromDeployParams } from '@aztec/stdlib/contract';
+import type { PXE } from '@aztec/stdlib/interfaces/client';
+
+const BANANA_COIN_SALT = new Fr(0);
+const bananaCoinArgs = {
+  name: 'BC',
+  symbol: 'BC',
+  decimal: 18n,
+};
+
+const BANANA_FPC_SALT = new Fr(0);
+
+function getBananaAdmin(initialAccounts: InitialAccountData[]): AztecAddress {
+  return initialAccounts[0]?.address ?? AztecAddress.ZERO;
+}
+
+async function getBananaCoinInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
+  const admin = getBananaAdmin(initialAccounts);
+  return await getContractInstanceFromDeployParams(TokenContract.artifact, {
+    constructorArgs: [admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal],
+    salt: BANANA_COIN_SALT,
+  });
+}
+
+export async function getBananaCoinAddress(initialAccounts: InitialAccountData[]) {
+  return (await getBananaCoinInstance(initialAccounts)).address;
+}
+
+async function getBananaFPCInstance(initialAccounts: InitialAccountData[]): Promise<ContractInstanceWithAddress> {
+  const bananaCoin = await getBananaCoinAddress(initialAccounts);
+  const admin = getBananaAdmin(initialAccounts);
+  return await getContractInstanceFromDeployParams(FPCContract.artifact, {
+    constructorArgs: [bananaCoin, admin],
+    salt: BANANA_FPC_SALT,
+  });
+}
+
+export async function getBananaFPCAddress(initialAccounts: InitialAccountData[]) {
+  return (await getBananaFPCInstance(initialAccounts)).address;
+}
+
+export async function setupBananaFPC(initialAccounts: InitialAccountData[], deployer: Wallet, log: LogFn) {
+  const bananaCoinAddress = await getBananaCoinAddress(initialAccounts);
+  const admin = getBananaAdmin(initialAccounts);
+  const [bananaCoin, fpc] = await Promise.all([
+    TokenContract.deploy(deployer, admin, bananaCoinArgs.name, bananaCoinArgs.symbol, bananaCoinArgs.decimal)
+      .send({ contractAddressSalt: BANANA_COIN_SALT, universalDeploy: true })
+      .deployed(),
+    FPCContract.deploy(deployer, bananaCoinAddress, admin)
+      .send({ contractAddressSalt: BANANA_FPC_SALT, universalDeploy: true })
+      .deployed(),
+  ]);
+
+  log(`BananaCoin: ${bananaCoin.address}`);
+  log(`FPC: ${fpc.address}`);
+}
+
+export async function getDeployedBananaCoinAddress(pxe: PXE) {
+  const initialAccounts = await getInitialTestAccounts();
+  const bananaCoin = await getBananaCoinAddress(initialAccounts);
+  const contracts = await pxe.getContracts();
+  if (!contracts.find(c => c.equals(bananaCoin))) {
+    throw new Error('BananaCoin not deployed.');
+  }
+  return bananaCoin;
+}
+
+export async function getDeployedBananaFPCAddress(pxe: PXE) {
+  const initialAccounts = await getInitialTestAccounts();
+  const fpc = await getBananaFPCInstance(initialAccounts);
+  const contracts = await pxe.getContracts();
+  if (!contracts.find(c => c.equals(fpc.address))) {
+    throw new Error('BananaFPC not deployed.');
+  }
+  return fpc.address;
+}

package/src/sandbox/index.ts

@@ -0,0 +1,5 @@
+export * from './sandbox.js';
+
+export { getDeployedBananaCoinAddress, getDeployedBananaFPCAddress } from './banana_fpc.js';
+export { getDeployedSponsoredFPCAddress } from './sponsored_fpc.js';
+export { SponsoredFeePaymentMethod } from './sponsored_fee_payment_method.js';

package/src/sandbox/sandbox.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env -S node --no-warnings
+import { getSchnorrWallet } from '@aztec/accounts/schnorr';
+import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
+import { AnvilTestWatcher, EthCheatCodes, SignerlessWallet } from '@aztec/aztec.js';
+import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
+import { setupCanonicalL2FeeJuice } from '@aztec/cli/setup-contracts';
+import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import {
+  NULL_KEY,
+  createEthereumChain,
+  deployL1Contracts,
+  getL1ContractsConfigEnvVars,
+  waitForPublicClient,
+} from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { type LogFn, createLogger } from '@aztec/foundation/log';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { ProtocolContractAddress, protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import {
+  type TelemetryClient,
+  getConfigEnvVars as getTelemetryClientConfig,
+  initTelemetryClient,
+} from '@aztec/telemetry-client';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { type HDAccount, type PrivateKeyAccount, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
+
+import { createAccountLogs } from '../cli/util.js';
+import { DefaultMnemonic } from '../mnemonic.js';
+import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
+import { getSponsoredFPCAddress, setupSponsoredFPC } from './sponsored_fpc.js';
+
+const logger = createLogger('sandbox');
+
+const localAnvil = foundry;
+
+/**
+ * Function to deploy our L1 contracts to the sandbox L1
+ * @param aztecNodeConfig - The Aztec Node Config
+ * @param hdAccount - Account for publishing L1 contracts
+ */
+export async function deployContractsToL1(
+  aztecNodeConfig: AztecNodeConfig,
+  hdAccount: HDAccount | PrivateKeyAccount,
+  contractDeployLogger = logger,
+  opts: { assumeProvenThroughBlockNumber?: number; salt?: number; genesisArchiveRoot?: Fr; genesisBlockHash?: Fr } = {},
+) {
+  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,
+      l2FeeJuiceAddress: ProtocolContractAddress.FeeJuice.toField(),
+      vkTreeRoot: getVKTreeRoot(),
+      protocolContractTreeRoot,
+      genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+      genesisBlockHash: opts.genesisBlockHash ?? new Fr(GENESIS_BLOCK_HASH),
+      salt: opts.salt,
+    },
+  );
+
+  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+
+  return aztecNodeConfig.l1Contracts;
+}
+
+/** Sandbox settings. */
+export type SandboxConfig = AztecNodeConfig & {
+  /** Mnemonic used to derive the L1 deployer private key.*/
+  l1Mnemonic: string;
+  /** Salt used to deploy L1 contracts.*/
+  l1Salt: string;
+  /** Whether to expose PXE service on sandbox start.*/
+  noPXE: boolean;
+  /** Whether to deploy test accounts on sandbox start.*/
+  testAccounts: boolean;
+};
+
+/**
+ * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
+ * Does not start any HTTP services nor populate any initial accounts.
+ * @param config - Optional Sandbox settings.
+ */
+export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog: LogFn) {
+  // sandbox is meant for test envs. We should only need one l1RpcUrl
+  const l1RpcUrl = config.l1RpcUrls?.[0];
+  if (!l1RpcUrl) {
+    throw new Error('An L1 RPC URL is required');
+  }
+  if ((config.l1RpcUrls?.length || 0) > 1) {
+    logger.warn(`Multiple L1 RPC URLs provided. Sandbox will only use the first one: ${l1RpcUrl}`);
+  }
+  const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
+  const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
+  if (!aztecNodeConfig.publisherPrivateKey || aztecNodeConfig.publisherPrivateKey === NULL_KEY) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.publisherPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+  }
+  if (!aztecNodeConfig.validatorPrivateKey || aztecNodeConfig.validatorPrivateKey === NULL_KEY) {
+    const privKey = hdAccount.getHdKey().privateKey;
+    aztecNodeConfig.validatorPrivateKey = `0x${Buffer.from(privKey!).toString('hex')}`;
+  }
+
+  const initialAccounts = await (async () => {
+    if (config.testAccounts) {
+      if (aztecNodeConfig.p2pEnabled) {
+        userLog(`Not setting up test accounts as we are connecting to a network`);
+      } else if (config.noPXE) {
+        userLog(`Not setting up test accounts as we are not exposing a PXE`);
+      } else {
+        return await getInitialTestAccounts();
+      }
+    }
+    return [];
+  })();
+
+  const bananaFPC = await getBananaFPCAddress(initialAccounts);
+  const sponsoredFPC = await getSponsoredFPCAddress();
+  const fundedAddresses = initialAccounts.length
+    ? [...initialAccounts.map(a => a.address), bananaFPC, sponsoredFPC]
+    : [];
+  const { genesisArchiveRoot, genesisBlockHash, prefilledPublicData } = await getGenesisValues(fundedAddresses);
+
+  let watcher: AnvilTestWatcher | undefined = undefined;
+  if (!aztecNodeConfig.p2pEnabled) {
+    const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
+      assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
+      genesisArchiveRoot,
+      genesisBlockHash,
+      salt: config.l1Salt ? parseInt(config.l1Salt) : undefined,
+    });
+
+    const chain =
+      aztecNodeConfig.l1RpcUrls.length > 0
+        ? createEthereumChain([l1RpcUrl], aztecNodeConfig.l1ChainId)
+        : { chainInfo: localAnvil };
+
+    const publicClient = createPublicClient({
+      chain: chain.chainInfo,
+      transport: fallback([httpViemTransport(l1RpcUrl)]) as any,
+    });
+
+    watcher = new AnvilTestWatcher(new EthCheatCodes([l1RpcUrl]), l1ContractAddresses.rollupAddress, publicClient);
+    watcher.setIsSandbox(true);
+    await watcher.start();
+  }
+
+  const telemetry = initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob sink client inside the sandbox, no http connectivity
+  const blobSinkClient = createBlobSinkClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobSinkClient }, { prefilledPublicData });
+  const pxe = await createAztecPXE(node);
+
+  await setupCanonicalL2FeeJuice(
+    new SignerlessWallet(pxe),
+    aztecNodeConfig.l1Contracts.feeJuicePortalAddress,
+    undefined,
+    logger.info,
+  );
+
+  if (initialAccounts.length) {
+    userLog('Setting up funded test accounts...');
+    const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
+    const accountsWithSecrets = accounts.map((account, i) => ({
+      account,
+      secretKey: initialAccounts[i].secret,
+    }));
+    const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
+    userLog(accLogs.join(''));
+
+    const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
+    await setupBananaFPC(initialAccounts, deployer, userLog);
+    await setupSponsoredFPC(deployer, userLog);
+  }
+
+  const stop = async () => {
+    await node.stop();
+    await watcher?.stop();
+  };
+
+  return { node, pxe, stop };
+}
+
+/**
+ * Create and start a new Aztec RPC HTTP Server
+ * @param config - Optional Aztec node settings.
+ */
+export async function createAztecNode(
+  config: Partial<AztecNodeConfig> = {},
+  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface } = {},
+  options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
+) {
+  // TODO(#12272): will clean this up. This is criminal.
+  const { l1Contracts, ...rest } = getConfigEnvVars();
+  const aztecNodeConfig: AztecNodeConfig = {
+    ...rest,
+    ...config,
+    l1Contracts: { ...l1Contracts, ...config.l1Contracts },
+  };
+  logger.info('createAztecNode', aztecNodeConfig);
+  const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+  return node;
+}
+
+/**
+ * Create and start a new Aztec PXE HTTP Server
+ * @param config - Optional PXE settings.
+ */
+export async function createAztecPXE(node: AztecNode, config: Partial<PXEServiceConfig> = {}) {
+  const pxeServiceConfig: PXEServiceConfig = { ...getPXEServiceConfig(), ...config };
+  const pxe = await createPXEService(node, pxeServiceConfig);
+  return pxe;
+}