@aztec/aztec 0.0.1-commit.a072138 → 0.0.1-commit.a5db02d

package/src/cli/cmds/start_prover_node.ts

@@ -1,124 +0,0 @@
-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';
-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 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}`,
-    );
-  }
-
-  const telemetry = await initTelemetryClient(extractRelevantOptions(options, telemetryClientConfigMappings, 'tel'));
-
-  let broker: ProvingJobBroker;
-  if (proverConfig.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(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/release_version.ts

@@ -1,21 +0,0 @@
-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/testing/anvil_test_watcher.ts

@@ -1,166 +0,0 @@
-import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import type { ViemClient } from '@aztec/ethereum/types';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { RunningPromise } from '@aztec/foundation/running-promise';
-import type { TestDateProvider } from '@aztec/foundation/timer';
-import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
-
-import { type GetContractReturnType, getAddress, getContract } from 'viem';
-
-/**
- * Represents a watcher for a rollup contract.
- *
- * It started on a network like anvil where time traveling is allowed, and auto-mine is turned on
- * it will periodically check if the current slot have already been filled, e.g., there was an L2
- * block within the slot. And if so, it will time travel into the next slot.
- */
-export class AnvilTestWatcher {
-  private isLocalNetwork: boolean = false;
-
-  private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
-  private rollupCheatCodes: RollupCheatCodes;
-  private l2SlotDuration!: number;
-
-  private filledRunningPromise?: RunningPromise;
-  private syncDateProviderPromise?: RunningPromise;
-  private markingAsProvenRunningPromise?: RunningPromise;
-
-  private logger: Logger = createLogger(`aztecjs:utils:watcher`);
-
-  private isMarkingAsProven = true;
-
-  constructor(
-    private cheatcodes: EthCheatCodes,
-    rollupAddress: EthAddress,
-    l1Client: ViemClient,
-    private dateProvider?: TestDateProvider,
-  ) {
-    this.rollup = getContract({
-      address: getAddress(rollupAddress.toString()),
-      abi: RollupAbi,
-      client: l1Client,
-    });
-
-    this.rollupCheatCodes = new RollupCheatCodes(this.cheatcodes, {
-      rollupAddress,
-    });
-
-    this.logger.debug(`Watcher created for rollup at ${rollupAddress}`);
-  }
-
-  setIsMarkingAsProven(isMarkingAsProven: boolean) {
-    this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
-    this.isMarkingAsProven = isMarkingAsProven;
-  }
-
-  setisLocalNetwork(isLocalNetwork: boolean) {
-    this.isLocalNetwork = isLocalNetwork;
-  }
-
-  async start() {
-    if (this.filledRunningPromise) {
-      throw new Error('Watcher already watching for filled slot');
-    }
-
-    const config = await this.rollupCheatCodes.getConfig();
-    this.l2SlotDuration = config.slotDuration;
-
-    // If auto mining is not supported (e.g., we are on a real network), then we
-    // will simple do nothing. But if on an anvil or the like, this make sure that
-    // the local network and tests don't break because time is frozen and we never get to
-    // the next slot.
-    const isAutoMining = await this.cheatcodes.isAutoMining();
-
-    if (isAutoMining) {
-      this.filledRunningPromise = new RunningPromise(() => this.warpTimeIfNeeded(), this.logger, 200);
-      this.filledRunningPromise.start();
-      this.syncDateProviderPromise = new RunningPromise(() => this.syncDateProviderToL1IfBehind(), this.logger, 200);
-      this.syncDateProviderPromise.start();
-      this.markingAsProvenRunningPromise = new RunningPromise(() => this.markAsProven(), this.logger, 200);
-      this.markingAsProvenRunningPromise.start();
-      this.logger.info(`Watcher started for rollup at ${this.rollup.address}`);
-    } else {
-      this.logger.info(`Watcher not started because not auto mining`);
-    }
-  }
-
-  async stop() {
-    await this.filledRunningPromise?.stop();
-    await this.syncDateProviderPromise?.stop();
-    await this.markingAsProvenRunningPromise?.stop();
-  }
-
-  async trigger() {
-    await this.filledRunningPromise?.trigger();
-    await this.syncDateProviderPromise?.trigger();
-    await this.markingAsProvenRunningPromise?.trigger();
-  }
-
-  async markAsProven() {
-    if (!this.isMarkingAsProven) {
-      return;
-    }
-    await this.rollupCheatCodes.markAsProven();
-  }
-
-  async syncDateProviderToL1IfBehind() {
-    // this doesn't apply to the local network, because we don't have a date provider in the local network
-    if (!this.dateProvider) {
-      return;
-    }
-
-    const l1Time = (await this.cheatcodes.timestamp()) * 1000;
-    const wallTime = this.dateProvider.now();
-    if (l1Time > wallTime) {
-      this.logger.warn(`L1 is ahead of wall time. Syncing wall time to L1 time`);
-      this.dateProvider.setTime(l1Time);
-    } else if (l1Time + Number(this.l2SlotDuration) * 1000 < wallTime) {
-      this.logger.warn(`L1 is more than 1 L2 slot behind wall time. Warping to wall time`);
-      await this.cheatcodes.warp(Math.ceil(wallTime / 1000));
-    }
-  }
-
-  async warpTimeIfNeeded() {
-    try {
-      const currentSlot = SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
-      const pendingCheckpointNumber = await this.rollup.read.getPendingCheckpointNumber();
-      const checkpointLog = await this.rollup.read.getCheckpoint([pendingCheckpointNumber]);
-      const nextSlot = SlotNumber(currentSlot + 1);
-      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]));
-
-      if (BigInt(currentSlot) === checkpointLog.slotNumber) {
-        // We should jump to the next slot
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, {
-            resetBlockInterval: true,
-          });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
-        }
-
-        this.logger.info(`Slot ${currentSlot} was filled, jumped to next slot`);
-        return;
-      }
-
-      // If we are not in local network, we don't need to warp time
-      if (!this.isLocalNetwork) {
-        return;
-      }
-
-      const currentTimestamp = this.dateProvider?.now() ?? Date.now();
-      if (currentTimestamp > nextSlotTimestamp * 1000) {
-        try {
-          await this.cheatcodes.warp(nextSlotTimestamp, { resetBlockInterval: true });
-        } catch (e) {
-          this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
-        }
-
-        this.logger.info(`Slot ${currentSlot} was missed, jumped to next slot`);
-      }
-    } catch {
-      this.logger.error('mineIfSlotFilled failed');
-    }
-  }
-}