@aztec/cli 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/src/cmds/l1/deploy_new_rollup.ts

@@ -1,7 +1,8 @@
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { type Operator, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
 import { deployNewRollupContracts } from '../../utils/aztec.js';
@@ -14,15 +15,12 @@ export async function deployNewRollup(
   privateKey: string | undefined,
   mnemonic: string,
   mnemonicIndex: number,
-  salt: number | undefined,
   testAccounts: boolean,
   sponsoredFPC: boolean,
   json: boolean,
   initialValidators: Operator[],
   realVerifier: boolean,
-  createVerificationJson: string | false,
   log: LogFn,
-  debugLogger: Logger,
 ) {
   const config = getL1ContractsConfigEnvVars();
 
@@ -34,18 +32,15 @@ export async function deployNewRollup(
   const { rollup, slashFactoryAddress } = await deployNewRollupContracts(
     registryAddress,
     rpcUrls,
-    chainId,
     privateKey,
+    chainId,
     mnemonic,
     mnemonicIndex,
-    salt,
     initialValidators,
     genesisArchiveRoot,
     fundingNeeded,
     config,
     realVerifier,
-    createVerificationJson,
-    debugLogger,
   );
 
   if (json) {

package/src/cmds/l1/get_l1_addresses.ts

@@ -1,5 +1,7 @@
 import { EthAddress } from '@aztec/aztec.js/addresses';
-import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
 import type { LogFn } from '@aztec/foundation/log';
 
 import { createPublicClient, fallback, http } from 'viem';
@@ -15,7 +17,7 @@ export async function getL1Addresses(
   const chain = createEthereumChain(rpcUrls, chainId);
   const publicClient: ViemPublicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(rpcUrls.map(url => http(url))),
+    transport: fallback(rpcUrls.map(url => http(url, { batch: false }))),
     pollingInterval: 100,
   });
   const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);

package/src/cmds/l1/get_l1_balance.ts

@@ -1,4 +1,4 @@
-import { createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
@@ -18,7 +18,7 @@ export async function getL1Balance(
   const chain = createEthereumChain(l1RpcUrls, chainId);
   const publicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(l1RpcUrls.map(url => http(url))),
+    transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
   });
 
   let balance = 0n;

package/src/cmds/l1/governance_utils.ts

@@ -1,11 +1,6 @@
-import {
-  FeeJuiceContract,
-  GovernanceContract,
-  ProposalState,
-  RegistryContract,
-  createEthereumChain,
-  createExtendedL1Client,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract } from '@aztec/ethereum/contracts';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
 export async function depositGovernanceTokens({

package/src/cmds/l1/index.ts

@@ -3,7 +3,6 @@ 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,
@@ -15,8 +14,6 @@ import {
   parseEthereumAddress,
 } 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)',
@@ -42,31 +39,25 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .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('--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');
+      const { deployL1ContractsCmd } = await import('./deploy_l1_contracts_cmd.js');
 
       const initialValidators =
         options.validators?.split(',').map((validator: string) => EthAddress.fromString(validator)) || [];
-      await deployL1Contracts(
+      await deployL1ContractsCmd(
         options.l1RpcUrls,
         options.l1ChainId,
         options.privateKey,
         options.mnemonic,
         options.mnemonicIndex,
-        options.salt,
         options.testAccounts,
         options.sponsoredFpc,
-        options.acceleratedTestDeployments,
         options.json,
-        options.createVerificationJson,
         initialValidators,
         options.realVerifier,
         options.existingToken,
@@ -89,12 +80,10 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     )
     .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');
 
@@ -107,15 +96,12 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         options.privateKey,
         options.mnemonic,
         options.mnemonicIndex,
-        options.salt,
         options.testAccounts,
         options.sponsoredFpc,
         options.json,
         initialValidators,
         options.realVerifier,
-        options.createVerificationJson,
         log,
-        debugLogger,
       );
     });
 
@@ -313,7 +299,11 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
     .action(async options => {
       const { addL1ValidatorViaRollup } = await import('./update_l1_validators.js');
 
-      const rollupAddress = options.rollup ?? (await getL1RollupAddressFromEnv(options.l1RpcUrls, options.l1ChainId));
+      let rollupAddress = options.rollup;
+      if (!rollupAddress) {
+        const { getL1RollupAddressFromEnv } = await import('../../config/get_l1_config.js');
+        rollupAddress = await getL1RollupAddressFromEnv(options.l1RpcUrls, options.l1ChainId);
+      }
 
       await addL1ValidatorViaRollup({
         rpcUrls: options.l1RpcUrls,

package/src/cmds/l1/prover_stats.ts

@@ -1,5 +1,6 @@
 import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
-import { type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import type { ViemPublicClient } from '@aztec/ethereum/types';
 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';
@@ -46,7 +47,10 @@ export async function proverStats(opts: {
         .then(a => a.rollupAddress);
 
   const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
-  const publicClient = createPublicClient({ chain, transport: fallback(l1RpcUrls.map(url => http(url))) });
+  const publicClient = createPublicClient({
+    chain,
+    transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
+  });
   const lastBlockNum = endBlock ?? (await publicClient.getBlockNumber());
   debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
 
@@ -55,33 +59,40 @@ export async function proverStats(opts: {
 
   // If we only care for raw logs, output them
   if (rawLogs && !provingTimeout) {
-    log(`l1_block_number, l2_block_number, prover_id, tx_hash`);
+    log(`l1_block_number, checkpoint_number, prover_id, tx_hash`);
     for (const event of events) {
-      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-      log(`${l1BlockNumber}, ${l2BlockNumber}, ${proverId}, ${txHash}`);
+      const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+      log(`${l1BlockNumber}, ${checkpointNumber}, ${proverId}, ${txHash}`);
     }
     return;
   }
 
-  // If we don't have a proving timeout, we can just count the number of unique blocks per prover
+  // If we don't have a proving timeout, we can just count the number of unique checkpoints per prover
   if (!provingTimeout) {
     const stats = groupBy(events, 'proverId');
-    log(`prover_id, total_blocks_proven`);
+    log(`prover_id, total_checkpoints_proven`);
     for (const proverId in stats) {
-      const uniqueBlocks = new Set(stats[proverId].map(e => e.l2BlockNumber));
-      log(`${proverId}, ${uniqueBlocks.size}`);
+      const uniqueCheckpoints = new Set(stats[proverId].map(e => e.checkpointNumber));
+      log(`${proverId}, ${uniqueCheckpoints.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);
+  // But if we do, fetch the events for each checkpoint submitted, so we can look up their timestamp
+  const checkpointEvents = await getCheckpointProposedEvents(
+    startBlock,
+    lastBlockNum,
+    batchSize,
+    debugLog,
+    publicClient,
+    rollup,
+  );
   debugLog.verbose(
-    `First L2 block within range is ${blockEvents[0]?.args.blockNumber} at L1 block ${blockEvents[0]?.blockNumber}`,
+    `First checkpoint within range is ${checkpointEvents[0]?.args.checkpointNumber} at L1 block ${checkpointEvents[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 l1BlockNumbers = unique([...events.map(e => e.l1BlockNumber), ...checkpointEvents.map(e => e.blockNumber)]);
   const l1BlockTimestamps: Record<string, bigint> = {};
   for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))) {
     const blocks = await Promise.all(
@@ -93,44 +104,44 @@ export async function proverStats(opts: {
     }
   }
 
-  // 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;
+  // Map from checkpoint number to the l1 block in which it was submitted
+  const checkpointSubmissions: Record<string, bigint> = {};
+  for (const checkpointEvent of checkpointEvents) {
+    checkpointSubmissions[checkpointEvent.args.checkpointNumber!.toString()] = checkpointEvent.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`);
+    log(`l1_block_number, checkpoint_number, checkpoint_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
     for (const event of events) {
-      const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-      const uploadedBlockNumber = l2BlockSubmissions[l2BlockNumber.toString()];
+      const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+      const uploadedBlockNumber = checkpointSubmissions[checkpointNumber.toString()];
       if (!uploadedBlockNumber) {
         continue;
       }
       const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
       const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
-      log(`${l1BlockNumber}, ${l2BlockNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+      log(`${l1BlockNumber}, ${checkpointNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
     }
     return;
   }
 
   // Or calculate stats per prover
-  const stats = mapValues(groupBy(events, 'proverId'), (blocks, proverId) =>
+  const stats = mapValues(groupBy(events, 'proverId'), (checkpoints, proverId) =>
     compactArray(
-      blocks.map(e => {
+      checkpoints.map(e => {
         const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
-        const uploadedBlockNumber = l2BlockSubmissions[e.l2BlockNumber.toString()];
+        const uploadedBlockNumber = checkpointSubmissions[e.checkpointNumber.toString()];
         if (!uploadedBlockNumber) {
           debugLog.verbose(
-            `Skipping ${proverId}'s proof for L2 block ${e.l2BlockNumber} as it was before the start block`,
+            `Skipping ${proverId}'s proof for checkpoint ${e.checkpointNumber} 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}`,
+          `prover=${e.proverId} checkpointNumber=${e.checkpointNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`,
         );
         return { provenTimestamp, uploadedTimestamp, provingTime, ...e };
       }),
@@ -141,8 +152,8 @@ export async function proverStats(opts: {
   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 uniqueBlocksWithinTimeout = new Set(withinTimeout.map(e => e.checkpointNumber));
+    const uniqueBlocks = new Set(blocks.map(e => e.checkpointNumber));
     const avgProvingTime =
       blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b) => acc + b.provingTime, 0n)) / blocks.length);
 
@@ -171,7 +182,7 @@ async function getL2ProofVerifiedEvents(
   return events;
 }
 
-async function getL2BlockEvents(
+async function getCheckpointProposedEvents(
   startBlock: bigint,
   lastBlockNum: bigint,
   batchSize: bigint,
@@ -188,14 +199,14 @@ async function getL2BlockEvents(
       address: getAddress(rollup.toString()),
       event: getAbiItem({
         abi: RollupAbi,
-        name: 'L2BlockProposed',
+        name: 'CheckpointProposed',
       }),
       fromBlock: blockNum,
       toBlock: end,
     });
 
     events.push(...newEvents);
-    debugLog.verbose(`Got ${newEvents.length} events querying l2 block submitted from block ${blockNum} to ${end}`);
+    debugLog.verbose(`Got ${newEvents.length} events querying checkpoints submitted from block ${blockNum} to ${end}`);
     blockNum += batchSize;
   }
   return events;

package/src/cmds/l1/trigger_seed_snapshot.ts

@@ -1,4 +1,5 @@
-import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
 import type { LogFn } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 

package/src/cmds/l1/update_l1_validators.ts

@@ -1,13 +1,8 @@
-import {
-  GSEContract,
-  RollupContract,
-  createEthereumChain,
-  createExtendedL1Client,
-  createL1TxUtilsFromViemWallet,
-  getL1ContractsConfigEnvVars,
-  getPublicClient,
-  isAnvilTestChain,
-} from '@aztec/ethereum';
+import { createEthereumChain, isAnvilTestChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client, getPublicClient } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec/ethereum/contracts';
+import { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
 import { EthCheatCodes } from '@aztec/ethereum/test';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn, Logger } from '@aztec/foundation/log';
@@ -299,9 +294,9 @@ export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }: Roll
   const publicClient = getPublicClient({ l1RpcUrls: rpcUrls, l1ChainId: chainId });
   const rollup = new RollupContract(publicClient, rollupAddress);
 
-  const pendingNum = await rollup.getBlockNumber();
+  const pendingNum = await rollup.getCheckpointNumber();
   log(`Pending block num: ${pendingNum}`);
-  const provenNum = await rollup.getProvenBlockNumber();
+  const provenNum = await rollup.getProvenCheckpointNumber();
   log(`Proven block num: ${provenNum}`);
   const validators = await rollup.getAttesters();
   log(`Validators: ${validators.map(v => v.toString()).join(', ')}`);

package/src/cmds/misc/generate_secret_and_hash.ts

@@ -1,5 +1,5 @@
 import { computeSecretHash } from '@aztec/aztec.js/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { LogFn } from '@aztec/foundation/log';
 
 export async function generateSecretAndHash(log: LogFn) {

package/src/cmds/misc/index.ts

@@ -1,5 +1,4 @@
 import type { LogFn } from '@aztec/foundation/log';
-import { printENR } from '@aztec/p2p/enr';
 
 import type { Command } from 'commander';
 
@@ -49,6 +48,7 @@ export function injectCommands(program: Command, log: LogFn) {
     .description('Decodes and ENR record')
     .argument('<enr>', 'The encoded ENR string')
     .action(async (enr: string) => {
+      const { printENR } = await import('@aztec/p2p/enr');
       await printENR(enr, log);
     });
 

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

@@ -9,7 +9,7 @@ import { type SemVer, parse } from 'semver';
 import type { DependencyChanges } from './common.js';
 import { atomicUpdateFile } from './utils.js';
 
-const deprecatedNpmPackages = new Set<string>(['@aztec/cli', '@aztec/aztec-sandbox']);
+const deprecatedNpmPackages = new Set<string>(['@aztec/cli', '@aztec/aztec-local-network']);
 const npmDeprecationMessage = `
 The following packages have been deprecated and will no longer be updated on the npm registry:
 ${Array.from(deprecatedNpmPackages)

package/src/cmds/validator_keys/add.ts

@@ -16,28 +16,35 @@ import {
   writeEthJsonV3ToFile,
   writeKeystoreFile,
 } from './shared.js';
+import { validateBlsPathOptions, validatePublisherOptions, validateRemoteSignerOptions } from './utils.js';
 
 export type AddValidatorKeysOptions = NewValidatorKeystoreOptions;
 
 export async function addValidatorKeys(existing: string, options: AddValidatorKeysOptions, log: LogFn) {
+  // validate bls-path inputs before proceeding with key generation
+  validateBlsPathOptions(options);
+  // validate publisher options
+  validatePublisherOptions(options);
+  // validate remote signer options
+  validateRemoteSignerOptions(options);
+
   const {
     dataDir,
     file,
     count,
     publisherCount = 0,
+    publishers,
     mnemonic,
     accountIndex = 0,
     addressIndex,
     ikm,
     blsPath,
-    blsOnly,
     json,
     feeRecipient: feeRecipientOpt,
     coinbase: coinbaseOpt,
-    fundingAccount: fundingAccountOpt,
     remoteSigner: remoteSignerOpt,
     password,
-    outDir,
+    encryptedKeystoreDir,
   } = options;
 
   const validatorCount = typeof count === 'number' && Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
@@ -55,8 +62,6 @@ export async function addValidatorKeys(existing: string, options: AddValidatorKe
     throw new Error('feeRecipient is required (either present in existing file or via --fee-recipient)');
   }
   const coinbase = (coinbaseOpt as EthAddress | undefined) ?? (first.coinbase as EthAddress | undefined);
-  const fundingAccount =
-    (fundingAccountOpt as EthAddress | undefined) ?? (first.fundingAccount as EthAddress | undefined);
   const derivedRemoteSigner = (first.attester as any)?.remoteSignerUrl || (first.attester as any)?.eth?.remoteSignerUrl;
   const remoteSigner = remoteSignerOpt ?? derivedRemoteSigner;
 
@@ -70,26 +75,31 @@ export async function addValidatorKeys(existing: string, options: AddValidatorKe
   const { validators, summaries } = await buildValidatorEntries({
     validatorCount,
     publisherCount,
+    publishers,
     accountIndex,
     baseAddressIndex: effectiveBaseAddressIndex,
     mnemonic: mnemonicToUse,
     ikm,
     blsPath,
-    blsOnly,
     feeRecipient,
     coinbase,
     remoteSigner,
-    fundingAccount,
   });
 
   keystore.validators.push(...validators);
 
   // If password provided, write ETH JSON V3 and BLS BN254 keystores and replace plaintext
   if (password !== undefined) {
-    const targetDir =
-      outDir && outDir.length > 0 ? outDir : dataDir && dataDir.length > 0 ? dataDir : dirname(existing);
+    let targetDir: string;
+    if (encryptedKeystoreDir && encryptedKeystoreDir.length > 0) {
+      targetDir = encryptedKeystoreDir;
+    } else if (dataDir && dataDir.length > 0) {
+      targetDir = dataDir;
+    } else {
+      targetDir = dirname(existing);
+    }
     await writeEthJsonV3ToFile(keystore.validators, { outDir: targetDir, password });
-    await writeBlsBn254ToFile(keystore.validators, { outDir: targetDir, password });
+    await writeBlsBn254ToFile(keystore.validators, { outDir: targetDir, password, blsPath });
   }
 
   let outputPath = existing;

package/src/cmds/validator_keys/generate_bls_keypair.ts

@@ -1,9 +1,10 @@
-import { deriveBlsPrivateKey } from '@aztec/foundation/crypto';
+import { deriveBlsPrivateKey } from '@aztec/foundation/crypto/bls';
 import type { LogFn } from '@aztec/foundation/log';
 
 import { writeFile } from 'fs/promises';
 
 import { computeBlsPublicKeyCompressed, withValidatorIndex } from './shared.js';
+import { defaultBlsPath } from './utils.js';
 
 export type GenerateBlsKeypairOptions = {
   mnemonic?: string;
@@ -17,7 +18,7 @@ export type GenerateBlsKeypairOptions = {
 
 export async function generateBlsKeypair(options: GenerateBlsKeypairOptions, log: LogFn) {
   const { mnemonic, ikm, blsPath, compressed = true, json, out } = options;
-  const path = withValidatorIndex(blsPath ?? 'm/12381/3600/0/0/0', 0);
+  const path = withValidatorIndex(blsPath ?? defaultBlsPath, 0);
   const priv = deriveBlsPrivateKey(mnemonic, ikm, path);
   const pub = await computeBlsPublicKeyCompressed(priv);
   const result = { path, privateKey: priv, publicKey: pub, format: compressed ? 'compressed' : 'uncompressed' };