@aztec/cli 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/cmds/aztec_node/get_l1_to_l2_message_witness.ts

@@ -0,0 +1,27 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { LogFn } from '@aztec/foundation/log';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+
+export async function getL1ToL2MessageWitness(
+  nodeUrl: string,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+  log: LogFn,
+) {
+  const node = createAztecNodeClient(nodeUrl);
+  const messageWitness = await getNonNullifiedL1ToL2MessageWitness(node, contractAddress, messageHash, secret);
+
+  log(
+    messageWitness === undefined
+      ? `
+    L1 to L2 Message not found.
+    `
+      : `
+    L1 to L2 message index: ${messageWitness[0]}
+    L1 to L2 message sibling path: ${messageWitness[1]}
+    `,
+  );
+}

package/src/cmds/{pxe → aztec_node}/get_logs.ts

@@ -1,6 +1,8 @@
-import type { AztecAddress, LogFilter, LogId, TxHash } from '@aztec/aztec.js';
-import { createCompatibleClient } from '@aztec/aztec.js';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { LogFilter, LogId } from '@aztec/aztec.js/log';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { TxHash } from '@aztec/aztec.js/tx';
+import type { LogFn } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 
 export async function getLogs(
@@ -9,12 +11,11 @@ export async function getLogs(
   toBlock: number,
   afterLog: LogId,
   contractAddress: AztecAddress,
-  rpcUrl: string,
+  nodeUrl: string,
   follow: boolean,
-  debugLogger: Logger,
   log: LogFn,
 ) {
-  const pxe = await createCompatibleClient(rpcUrl, debugLogger);
+  const node = createAztecNodeClient(nodeUrl);
 
   if (follow) {
     if (txHash) {
@@ -28,7 +29,7 @@ export async function getLogs(
   const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress };
 
   const fetchLogs = async () => {
-    const response = await pxe.getPublicLogs(filter);
+    const response = await node.getPublicLogs(filter);
     const logs = response.logs;
 
     if (!logs.length) {

package/src/cmds/{pxe → aztec_node}/get_node_info.ts

@@ -1,20 +1,9 @@
-import { type AztecNode, type PXE, createAztecNodeClient, createCompatibleClient } from '@aztec/aztec.js';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function getNodeInfo(nodeUrl: string, json: boolean, log: LogFn, logJson: (output: any) => void) {
+  const client = createAztecNodeClient(nodeUrl);
 
-export async function getNodeInfo(
-  rpcUrl: string,
-  pxeRequest: boolean,
-  debugLogger: Logger,
-  json: boolean,
-  log: LogFn,
-  logJson: (output: any) => void,
-) {
-  let client: AztecNode | PXE;
-  if (pxeRequest) {
-    client = await createCompatibleClient(rpcUrl, debugLogger);
-  } else {
-    client = createAztecNodeClient(rpcUrl);
-  }
   const info = await client.getNodeInfo();
   if (json) {
     logJson({

package/src/cmds/aztec_node/index.ts

@@ -0,0 +1,87 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import {
+  logJson,
+  nodeOption,
+  parseAztecAddress,
+  parseField,
+  parseOptionalAztecAddress,
+  parseOptionalInteger,
+  parseOptionalLogId,
+  parseOptionalTxHash,
+} from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('get-block')
+    .description('Gets info for a given block or latest.')
+    .argument('[blockNumber]', 'Block height', parseOptionalInteger)
+    .addOption(nodeOption)
+    .action(async (blockNumber, options) => {
+      const { getBlock } = await import('./get_block.js');
+      await getBlock(options.nodeUrl, blockNumber, log);
+    });
+
+  program
+    .command('get-current-base-fee')
+    .description('Gets the current base fee.')
+    .addOption(nodeOption)
+    .action(async options => {
+      const { getCurrentBaseFee } = await import('./get_current_base_fee.js');
+      await getCurrentBaseFee(options.rpcUrl, debugLogger, log);
+    });
+
+  program
+    .command('get-l1-to-l2-message-witness')
+    .description('Gets a L1 to L2 message witness.')
+    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress)
+    .requiredOption('--message-hash <messageHash>', 'The L1 to L2 message hash.', parseField)
+    .requiredOption('--secret <secret>', 'The secret used to claim the L1 to L2 message', parseField)
+    .addOption(nodeOption)
+    .action(async ({ contractAddress, messageHash, secret, nodeUrl }) => {
+      const { getL1ToL2MessageWitness } = await import('./get_l1_to_l2_message_witness.js');
+      await getL1ToL2MessageWitness(nodeUrl, contractAddress, messageHash, secret, log);
+    });
+
+  program
+    .command('get-logs')
+    .description('Gets all the public logs from an intersection of all the filter params.')
+    .option('-tx, --tx-hash <txHash>', 'A transaction hash to get the receipt for.', parseOptionalTxHash)
+    .option(
+      '-fb, --from-block <blockNum>',
+      'Initial block number for getting logs (defaults to 1).',
+      parseOptionalInteger,
+    )
+    .option('-tb, --to-block <blockNum>', 'Up to which block to fetch logs (defaults to latest).', parseOptionalInteger)
+    .option('-al --after-log <logId>', 'ID of a log after which to fetch the logs.', parseOptionalLogId)
+    .option('-ca, --contract-address <address>', 'Contract address to filter logs by.', parseOptionalAztecAddress)
+    .addOption(nodeOption)
+    .option('--follow', 'If set, will keep polling for new logs until interrupted.')
+    .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, aztecNodeRpcUrl: nodeUrl, follow }) => {
+      const { getLogs } = await import('./get_logs.js');
+      await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, nodeUrl, follow, log);
+    });
+
+  program
+    .command('block-number')
+    .description('Gets the current Aztec L2 block number.')
+    .addOption(nodeOption)
+    .action(async (options: any) => {
+      const { blockNumber } = await import('./block_number.js');
+      await blockNumber(options.nodeUrl, log);
+    });
+
+  program
+    .command('get-node-info')
+    .description('Gets the information of an Aztec node from a PXE or directly from an Aztec node.')
+    .option('--json', 'Emit output as json')
+    .addOption(nodeOption)
+    .action(async options => {
+      const { getNodeInfo } = await import('./get_node_info.js');
+      await getNodeInfo(options.nodeUrl, options.json, log, logJson(log));
+    });
+
+  return program;
+}

package/src/cmds/infrastructure/index.ts

@@ -1,28 +1,19 @@
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 
 import type { Command } from 'commander';
 
-import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+import { ETHEREUM_HOSTS, l1ChainIdOption, nodeOption, parseOptionalInteger } from '../../utils/commands.js';
 
-export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+export function injectCommands(program: Command, log: LogFn) {
   program
     .command('setup-protocol-contracts')
     .description('Bootstrap the blockchain by initializing all the protocol contracts')
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .option('--testAccounts', 'Deploy funded test accounts.')
-    .option('--sponsoredFPC', 'Deploy a sponsored FPC.')
     .option('--json', 'Output the contract addresses in JSON format')
-    .option('--skipProofWait', "Don't wait for proofs to land.")
     .action(async options => {
       const { setupL2Contracts } = await import('./setup_l2_contract.js');
-      await setupL2Contracts(
-        options.rpcUrl,
-        options.testAccounts,
-        options.sponsoredFPC,
-        options.json,
-        options.skipProofWait,
-        log,
-      );
+      await setupL2Contracts(options.nodeUrl, options.testAccounts, options.json, log);
     });
 
   program
@@ -42,7 +33,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       'test test test test test test test test test test test junk',
     )
     .option('--block-number <number>', 'Block number to query next sequencer for', parseOptionalInteger)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .addOption(l1ChainIdOption)
     .action(async (command, who, options) => {
       const { sequencers } = await import('./sequencers.js');
@@ -50,12 +41,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         command: command,
         who,
         mnemonic: options.mnemonic,
-        rpcUrl: options.rpcUrl,
+        nodeUrl: options.nodeUrl,
         l1RpcUrls: options.l1RpcUrls,
         chainId: options.l1ChainId,
         blockNumber: options.blockNumber,
         log,
-        debugLogger,
       });
     });
 

package/src/cmds/infrastructure/sequencers.ts

@@ -1,6 +1,7 @@
-import { Fr, createCompatibleClient } from '@aztec/aztec.js';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { GSEContract, RollupContract, createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 
 import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
@@ -11,15 +12,14 @@ export async function sequencers(opts: {
   who?: string;
   mnemonic?: string;
   bn254SecretKey?: bigint;
-  rpcUrl: string;
+  nodeUrl: string;
   l1RpcUrls: string[];
   chainId: number;
   blockNumber?: number;
   log: LogFn;
-  debugLogger: Logger;
 }) {
-  const { command, who: maybeWho, mnemonic, bn254SecretKey, rpcUrl, l1RpcUrls, chainId, log, debugLogger } = opts;
-  const client = await createCompatibleClient(rpcUrl, debugLogger);
+  const { command, who: maybeWho, mnemonic, bn254SecretKey, nodeUrl, l1RpcUrls, chainId, log } = opts;
+  const client = createAztecNodeClient(nodeUrl);
   const { l1ContractAddresses } = await client.getNodeInfo();
 
   const chain = createEthereumChain(l1RpcUrls, chainId);

package/src/cmds/infrastructure/setup_l2_contract.ts

@@ -1,50 +1,33 @@
-import { type InitialAccountData, deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
-import { type AztecAddress, type WaitForProvenOpts, type WaitOpts, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { AccountManager } from '@aztec/aztec.js/wallet';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { LogFn } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 
-import { setupSponsoredFPC } from '../../utils/setup_contracts.js';
-
-export async function setupL2Contracts(
-  rpcUrl: string,
-  testAccounts: boolean,
-  sponsoredFPC: boolean,
-  json: boolean,
-  skipProofWait: boolean,
-  log: LogFn,
-) {
+export async function setupL2Contracts(nodeUrl: string, testAccounts: boolean, json: boolean, log: LogFn) {
   const waitOpts: WaitOpts = {
     timeout: 180,
     interval: 1,
   };
-  const waitForProvenOptions: WaitForProvenOpts | undefined = !skipProofWait
-    ? {
-        provenTimeout: 600,
-      }
-    : undefined;
   log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
-  if (waitForProvenOptions) {
-    log('setupL2Contracts: Wait for proven options' + jsonStringify(waitForProvenOptions));
-  }
   log('setupL2Contracts: Creating PXE client...');
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([1, 1, 1, 1, 1], false));
+  const node = createAztecNodeClient(nodeUrl);
+  const wallet = await TestWallet.create(node);
 
-  let deployedAccounts: InitialAccountData[] = [];
+  let deployedAccountManagers: AccountManager[] = [];
   if (testAccounts) {
     log('setupL2Contracts: Deploying test accounts...');
-    deployedAccounts = await getInitialTestAccounts();
-    await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
-  }
-
-  if (sponsoredFPC) {
-    log('setupL2Contracts: Setting up sponsored FPC...');
-    await setupSponsoredFPC(pxe, log, waitOpts, waitForProvenOptions);
+    const initialAccountsData = await getInitialTestAccountsData();
+    deployedAccountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccountsData, waitOpts);
   }
 
   if (json) {
     const toPrint: Record<string, AztecAddress> = { ...ProtocolContractAddress };
-    deployedAccounts.forEach((a, i) => {
+    deployedAccountManagers.forEach((a, i) => {
       toPrint[`testAccount${i}`] = a.address;
     });
     log(JSON.stringify(toPrint, null, 2));

package/src/cmds/l1/advance_epoch.ts

@@ -1,12 +1,13 @@
-import { createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { RollupCheatCodes } from '@aztec/ethereum/test';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
-export async function advanceEpoch(l1RpcUrls: string[], rpcUrl: string, log: LogFn) {
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
-  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+export async function advanceEpoch(l1RpcUrls: string[], nodeUrl: string, log: LogFn) {
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
 
-  const cheat = RollupCheatCodes.create(l1RpcUrls, { rollupAddress });
+  const cheat = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
   await cheat.advanceToNextEpoch();
   log(`Warped time to advance to next epoch`);

package/src/cmds/l1/assume_proven_through.ts

@@ -1,18 +1,19 @@
-import { createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { RollupCheatCodes } from '@aztec/ethereum/test';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
 export async function assumeProvenThrough(
   blockNumberOrLatest: number | undefined,
   l1RpcUrls: string[],
-  rpcUrl: string,
+  nodeUrl: string,
   log: LogFn,
 ) {
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
-  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
-  const blockNumber = blockNumberOrLatest ?? (await pxe.getBlockNumber());
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+  const blockNumber = blockNumberOrLatest ?? (await aztecNode.getBlockNumber());
 
-  const rollupCheatCodes = RollupCheatCodes.create(l1RpcUrls, { rollupAddress });
+  const rollupCheatCodes = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
   await rollupCheatCodes.markAsProven(blockNumber);
   log(`Assumed proven through block ${blockNumber}`);

package/src/cmds/l1/bridge_erc20.ts

@@ -1,4 +1,6 @@
-import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import type { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js/ethereum';
+import type { Fr } from '@aztec/aztec.js/fields';
 import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -1,5 +1,6 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
-import { type EthAddress, Fr } from '@aztec/aztec.js';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { EthAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
 import { SecretValue } from '@aztec/foundation/config';
 import type { LogFn, Logger } from '@aztec/foundation/log';
@@ -22,12 +23,13 @@ export async function deployL1Contracts(
   createVerificationJson: string | false,
   initialValidators: EthAddress[],
   realVerifier: boolean,
+  existingToken: EthAddress | undefined,
   log: LogFn,
   debugLogger: Logger,
 ) {
   const config = getL1ContractsConfigEnvVars();
 
-  const initialAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
   const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
   const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
   const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
@@ -50,6 +52,7 @@ export async function deployL1Contracts(
     fundingNeeded,
     acceleratedTestDeployments,
     config,
+    existingToken,
     realVerifier,
     createVerificationJson,
     debugLogger,

package/src/cmds/l1/deploy_new_rollup.ts

@@ -1,4 +1,4 @@
-import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { type Operator, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn, Logger } from '@aztec/foundation/log';
@@ -20,12 +20,13 @@ export async function deployNewRollup(
   json: boolean,
   initialValidators: Operator[],
   realVerifier: boolean,
+  createVerificationJson: string | false,
   log: LogFn,
   debugLogger: Logger,
 ) {
   const config = getL1ContractsConfigEnvVars();
 
-  const initialAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
   const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
   const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
   const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
@@ -43,6 +44,7 @@ export async function deployNewRollup(
     fundingNeeded,
     config,
     realVerifier,
+    createVerificationJson,
     debugLogger,
   );
 

package/src/cmds/l1/get_l1_addresses.ts

@@ -1,4 +1,4 @@
-import { EthAddress } from '@aztec/aztec.js';
+import { EthAddress } from '@aztec/aztec.js/addresses';
 import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
 import type { LogFn } from '@aztec/foundation/log';
 

package/src/cmds/l1/index.ts

@@ -1,18 +1,18 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn, Logger } from '@aztec/foundation/log';
-import { withoutHexPrefix } from '@aztec/foundation/string';
 
 import { type Command, Option } from 'commander';
 
+import { getL1RollupAddressFromEnv } from '../../config/get_l1_config.js';
 import {
   ETHEREUM_HOSTS,
   MNEMONIC,
   PRIVATE_KEY,
   l1ChainIdOption,
+  nodeOption,
   parseAztecAddress,
   parseBigint,
   parseEthereumAddress,
-  pxeOption,
 } from '../../utils/commands.js';
 
 export { addL1Validator } from './update_l1_validators.js';
@@ -26,6 +26,8 @@ const l1RpcUrlsOption = new Option(
   .makeOptionMandatory(true)
   .argParser((arg: string) => arg.split(',').map(url => url.trim()));
 
+const networkOption = new Option('--network <string>', 'Network to execute against').env('NETWORK');
+
 export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
   program
     .command('deploy-l1-contracts')
@@ -46,6 +48,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract')
     .option('--accelerated-test-deployments', 'Fire and forget deployment transactions, use in testing only', false)
     .option('--real-verifier', 'Deploy the real verifier', false)
+    .option('--existing-token <address>', 'Use an existing ERC20 for both fee and staking', parseEthereumAddress)
     .option('--create-verification-json [path]', 'Create JSON file for etherscan contract verification', false)
     .action(async options => {
       const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
@@ -66,6 +69,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.createVerificationJson,
         initialValidators,
         options.realVerifier,
+        options.existingToken,
         log,
         debugLogger,
       );
@@ -90,6 +94,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts')
     .option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract')
     .option('--real-verifier', 'Deploy the real verifier', false)
+    .option('--create-verification-json [path]', 'Create JSON file for etherscan contract verification', false)
     .action(async options => {
       const { deployNewRollup } = await import('./deploy_new_rollup.js');
 
@@ -108,6 +113,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.json,
         initialValidators,
         options.realVerifier,
+        options.createVerificationJson,
         log,
         debugLogger,
       );
@@ -285,8 +291,9 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
 
   program
     .command('add-l1-validator')
-    .description('Adds a validator to the L1 rollup contract.')
+    .description('Adds a validator to the L1 rollup contract via a direct deposit.')
     .addOption(l1RpcUrlsOption)
+    .addOption(networkOption)
     .option('-pk, --private-key <string>', 'The private key to use sending the transaction', PRIVATE_KEY)
     .option(
       '-m, --mnemonic <string>',
@@ -295,32 +302,29 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .addOption(l1ChainIdOption)
     .option('--attester <address>', 'ethereum address of the attester', parseEthereumAddress)
+    .option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress)
     .option(
       '--bls-secret-key <string>',
       'The BN254 scalar field element used as a secret key for BLS signatures. Will be associated with the attester address.',
       parseBigint,
     )
-    .option('--staking-asset-handler <address>', 'ethereum address of the staking asset handler', parseEthereumAddress)
-    .option('--proof <buffer>', 'The proof to use for the attestation', arg =>
-      Buffer.from(withoutHexPrefix(arg), 'hex'),
-    )
-    .option(
-      '--merkle-proof <string>',
-      'The merkle proof to use for the attestation (comma separated list of 32 byte buffers)',
-      arg => arg.split(','),
-    )
+    .option('--move-with-latest-rollup', 'Whether to move with the latest rollup', true)
+    .option('--rollup <string>', 'Rollup contract address', parseEthereumAddress)
     .action(async options => {
-      const { addL1Validator } = await import('./update_l1_validators.js');
-      await addL1Validator({
+      const { addL1ValidatorViaRollup } = await import('./update_l1_validators.js');
+
+      const rollupAddress = options.rollup ?? (await getL1RollupAddressFromEnv(options.l1RpcUrls, options.l1ChainId));
+
+      await addL1ValidatorViaRollup({
         rpcUrls: options.l1RpcUrls,
         chainId: options.l1ChainId,
         privateKey: options.privateKey,
         mnemonic: options.mnemonic,
         attesterAddress: options.attester,
-        stakingAssetHandlerAddress: options.stakingAssetHandler,
-        merkleProof: options.merkleProof,
-        proofParams: options.proof,
         blsSecretKey: options.blsSecretKey,
+        withdrawerAddress: options.withdrawer,
+        rollupAddress,
+        moveWithLatestRollup: options.moveWithLatestRollup,
         log,
         debugLogger,
       });
@@ -507,52 +511,20 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint)
     .addOption(l1RpcUrlsOption)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .action(async (blockNumber, options) => {
       const { assumeProvenThrough } = await import('./assume_proven_through.js');
-      await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
+      await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.nodeUrl, log);
     });
 
   program
     .command('advance-epoch')
     .description('Use L1 cheat codes to warp time until the next epoch.')
     .addOption(l1RpcUrlsOption)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .action(async options => {
       const { advanceEpoch } = await import('./advance_epoch.js');
-      await advanceEpoch(options.l1RpcUrls, options.rpcUrl, log);
-    });
-
-  program
-    .command('prover-stats', { hidden: true })
-    .addOption(l1RpcUrlsOption)
-    .addOption(l1ChainIdOption)
-    .option('--start-block <number>', 'The L1 block number to start from', parseBigint, 1n)
-    .option('--end-block <number>', 'The last L1 block number to query', parseBigint)
-    .option('--batch-size <number>', 'The number of blocks to query in each batch', parseBigint, 100n)
-    .option('--proving-timeout <number>', 'Cutoff for proving time to consider a block', parseBigint)
-    .option('--l1-rollup-address <string>', 'Address of the rollup contract (required if node URL is not set)')
-    .option(
-      '--node-url <string>',
-      'JSON RPC URL of an Aztec node to retrieve the rollup contract address (required if L1 rollup address is not set)',
-    )
-    .option('--raw-logs', 'Output raw logs instead of aggregated stats')
-    .action(async options => {
-      const { proverStats } = await import('./prover_stats.js');
-      const { l1RpcUrls, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } =
-        options;
-      await proverStats({
-        l1RpcUrls,
-        chainId,
-        l1RollupAddress,
-        startBlock,
-        endBlock,
-        batchSize,
-        nodeUrl,
-        provingTimeout,
-        rawLogs,
-        log,
-      });
+      await advanceEpoch(options.l1RpcUrls, options.nodeUrl, log);
     });
 
   return program;