@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/src/cmds/l1/prover_stats.ts

@@ -0,0 +1,202 @@
+import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
+import { type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import { compactArray, mapValues, unique } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type LogFn, type Logger, createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+
+import chunk from 'lodash.chunk';
+import groupBy from 'lodash.groupby';
+import { createPublicClient, fallback, getAbiItem, getAddress, http } from 'viem';
+
+export async function proverStats(opts: {
+  l1RpcUrls: string[];
+  chainId: number;
+  l1RollupAddress: string | undefined;
+  nodeUrl: string | undefined;
+  log: LogFn;
+  startBlock: bigint;
+  endBlock: bigint | undefined;
+  batchSize: bigint;
+  provingTimeout: bigint | undefined;
+  rawLogs: boolean;
+}) {
+  const debugLog = createLogger('cli:prover_stats');
+  const {
+    startBlock,
+    chainId,
+    l1RpcUrls,
+    l1RollupAddress,
+    batchSize,
+    nodeUrl,
+    provingTimeout,
+    endBlock,
+    rawLogs,
+    log,
+  } = opts;
+  if (!l1RollupAddress && !nodeUrl) {
+    throw new Error('Either L1 rollup address or node URL must be set');
+  }
+
+  const rollup = l1RollupAddress
+    ? EthAddress.fromString(l1RollupAddress)
+    : await createAztecNodeClient(nodeUrl!)
+        .getL1ContractAddresses()
+        .then(a => a.rollupAddress);
+
+  const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
+  const publicClient = createPublicClient({ chain, transport: fallback(l1RpcUrls.map(url => http(url))) });
+  const lastBlockNum = endBlock ?? (await publicClient.getBlockNumber());
+  debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
+
+  // Get all events for L2 proof submissions
+  const events = await getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+
+  // If we only care for raw logs, output them
+  if (rawLogs && !provingTimeout) {
+    log(`l1_block_number, l2_block_number, prover_id, tx_hash`);
+    for (const event of events) {
+      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
+      log(`${l1BlockNumber}, ${l2BlockNumber}, ${proverId}, ${txHash}`);
+    }
+    return;
+  }
+
+  // If we don't have a proving timeout, we can just count the number of unique blocks per prover
+  if (!provingTimeout) {
+    const stats = groupBy(events, 'proverId');
+    log(`prover_id, total_blocks_proven`);
+    for (const proverId in stats) {
+      const uniqueBlocks = new Set(stats[proverId].map(e => e.l2BlockNumber));
+      log(`${proverId}, ${uniqueBlocks.size}`);
+    }
+    return;
+  }
+
+  // But if we do, fetch the events for each block submitted, so we can look up their timestamp
+  const blockEvents = await getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+  debugLog.verbose(
+    `First L2 block within range is ${blockEvents[0]?.args.blockNumber} at L1 block ${blockEvents[0]?.blockNumber}`,
+  );
+
+  // Get the timestamps for every block on every log, both for proof and block submissions
+  const l1BlockNumbers = unique([...events.map(e => e.l1BlockNumber), ...blockEvents.map(e => e.blockNumber)]);
+  const l1BlockTimestamps: Record<string, bigint> = {};
+  for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))) {
+    const blocks = await Promise.all(
+      l1Batch.map(blockNumber => publicClient.getBlock({ includeTransactions: false, blockNumber })),
+    );
+    debugLog.verbose(`Queried ${blocks.length} L1 blocks between ${l1Batch[0]} and ${l1Batch[l1Batch.length - 1]}`);
+    for (const block of blocks) {
+      l1BlockTimestamps[block.number.toString()] = block.timestamp;
+    }
+  }
+
+  // Map from l2 block number to the l1 block in which it was submitted
+  const l2BlockSubmissions: Record<string, bigint> = {};
+  for (const blockEvent of blockEvents) {
+    l2BlockSubmissions[blockEvent.args.blockNumber!.toString()] = blockEvent.blockNumber;
+  }
+
+  // If we want raw logs, output them
+  if (rawLogs) {
+    log(`l1_block_number, l2_block_number, l2_block_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+    for (const event of events) {
+      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
+      const uploadedBlockNumber = l2BlockSubmissions[l2BlockNumber.toString()];
+      if (!uploadedBlockNumber) {
+        continue;
+      }
+      const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+      const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
+      log(`${l1BlockNumber}, ${l2BlockNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+    }
+    return;
+  }
+
+  // Or calculate stats per prover
+  const stats = mapValues(groupBy(events, 'proverId'), (blocks, proverId) =>
+    compactArray(
+      blocks.map(e => {
+        const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
+        const uploadedBlockNumber = l2BlockSubmissions[e.l2BlockNumber.toString()];
+        if (!uploadedBlockNumber) {
+          debugLog.verbose(
+            `Skipping ${proverId}'s proof for L2 block ${e.l2BlockNumber} as it was before the start block`,
+          );
+          return undefined;
+        }
+        const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+        const provingTime = provenTimestamp - uploadedTimestamp;
+        debugLog.debug(
+          `prover=${e.proverId} blockNumber=${e.l2BlockNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`,
+        );
+        return { provenTimestamp, uploadedTimestamp, provingTime, ...e };
+      }),
+    ),
+  );
+
+  log(`prover_id, blocks_proven_within_timeout, total_blocks_proven, avg_proving_time`);
+  for (const proverId in stats) {
+    const blocks = stats[proverId];
+    const withinTimeout = blocks.filter(b => b.provingTime <= provingTimeout);
+    const uniqueBlocksWithinTimeout = new Set(withinTimeout.map(e => e.l2BlockNumber));
+    const uniqueBlocks = new Set(blocks.map(e => e.l2BlockNumber));
+    const avgProvingTime =
+      blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b) => acc + b.provingTime, 0n)) / blocks.length);
+
+    log(`${proverId}, ${uniqueBlocksWithinTimeout.size}, ${uniqueBlocks.size}, ${avgProvingTime}`);
+  }
+  return;
+}
+
+async function getL2ProofVerifiedEvents(
+  startBlock: bigint,
+  lastBlockNum: bigint,
+  batchSize: bigint,
+  debugLog: Logger,
+  publicClient: ViemPublicClient,
+  rollup: EthAddress,
+) {
+  let blockNum = startBlock;
+  const events = [];
+  while (blockNum <= lastBlockNum) {
+    const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+    const newEvents = await retrieveL2ProofVerifiedEvents(publicClient, rollup, blockNum, end);
+    events.push(...newEvents);
+    debugLog.verbose(`Got ${newEvents.length} events querying l2 proof verified from block ${blockNum} to ${end}`);
+    blockNum += batchSize;
+  }
+  return events;
+}
+
+async function getL2BlockEvents(
+  startBlock: bigint,
+  lastBlockNum: bigint,
+  batchSize: bigint,
+  debugLog: Logger,
+  publicClient: ViemPublicClient,
+  rollup: EthAddress,
+) {
+  let blockNum = startBlock;
+  const events = [];
+  while (blockNum <= lastBlockNum) {
+    const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+
+    const newEvents = await publicClient.getLogs({
+      address: getAddress(rollup.toString()),
+      event: getAbiItem({
+        abi: RollupAbi,
+        name: 'L2BlockProposed',
+      }),
+      fromBlock: blockNum,
+      toBlock: end,
+    });
+
+    events.push(...newEvents);
+    debugLog.verbose(`Got ${newEvents.length} events querying l2 block submitted from block ${blockNum} to ${end}`);
+    blockNum += batchSize;
+  }
+  return events;
+}

