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

package/src/cli/cmds/start_prover_node.ts

@@ -1,124 +0,0 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { Fr } from '@aztec/aztec.js';
-import { getSponsoredFPCAddress } from '@aztec/cli/cli-utils';
-import { getL1Config } from '@aztec/cli/config';
-import { getPublicClient } from '@aztec/ethereum';
-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 { ProvingJobConsumerSchema, createProvingJobBrokerClient } from '@aztec/prover-client/broker';
-import {
-  type ProverNodeConfig,
-  createProverNode,
-  getProverNodeConfigFromEnv,
-  proverNodeConfigMappings,
-} from '@aztec/prover-node';
-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 { extractRelevantOptions, preloadCrsDataForVerifying, setupUpdateMonitor } from '../util.js';
-import { getVersions } from '../versioning.js';
-import { startProverBroker } from './start_prover_broker.js';
-
-export async function startProverNode(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  userLog: LogFn,
-): Promise<{ config: ProverNodeConfig }> {
-  if (options.node || options.sequencer || options.pxe || options.p2pBootstrap || options.txe) {
-    userLog(`Starting a prover-node with --node, --sequencer, --pxe, --p2p-bootstrap, or --txe is not supported.`);
-    process.exit(1);
-  }
-
-  let proverConfig = {
-    ...getProverNodeConfigFromEnv(), // get default config from env
-    ...extractRelevantOptions<ProverNodeConfig>(options, proverNodeConfigMappings, 'proverNode'), // override with command line options
-  };
-
-  if (!proverConfig.l1Contracts.registryAddress || proverConfig.l1Contracts.registryAddress.isZero()) {
-    throw new Error('L1 registry address is required to start a Prover Node');
-  }
-
-  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 getInitialTestAccounts()).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}`,
-    );
-  }
-
-  const telemetry = 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 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));
-  } else {
-    userLog(`--prover-broker-url or --prover-broker is required to start a Prover Node`);
-    process.exit(1);
-  }
-
-  if (proverConfig.proverAgentCount === 0) {
-    userLog(
-      `Running prover node without local prover agent. Connect one or more prover agents to this node or pass --proverAgent.proverAgentCount`,
-    );
-  }
-
-  await preloadCrsDataForVerifying(proverConfig, userLog);
-
-  const proverNode = await createProverNode(proverConfig, { telemetry, broker }, { prefilledPublicData });
-  services.proverNode = [proverNode, ProverNodeApiSchema];
-
-  if (proverNode.getP2P()) {
-    services.p2p = [proverNode.getP2P(), P2PApiSchema];
-  }
-
-  if (!proverConfig.proverBrokerUrl) {
-    services.provingJobSource = [proverNode.getProver().getProvingJobSource(), ProvingJobConsumerSchema];
-  }
-
-  signalHandlers.push(proverNode.stop.bind(proverNode));
-
-  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/cmds/start_pxe.ts

@@ -1,49 +0,0 @@
-import type { NamespacedApiHandlers } from '@aztec/foundation/json-rpc/server';
-import type { LogFn } from '@aztec/foundation/log';
-import {
-  type CliPXEOptions,
-  type PXEService,
-  type PXEServiceConfig,
-  allPxeConfigMappings,
-  createPXEService,
-} from '@aztec/pxe/server';
-import { type AztecNode, PXESchema, createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
-import { makeTracedFetch } from '@aztec/telemetry-client';
-
-import { extractRelevantOptions } from '../util.js';
-import { getVersions } from '../versioning.js';
-
-export type { PXEServiceConfig, CliPXEOptions };
-
-export async function startPXE(
-  options: any,
-  signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  userLog: LogFn,
-): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
-  return await addPXE(options, signalHandlers, services, userLog, {});
-}
-
-export async function addPXE(
-  options: any,
-  _signalHandlers: (() => Promise<void>)[],
-  services: NamespacedApiHandlers,
-  userLog: LogFn,
-  deps: { node?: AztecNode } = {},
-): Promise<{ pxe: PXEService; config: PXEServiceConfig & CliPXEOptions }> {
-  const pxeConfig = extractRelevantOptions<PXEServiceConfig & CliPXEOptions>(options, allPxeConfigMappings, 'pxe');
-  const nodeUrl = pxeConfig.nodeUrl;
-
-  if (!nodeUrl && !deps.node) {
-    userLog('Aztec Node URL (nodeUrl | AZTEC_NODE_URL) option is required to start PXE without --node option');
-    process.exit(1);
-  }
-
-  const node = deps.node ?? createAztecNodeClient(nodeUrl!, getVersions(pxeConfig), makeTracedFetch([1, 2, 3], true));
-  const pxe = await createPXEService(node, pxeConfig as PXEServiceConfig);
-
-  // Add PXE to services list
-  services.pxe = [pxe, PXESchema];
-
-  return { pxe, config: pxeConfig };
-}

package/src/sandbox/index.ts

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

package/src/sandbox/sandbox.ts

@@ -1,253 +0,0 @@
-#!/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 { EthAddress } from '@aztec/aztec.js';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
-import { setupSponsoredFPC } from '@aztec/cli/cli-utils';
-import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import {
-  NULL_KEY,
-  createEthereumChain,
-  deployL1Contracts,
-  deployMulticall3,
-  getL1ContractsConfigEnvVars,
-  waitForPublicClient,
-} from '@aztec/ethereum';
-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 { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
-import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { 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, 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 { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
-import { getSponsoredFPCAddress } 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;
-    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(),
-      protocolContractTreeRoot,
-      genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-      salt: opts.salt,
-      feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
-      aztecTargetCommitteeSize: 0, // no committee in sandbox
-      slasherFlavor: 'none', // no slashing in sandbox
-      realVerifier: false,
-    },
-  );
-
-  await deployMulticall3(l1Contracts.l1Client, logger);
-
-  aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
-  aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
-
-  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.*/
-  deployAztecContractsSalt: 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.publisherPrivateKeys == undefined ||
-    !aztecNodeConfig.publisherPrivateKeys.length ||
-    aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY
-  ) {
-    const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.publisherPrivateKeys = [new SecretValue(`0x${Buffer.from(privKey!).toString('hex')}` as const)];
-  }
-  if (!aztecNodeConfig.validatorPrivateKeys?.getValue().length) {
-    const privKey = hdAccount.getHdKey().privateKey;
-    aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${Buffer.from(privKey!).toString('hex')}`]);
-  }
-  aztecNodeConfig.coinbase = EthAddress.fromString(
-    privateKeyToAddress(aztecNodeConfig.validatorPrivateKeys.getValue()[0]),
-  );
-
-  const initialAccounts = await (async () => {
-    if (config.testAccounts === true || config.testAccounts === undefined) {
-      if (aztecNodeConfig.p2pEnabled) {
-        userLog(`Not setting up test accounts as we are connecting to a network`);
-      } else {
-        userLog(`Setting up test accounts`);
-        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, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
-
-  let watcher: AnvilTestWatcher | undefined = undefined;
-  const dateProvider = new TestDateProvider();
-  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,
-    });
-
-    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,
-      dateProvider,
-    );
-    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, dateProvider },
-    { prefilledPublicData },
-  );
-  const pxeServiceConfig = { proverEnabled: aztecNodeConfig.realProofs };
-  const pxe = await createAztecPXE(node, pxeServiceConfig);
-
-  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(pxe, 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; dateProvider?: DateProvider } = {},
-  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 },
-  };
-  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;
-}

