@aztec/cli 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/cmds/l1/index.ts

@@ -3,17 +3,20 @@ import type { LogFn, Logger } from '@aztec/foundation/log';
 
 import { type Command, Option } from 'commander';
 
+import { getL1RollupAddressFromEnv } from '../../config/get_l1_config.js';
 import {
   ETHEREUM_HOSTS,
+  MNEMONIC,
   PRIVATE_KEY,
   l1ChainIdOption,
-  makePxeOption,
+  nodeOption,
   parseAztecAddress,
   parseBigint,
   parseEthereumAddress,
-  pxeOption,
 } from '../../utils/commands.js';
 
+export { addL1Validator } from './update_l1_validators.js';
+
 const l1RpcUrlsOption = new Option(
   '--l1-rpc-urls <string>',
   'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)',
@@ -23,9 +26,9 @@ const l1RpcUrlsOption = new Option(
   .makeOptionMandatory(true)
   .argParser((arg: string) => arg.split(',').map(url => url.trim()));
 
-export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
-  const { BB_BINARY_PATH, BB_WORKING_DIRECTORY } = process.env;
+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')
     .description('Deploys all necessary Ethereum contracts for Aztec.')
@@ -42,7 +45,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .option('--salt <number>', 'The optional salt to use in deployment', arg => parseInt(arg))
     .option('--json', 'Output the contract addresses in JSON format')
     .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('--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');
 
@@ -56,9 +63,13 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.mnemonicIndex,
         options.salt,
         options.testAccounts,
+        options.sponsoredFpc,
         options.acceleratedTestDeployments,
         options.json,
+        options.createVerificationJson,
         initialValidators,
+        options.realVerifier,
+        options.existingToken,
         log,
         debugLogger,
       );
@@ -66,7 +77,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
 
   program
     .command('deploy-new-rollup')
-    .description('Deploys a new rollup contract and a payload to upgrade the registry with it.')
+    .description('Deploys a new rollup contract and adds it to the registry (if you are the owner).')
     .requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress)
     .addOption(l1RpcUrlsOption)
     .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
@@ -74,13 +85,16 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .option(
       '-m, --mnemonic <string>',
       'The mnemonic to use in deployment',
-      'test test test test test test test test test test test junk',
+      MNEMONIC ?? 'test test test test test test test test test test test junk',
     )
     .option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use in deployment', arg => parseInt(arg), 0)
     .addOption(l1ChainIdOption)
     .option('--salt <number>', 'The optional salt to use in deployment', arg => parseInt(arg))
     .option('--json', 'Output the contract addresses in JSON format')
     .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');
 
@@ -95,8 +109,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.mnemonicIndex,
         options.salt,
         options.testAccounts,
+        options.sponsoredFpc,
         options.json,
         initialValidators,
+        options.realVerifier,
+        options.createVerificationJson,
         log,
         debugLogger,
       );
@@ -274,28 +291,40 @@ 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)
-    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .addOption(networkOption)
+    .option('-pk, --private-key <string>', 'The private key to use sending the transaction', PRIVATE_KEY)
     .option(
       '-m, --mnemonic <string>',
-      'The mnemonic to use in deployment',
+      'The mnemonic to use sending the transaction',
       'test test test test test test test test test test test junk',
     )
     .addOption(l1ChainIdOption)
-    .option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress)
-    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .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('--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,
-        validatorAddress: options.validator,
-        rollupAddress: options.rollup,
+        attesterAddress: options.attester,
+        blsSecretKey: options.blsSecretKey,
         withdrawerAddress: options.withdrawer,
+        rollupAddress,
+        moveWithLatestRollup: options.moveWithLatestRollup,
         log,
         debugLogger,
       });
@@ -347,6 +376,30 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       });
     });
 
+  program
+    .command('trigger-seed-snapshot')
+    .description('Triggers a seed snapshot for the next epoch.')
+    .option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic to use in deployment',
+      'test test test test test test test test test test test junk',
+    )
+    .option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress)
+    .addOption(l1RpcUrlsOption)
+    .addOption(l1ChainIdOption)
+    .action(async options => {
+      const { triggerSeedSnapshot } = await import('./trigger_seed_snapshot.js');
+      await triggerSeedSnapshot({
+        rollupAddress: options.rollup,
+        rpcUrls: options.l1RpcUrls,
+        chainId: options.l1ChainId,
+        privateKey: options.privateKey,
+        mnemonic: options.mnemonic,
+        log,
+      });
+    });
+
   program
     .command('debug-rollup')
     .description('Debugs the rollup contract.')