package/src/cmds/l1/update_l1_validators.ts

@@ -0,0 +1,238 @@
+import {
+  EthCheatCodes,
+  createEthereumChain,
+  getExpectedAddress,
+  getL1ContractsConfigEnvVars,
+  isAnvilTestChain,
+} from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+export interface RollupCommandArgs {
+  rpcUrls: string[];
+  chainId: number;
+  privateKey?: string;
+  mnemonic?: string;
+  rollupAddress: EthAddress;
+  withdrawerAddress?: EthAddress;
+}
+
+export interface LoggerArgs {
+  log: LogFn;
+  debugLogger: Logger;
+}
+
+export function generateL1Account() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  account.address;
+  return {
+    privateKey,
+    address: account.address,
+  };
+}
+
+export async function addL1Validator({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  validatorAddress,
+  rollupAddress,
+  withdrawerAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs & { validatorAddress: EthAddress }) {
+  const config = getL1ContractsConfigEnvVars();
+  const dualLog = makeDualLog(log, debugLogger);
+  const publicClient = getPublicClient(rpcUrls, chainId);
+  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: walletClient,
+  });
+
+  const stakingAsset = getContract({
+    address: await rollup.read.getStakingAsset(),
+    abi: TestERC20Abi,
+    client: walletClient,
+  });
+
+  await Promise.all(
+    [
+      await stakingAsset.write.mint([walletClient.account.address, config.minimumStake], {} as any),
+      await stakingAsset.write.approve([rollupAddress.toString(), config.minimumStake], {} as any),
+    ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+  );
+
+  dualLog(`Adding validator ${validatorAddress.toString()} to rollup ${rollupAddress.toString()}`);
+  const txHash = await rollup.write.deposit([
+    validatorAddress.toString(),
+    // TODO(#11451): custom forwarders
+    getExpectedAddress(ForwarderAbi, ForwarderBytecode, [validatorAddress.toString()], validatorAddress.toString())
+      .address,
+    withdrawerAddress?.toString() ?? validatorAddress.toString(),
+    config.minimumStake,
+  ]);
+  dualLog(`Transaction hash: ${txHash}`);
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+  if (isAnvilTestChain(chainId)) {
+    dualLog(`Funding validator on L1`);
+    const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
+    await cheatCodes.setBalance(validatorAddress, 10n ** 20n);
+  } else {
+    const balance = await publicClient.getBalance({ address: validatorAddress.toString() });
+    const balanceInEth = Number(balance) / 10 ** 18;
+    dualLog(`Validator balance: ${balanceInEth.toFixed(6)} ETH`);
+    if (balanceInEth === 0) {
+      dualLog(`WARNING: Validator has no balance. Remember to fund it!`);
+    }
+  }
+}
+
+export async function removeL1Validator({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  validatorAddress,
+  rollupAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs & { validatorAddress: EthAddress }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const publicClient = getPublicClient(rpcUrls, chainId);
+  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: walletClient,
+  });
+
+  dualLog(`Removing validator ${validatorAddress.toString()} from rollup ${rollupAddress.toString()}`);
+  const txHash = await rollup.write.initiateWithdraw([validatorAddress.toString(), validatorAddress.toString()]);
+  dualLog(`Transaction hash: ${txHash}`);
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+}
+
+export async function pruneRollup({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  rollupAddress,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const publicClient = getPublicClient(rpcUrls, chainId);
+  const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: walletClient,
+  });
+
+  dualLog(`Trying prune`);
+  const txHash = await rollup.write.prune();
+  dualLog(`Transaction hash: ${txHash}`);
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+}
+
+export async function fastForwardEpochs({
+  rpcUrls,
+  chainId,
+  rollupAddress,
+  numEpochs,
+  log,
+  debugLogger,
+}: RollupCommandArgs & LoggerArgs & { numEpochs: bigint }) {
+  const dualLog = makeDualLog(log, debugLogger);
+  const publicClient = getPublicClient(rpcUrls, chainId);
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: publicClient,
+  });
+
+  const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
+  const currentSlot = await rollup.read.getCurrentSlot();
+  const l2SlotsInEpoch = await rollup.read.getEpochDuration();
+  const timestamp = await rollup.read.getTimestampForSlot([currentSlot + l2SlotsInEpoch * numEpochs]);
+  dualLog(`Fast forwarding ${numEpochs} epochs to ${timestamp}`);
+  try {
+    await cheatCodes.warp(Number(timestamp));
+    dualLog(`Fast forwarded ${numEpochs} epochs to ${timestamp}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("is lower than or equal to previous block's timestamp")) {
+      dualLog(`Someone else fast forwarded the chain to a point after/equal to the target time`);
+    } else {
+      // Re-throw other errors
+      throw error;
+    }
+  }
+}
+
+export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs) {
+  const config = getL1ContractsConfigEnvVars();
+  const publicClient = getPublicClient(rpcUrls, chainId);
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client: publicClient,
+  });
+
+  const pendingNum = await rollup.read.getPendingBlockNumber();
+  log(`Pending block num: ${pendingNum}`);
+  const provenNum = await rollup.read.getProvenBlockNumber();
+  log(`Proven block num: ${provenNum}`);
+  const validators = await rollup.read.getAttesters();
+  log(`Validators: ${validators.map(v => v.toString()).join(', ')}`);
+  const committee = await rollup.read.getCurrentEpochCommittee();
+  log(`Committee: ${committee.map(v => v.toString()).join(', ')}`);
+  const archive = await rollup.read.archive();
+  log(`Archive: ${archive}`);
+  const epochNum = await rollup.read.getCurrentEpoch();
+  log(`Current epoch: ${epochNum}`);
+  const slot = await rollup.read.getCurrentSlot();
+  log(`Current slot: ${slot}`);
+  const proposerDuringPrevL1Block = await rollup.read.getCurrentProposer();
+  log(`Proposer during previous L1 block: ${proposerDuringPrevL1Block}`);
+  const nextBlockTS = BigInt((await publicClient.getBlock()).timestamp + BigInt(config.ethereumSlotDuration));
+  const proposer = await rollup.read.getProposerAt([nextBlockTS]);
+  log(`Proposer NOW: ${proposer.toString()}`);
+}
+
+function makeDualLog(log: LogFn, debugLogger: Logger) {
+  return (msg: string) => {
+    log(msg);
+    debugLogger.info(msg);
+  };
+}
+
+function getPublicClient(rpcUrls: string[], chainId: number) {
+  const chain = createEthereumChain(rpcUrls, chainId);
+  return createPublicClient({ chain: chain.chainInfo, transport: fallback(rpcUrls.map(url => http(url))) });
+}
+
+function getWalletClient(
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string | undefined,
+) {
+  if (!privateKey && !mnemonic) {
+    throw new Error('Either privateKey or mnemonic must be provided to create a wallet client');
+  }
+
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const account = !privateKey
+    ? mnemonicToAccount(mnemonic!)
+    : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}` as `0x${string}`);
+  return createWalletClient({ account, chain: chain.chainInfo, transport: fallback(rpcUrls.map(url => http(url))) });
+}