package/src/sandbox/sponsored_fpc.ts

@@ -1,27 +0,0 @@
-import {
-  type ContractInstanceWithAddress,
-  Fr,
-  type PXE,
-  getContractInstanceFromInstantiationParams,
-} from '@aztec/aztec.js';
-import { SPONSORED_FPC_SALT } from '@aztec/constants';
-import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
-
-async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
-  return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
-    salt: new Fr(SPONSORED_FPC_SALT),
-  });
-}
-
-export async function getSponsoredFPCAddress() {
-  return (await getSponsoredFPCInstance()).address;
-}
-
-export async function getDeployedSponsoredFPCAddress(pxe: PXE) {
-  const fpc = await getSponsoredFPCAddress();
-  const contracts = await pxe.getContracts();
-  if (!contracts.find(c => c.equals(fpc))) {
-    throw new Error('SponsoredFPC not deployed.');
-  }
-  return fpc;
-}

package/src/testing/aztec_cheat_codes.ts

@@ -1,77 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import type { Note } from '@aztec/stdlib/note';
-
-/**
- * A class that provides utility functions for interacting with the aztec chain.
- */
-export class AztecCheatCodes {
-  constructor(
-    /**
-     * The PXE Service to use for interacting with the chain
-     */
-    public pxe: PXE,
-    /**
-     * The logger to use for the aztec cheatcodes
-     */
-    public logger = createLogger('aztecjs:cheat_codes'),
-  ) {}
-
-  /**
-   * Computes the slot value for a given map and key.
-   * @param mapSlot - The slot of the map (specified in Aztec.nr contract)
-   * @param key - The key to lookup in the map
-   * @returns The storage slot of the value in the map
-   */
-  public computeSlotInMap(mapSlot: Fr | bigint, key: Fr | bigint | AztecAddress): Promise<Fr> {
-    const keyFr = typeof key === 'bigint' ? new Fr(key) : key.toField();
-    return deriveStorageSlotInMap(mapSlot, keyFr);
-  }
-
-  /**
-   * Get the current blocknumber
-   * @returns The current block number
-   */
-  public async blockNumber(): Promise<number> {
-    return await this.pxe.getBlockNumber();
-  }
-
-  /**
-   * Get the current timestamp
-   * @returns The current timestamp
-   */
-  public async timestamp(): Promise<number> {
-    const res = await this.pxe.getBlock(await this.blockNumber());
-    return Number(res?.header.globalVariables.timestamp ?? 0);
-  }
-
-  /**
-   * Loads the value stored at the given slot in the public storage of the given contract.
-   * @param who - The address of the contract
-   * @param slot - The storage slot to lookup
-   * @returns The value stored at the given slot
-   */
-  public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
-    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
-    return storageValue;
-  }
-
-  /**
-   * Loads the value stored at the given slot in the private storage of the given contract.
-   * @param contract - The address of the contract
-   * @param recipient - The address whose public key was used to encrypt the note
-   * @param slot - The storage slot to lookup
-   * @returns The notes stored at the given slot
-   */
-  public async loadPrivate(recipient: AztecAddress, contract: AztecAddress, slot: Fr | bigint): Promise<Note[]> {
-    const extendedNotes = await this.pxe.getNotes({
-      recipient,
-      contractAddress: contract,
-      storageSlot: new Fr(slot),
-    });
-    return extendedNotes.map(extendedNote => extendedNote.note);
-  }
-}