@@ -391,56 +444,6 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       });
     });
 
-  program
-    .command('deploy-l1-verifier')
-    .description('Deploys the rollup verifier contract')
-    .addOption(l1RpcUrlsOption)
-    .addOption(l1ChainIdOption)
-    .addOption(makePxeOption(false).conflicts('rollup-address'))
-    .addOption(
-      new Option('--rollup-address <string>', 'The address of the rollup contract')
-        .env('ROLLUP_CONTRACT_ADDRESS')
-        .argParser(parseEthereumAddress)
-        .conflicts('rpc-url'),
-    )
-    .option('--l1-private-key <string>', 'The L1 private key to use for deployment', PRIVATE_KEY)
-    .option(
-      '-m, --mnemonic <string>',
-      'The mnemonic to use in deployment',
-      'test test test test test test test test test test test junk',
-    )
-    .requiredOption('--verifier <verifier>', 'Either mock or real', 'real')
-    .option('--bb <path>', 'Path to bb binary', BB_BINARY_PATH)
-    .option('--bb-working-dir <path>', 'Path to bb working directory', BB_WORKING_DIRECTORY)
-    .action(async options => {
-      const { deployMockVerifier, deployUltraHonkVerifier } = await import('./deploy_l1_verifier.js');
-      if (options.verifier === 'mock') {
-        await deployMockVerifier(
-          options.rollupAddress?.toString(),
-          options.l1RpcUrls,
-          options.l1ChainId,
-          options.l1PrivateKey,
-          options.mnemonic,
-          options.rpcUrl,
-          log,
-          debugLogger,
-        );
-      } else {
-        await deployUltraHonkVerifier(
-          options.rollupAddress?.toString(),
-          options.l1RpcUrls,
-          options.l1ChainId,
-          options.l1PrivateKey,
-          options.mnemonic,
-          options.rpcUrl,
-          options.bb,
-          options.bbWorkingDir,
-          log,
-          debugLogger,
-        );
-      }
-    });
-
   program
     .command('bridge-erc20')
     .description('Bridges ERC20 tokens to L2.')
@@ -457,6 +460,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .addOption(l1ChainIdOption)
     .requiredOption('-t, --token <string>', 'The address of the token to bridge', parseEthereumAddress)
     .requiredOption('-p, --portal <string>', 'The address of the portal contract', parseEthereumAddress)
+    .option('-f, --faucet <string>', 'The address of the faucet contract (only used if minting)', parseEthereumAddress)
     .option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY)
     .option('--json', 'Output the claim in JSON format')
     .action(async (amount, recipient, options) => {
@@ -469,6 +473,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.l1PrivateKey,
         options.mnemonic,
         options.token,
+        options.faucet,
         options.portal,
         options.private,
         options.mint,
@@ -506,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;

package/src/cmds/l1/trigger_seed_snapshot.ts

@@ -0,0 +1,31 @@
+import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import type { LogFn } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+
+import { getContract } from 'viem';
+
+import type { RollupCommandArgs } from './update_l1_validators.js';
+
+export async function triggerSeedSnapshot({
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  rollupAddress,
+  log,
+}: RollupCommandArgs & { log: LogFn }) {
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic!, chain.chainInfo);
+
+  const rollup = getContract({
+    address: rollupAddress.toString(),
+    abi: RollupAbi,
+    client,
+  });
+
+  log('Triggering seed snapshot for next epoch');
+  const txHash = await rollup.write.checkpointRandao();
+  log(`Sent! | Seed snapshot setup for next epoch | tx hash: ${txHash}`);
+  const receipt = await client.waitForTransactionReceipt({ hash: txHash });
+  log(`Done! | Seed snapshot setup for next epoch | tx hash: ${txHash} | status: ${receipt.status}`);
+}