package/src/cmds/misc/compute_selector.ts

@@ -0,0 +1,7 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+
+export async function computeSelector(functionSignature: string, log: LogFn) {
+  const selector = await FunctionSelector.fromSignature(functionSignature);
+  log(`${selector}`);
+}

package/src/cmds/misc/example_contracts.ts

@@ -0,0 +1,12 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { getExampleContractNames } from '../../utils/aztec.js';
+
+export async function exampleContracts(log: LogFn) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  return (await getExampleContractNames())
+    .filter(name => name !== 'AvmTest')
+    .sort()
+    .forEach(name => log(name));
+}

package/src/cmds/misc/generate_bootnode_enr.ts

@@ -0,0 +1,12 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { createBootnodeENRandPeerId } from '@aztec/p2p/enr';
+
+export async function generateEncodedBootnodeENR(
+  privateKey: string,
+  udpAnnounceAddress: string,
+  l1ChainId: number,
+  log: LogFn,
+) {
+  const { enr } = await createBootnodeENRandPeerId(privateKey, udpAnnounceAddress, l1ChainId);
+  log(`ENR: ${enr.encodeTxt()}`);
+}

package/src/cmds/misc/generate_p2p_private_key.ts

@@ -0,0 +1,10 @@
+import type { LogFn } from '@aztec/foundation/log';
+
+import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+
+export async function generateP2PPrivateKey(log: LogFn) {
+  const peerId = await createSecp256k1PeerId();
+  const exportedPeerId = Buffer.from(peerId.privateKey!).toString('hex');
+  log(`Private key: ${exportedPeerId}`);
+  log(`Peer Id: ${peerId}`);
+}

package/src/cmds/misc/generate_secret_and_hash.ts

@@ -0,0 +1,15 @@
+import { computeSecretHash } from '@aztec/aztec.js';
+import { Fr } from '@aztec/foundation/fields';
+import type { LogFn } from '@aztec/foundation/log';
+
+export function generateSecretAndHash(log: LogFn) {
+  const secret = Fr.random();
+
+  // We hash this the same way that aztec nr hash does.
+  const secretHash = computeSecretHash(secret);
+
+  log(`
+    Secret: ${secret}
+    Secret hash: ${secretHash}
+  `);
+}

package/src/cmds/misc/generate_secret_key.ts

@@ -0,0 +1,5 @@
+import { Fr } from '@aztec/aztec.js';
+
+export function generateSecretKey() {
+  return { secretKey: Fr.random() };
+}

package/src/cmds/misc/index.ts

@@ -0,0 +1,92 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { printENR } from '@aztec/p2p/enr';
+
+import type { Command } from 'commander';
+
+import { l1ChainIdOption, prettyPrintJSON } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn) {
+  program
+    .command('generate-keys')
+    .summary('Generates encryption and signing private keys.')
+    .description('Generates and encryption and signing private key pair.')
+    .option('--json', 'Output the keys in JSON format')
+    .action(async ({ json }) => {
+      const { generateSecretKey } = await import('./generate_secret_key.js');
+      const { secretKey } = generateSecretKey();
+      if (json) {
+        log(prettyPrintJSON({ secretKey: secretKey.toString() }));
+      } else {
+        log(`Secret Key: ${secretKey}`);
+      }
+    });
+
+  program
+    .command('generate-p2p-private-key')
+    .summary('Generates a LibP2P peer private key.')
+    .description('Generates a private key that can be used for running a node on a LibP2P network.')
+    .action(async () => {
+      const { generateP2PPrivateKey } = await import('./generate_p2p_private_key.js');
+      await generateP2PPrivateKey(log);
+    });
+
+  program
+    .command('generate-bootnode-enr')
+    .summary('Generates the encoded ENR record for a bootnode.')
+    .description('Generates the encoded ENR record for a bootnode.')
+    .argument('<privateKey>', 'The peer id private key of the bootnode')
+    .argument('<udpAnnounceAddress>', 'The bootnode UDP announce address')
+    .addOption(l1ChainIdOption)
+    .action(async (privateKey: string, udpAnnounceAddress: string, options) => {
+      const { generateEncodedBootnodeENR } = await import('./generate_bootnode_enr.js');
+      await generateEncodedBootnodeENR(privateKey, udpAnnounceAddress, options.l1ChainId, log);
+    });
+
+  program
+    .command('decode-enr')
+    .summary('Decodes an ENR record')
+    .description('Decodes and ENR record')
+    .argument('<enr>', 'The encoded ENR string')
+    .action(async (enr: string) => {
+      await printENR(enr, log);
+    });
+
+  program
+    .command('example-contracts')
+    .description('Lists the example contracts available to deploy from @aztec/noir-contracts.js')
+    .action(async () => {
+      const { exampleContracts } = await import('./example_contracts.js');
+      await exampleContracts(log);
+    });
+
+  program
+    .command('compute-selector')
+    .description('Given a function signature, it computes a selector')
+    .argument('<functionSignature>', 'Function signature to compute selector for e.g. foo(Field)')
+    .action(async (functionSignature: string) => {
+      const { computeSelector } = await import('./compute_selector.js');
+      await computeSelector(functionSignature, log);
+    });
+
+  program
+    .command('generate-secret-and-hash')
+    .description('Generates an arbitrary secret (Fr), and its hash (using aztec-nr defaults)')
+    .action(async () => {
+      const { generateSecretAndHash } = await import('./generate_secret_and_hash.js');
+      generateSecretAndHash(log);
+    });
+
+  program
+    .command('update')
+    .description('Updates Nodejs and Noir dependencies')
+    .argument('[projectPath]', 'Path to the project directory', process.cwd())
+    .option('--contract [paths...]', 'Paths to contracts to update dependencies', [])
+    .option('--aztec-version <semver>', 'The version to update Aztec packages to. Defaults to latest', 'latest')
+    .action(async (projectPath: string, options) => {
+      const { updateProject } = await import('./update.js');
+      const { contract, aztecVersion } = options;
+      await updateProject(projectPath, contract, aztecVersion, log);
+    });
+
+  return program;
+}

package/src/cmds/misc/setup_contracts.ts

@@ -0,0 +1,40 @@
+import { DefaultWaitOpts, type EthAddress, FeeJuicePaymentMethod, type Wallet } from '@aztec/aztec.js';
+import { FEE_JUICE_INITIAL_MINT } from '@aztec/constants';
+import type { LogFn } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { Gas } from '@aztec/stdlib/gas';
+
+/**
+ * Deploys the contract to pay for gas on L2.
+ */
+export async function setupCanonicalL2FeeJuice(
+  deployer: Wallet,
+  feeJuicePortalAddress: EthAddress,
+  waitOpts = DefaultWaitOpts,
+  log: LogFn,
+) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+
+  const feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, deployer);
+
+  const portalAddress = await deployer.getPublicStorageAt(
+    feeJuiceContract.address,
+    feeJuiceContract.artifact.storageLayout.portal_address.slot,
+  );
+
+  if (portalAddress.isZero()) {
+    log('setupCanonicalL2FeeJuice: Calling initialize on fee juice contract...');
+    const paymentMethod = new FeeJuicePaymentMethod(ProtocolContractAddress.FeeJuice);
+    await feeJuiceContract.methods
+      .initialize(feeJuicePortalAddress, FEE_JUICE_INITIAL_MINT)
+      .send({ fee: { paymentMethod, gasSettings: { teardownGasLimits: Gas.empty() } } })
+      .wait(waitOpts);
+  } else {
+    log(
+      'setupCanonicalL2FeeJuice: Fee juice contract already initialized. Fee Juice Portal address: ' +
+        portalAddress.toString(),
+    );
+  }
+}

package/src/cmds/misc/update/common.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks changes to dependencies
+ */
+export type DependencyChanges = {
+  /** Which file was changed */
+  file: string;
+  /** changes done to the file */
+  dependencies: Array<{
+    /** Name of the dependency being changed */
+    name: string;
+    /** Previous version of the dependency */
+    from: string;
+    /** New version of the dependency (after the update) */
+    to: string;
+  }>;
+};

package/src/cmds/misc/update/github.ts

@@ -0,0 +1,3 @@
+export const GITHUB_OWNER = 'AztecProtocol';
+export const GITHUB_REPO = 'aztec-packages';
+export const GITHUB_TAG_PREFIX = 'aztec-packages';