@aztec/cli 0.0.1-fake-c83136db25 → 0.0.1-private.d0bedffd

package/src/config/generated/networks.ts

@@ -0,0 +1,227 @@
+// Auto-generated from spartan/environments/network-defaults.yml
+// Do not edit manually - run yarn generate to regenerate
+
+export const devnetConfig = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_SLOT_DURATION: 72,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
+  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
+  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
+  SLASH_MAX_PENALTY_PERCENTAGE: 2,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 0,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  DATA_STORE_MAP_SIZE_KB: 134217728,
+  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
+  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
+  NULLIFIER_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_OTEL_INCLUDE_METRICS: 'aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_',
+  SENTINEL_ENABLED: true,
+  AZTEC_EPOCH_DURATION: 8,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 1,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 1,
+  L1_CHAIN_ID: 11155111,
+  TEST_ACCOUNTS: true,
+  SPONSORED_FPC: true,
+  TRANSACTIONS_DISABLED: false,
+  SEQ_MAX_TX_PER_BLOCK: 18,
+  PROVER_REAL_PROOFS: false,
+  PXE_PROVER_ENABLED: false,
+  SYNC_SNAPSHOTS_URLS: '',
+  SKIP_ARCHIVER_INITIAL_SYNC: false,
+  BLOB_ALLOW_EMPTY_SOURCES: false,
+  P2P_MAX_PENDING_TX_COUNT: 1000,
+  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
+  PUBLIC_OTEL_OPT_OUT: true,
+  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
+  PUBLIC_OTEL_COLLECT_FROM: '',
+  SLASH_PRUNE_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+  ENABLE_VERSION_CHECK: true,
+} as const;
+
+export const testnetConfig = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
+  SLASH_MAX_PENALTY_PERCENTAGE: 2,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 0,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  DATA_STORE_MAP_SIZE_KB: 134217728,
+  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
+  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
+  NULLIFIER_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_OTEL_INCLUDE_METRICS: 'aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_',
+  SENTINEL_ENABLED: true,
+  AZTEC_SLOT_DURATION: 72,
+  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
+  AZTEC_EJECTION_THRESHOLD: 1E+23,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 1.99E+23,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 2,
+  AZTEC_SLASHING_VETOER: '0xdfe19Da6a717b7088621d8bBB66be59F2d78e924',
+  AZTEC_SLASHING_QUORUM: 33,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
+  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
+  AZTEC_MANA_TARGET: 75000000,
+  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 1E+23,
+  AZTEC_SLASH_AMOUNT_LARGE: 1E+23,
+  L1_CHAIN_ID: 11155111,
+  TEST_ACCOUNTS: false,
+  SPONSORED_FPC: false,
+  TRANSACTIONS_DISABLED: false,
+  SEQ_MAX_TX_PER_CHECKPOINT: 72,
+  PROVER_REAL_PROOFS: true,
+  P2P_MAX_PENDING_TX_COUNT: 1000,
+  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
+  SLASH_PRUNE_PENALTY: 10000000000000000000,
+  SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 10000000000000000000,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 64,
+  ENABLE_VERSION_CHECK: true,
+} as const;
+
+export const mainnetConfig = {
+  ETHEREUM_SLOT_DURATION: 12,
+  AZTEC_EPOCH_DURATION: 32,
+  AZTEC_TARGET_COMMITTEE_SIZE: 48,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
+  AZTEC_INBOX_LAG: 1,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
+  SLASH_MAX_PENALTY_PERCENTAGE: 2,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 0,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  DATA_STORE_MAP_SIZE_KB: 134217728,
+  ARCHIVER_STORE_MAP_SIZE_KB: 1073741824,
+  NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824,
+  NULLIFIER_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824,
+  PUBLIC_OTEL_INCLUDE_METRICS: 'aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_',
+  SENTINEL_ENABLED: true,
+  AZTEC_SLOT_DURATION: 72,
+  AZTEC_ACTIVATION_THRESHOLD: 2E+23,
+  AZTEC_EJECTION_THRESHOLD: 1E+23,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9E+23,
+  AZTEC_SLASH_AMOUNT_SMALL: 2E+21,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 2E+21,
+  AZTEC_SLASH_AMOUNT_LARGE: 2E+21,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 34,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 28,
+  AZTEC_SLASHING_VETOER: '0xBbB4aF368d02827945748b28CD4b2D42e4A37480',
+  AZTEC_SLASHING_QUORUM: 65,
+  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
+  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
+  AZTEC_MANA_TARGET: 75000000,
+  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_EXIT_DELAY_SECONDS: 345600,
+  AZTEC_SLASHING_DISABLE_DURATION: 259200,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 500,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 1,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 400,
+  AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 4,
+  L1_CHAIN_ID: 1,
+  TEST_ACCOUNTS: false,
+  SPONSORED_FPC: false,
+  TRANSACTIONS_DISABLED: false,
+  SEQ_MAX_TX_PER_CHECKPOINT: 72,
+  PROVER_REAL_PROOFS: true,
+  SYNC_SNAPSHOTS_URLS: 'https://aztec-labs-snapshots.com/mainnet/',
+  BLOB_ALLOW_EMPTY_SOURCES: true,
+  P2P_MAX_PENDING_TX_COUNT: 1000,
+  P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
+  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
+  PUBLIC_OTEL_COLLECT_FROM: '',
+  ENABLE_VERSION_CHECK: false,
+  SLASH_PRUNE_PENALTY: 0,
+  SLASH_DATA_WITHHOLDING_PENALTY: 0,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
+  SLASH_INACTIVITY_PENALTY: 2E+21,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2E+21,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 2E+21,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 2E+21,
+  SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2E+21,
+  SLASH_UNKNOWN_PENALTY: 2E+21,
+  SLASH_INVALID_BLOCK_PENALTY: 2E+21,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 1200,
+} as const;
+

package/src/config/get_l1_config.ts

@@ -1,4 +1,7 @@
-import { type L1ContractAddresses, RegistryContract, getL1ContractsConfig, getPublicClient } from '@aztec/ethereum';
+import { getPublicClient } from '@aztec/ethereum/client';
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { getL1ContractsConfig } from '@aztec/ethereum/queries';
 import { EthAddress } from '@aztec/foundation/eth-address';
 
 export async function getL1Config(

package/src/config/network_config.ts

@@ -8,27 +8,66 @@ import { enrichEthAddressVar, enrichVar } from './enrich_env.js';
 
 const DEFAULT_CONFIG_URL =
   'https://raw.githubusercontent.com/AztecProtocol/networks/refs/heads/main/network_config.json';
-const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
+const FALLBACK_CONFIG_URL = 'https://metadata.aztec.network/network_config.json';
 
 /**
  * Fetches remote network configuration from GitHub with caching support.
- * Uses the reusable cachedFetch utility.
+ * Uses the reusable cachedFetch utility. Falls back to metadata.aztec.network if the default URL fails.
  *
  * @param networkName - The network name to fetch config for
  * @param cacheDir - Optional cache directory for storing fetched config
- * @returns Remote configuration for the specified network, or undefined if not found/error
+ * @returns Remote configuration for the specified network, or undefined if network not found in config
+ * @throws Error if both primary and fallback URLs fail to fetch
  */
 export async function getNetworkConfig(
   networkName: NetworkNames,
   cacheDir?: string,
 ): Promise<NetworkConfig | undefined> {
-  let url: URL | undefined;
+  // Try with the primary URL (env var or default)
   const configLocation = process.env.NETWORK_CONFIG_LOCATION || DEFAULT_CONFIG_URL;
 
-  if (!configLocation) {
-    return undefined;
+  let primaryError: Error | undefined;
+  let config: NetworkConfig | undefined;
+
+  // First try the primary config location
+  try {
+    config = await fetchNetworkConfigFromUrl(configLocation, networkName, cacheDir);
+  } catch (error) {
+    primaryError = error as Error;
   }
 
+  // If primary fails and we were using the default URL, try the fallback
+  if (!config && configLocation === DEFAULT_CONFIG_URL) {
+    try {
+      config = await fetchNetworkConfigFromUrl(FALLBACK_CONFIG_URL, networkName, cacheDir);
+    } catch {
+      // Both failed - throw the primary error
+      if (primaryError) {
+        throw primaryError;
+      }
+    }
+  } else if (primaryError) {
+    // Primary failed and no fallback to try
+    throw primaryError;
+  }
+
+  return config;
+}
+
+/**
+ * Helper function to fetch network config from a specific URL.
+ * @param configLocation - The URL or file path to fetch from
+ * @param networkName - The network name to fetch config for
+ * @param cacheDir - Optional cache directory for storing fetched config
+ * @returns Remote configuration for the specified network, or undefined if network not found in config, or undefined if URL invalid
+ * @throws Error if fetch/parse fails
+ */
+async function fetchNetworkConfigFromUrl(
+  configLocation: string,
+  networkName: NetworkNames,
+  cacheDir?: string,
+): Promise<NetworkConfig | undefined> {
+  let url: URL | undefined;
   try {
     if (configLocation.includes('://')) {
       url = new URL(configLocation);
@@ -43,31 +82,26 @@ export async function getNetworkConfig(
     return undefined;
   }
 
-  try {
-    let rawConfig: any;
-
-    if (url.protocol === 'http:' || url.protocol === 'https:') {
-      rawConfig = await cachedFetch(url.href, {
-        cacheDurationMs: NETWORK_CONFIG_CACHE_DURATION_MS,
-        cacheFile: cacheDir ? join(cacheDir, networkName, 'network_config.json') : undefined,
-      });
-    } else if (url.protocol === 'file:') {
-      rawConfig = JSON.parse(await readFile(url.pathname, 'utf-8'));
-    } else {
-      throw new Error('Unsupported Aztec network config protocol: ' + url.href);
-    }
+  let rawConfig: any;
 
-    if (!rawConfig) {
-      return undefined;
-    }
+  if (url.protocol === 'http:' || url.protocol === 'https:') {
+    rawConfig = await cachedFetch(url.href, {
+      cacheFile: cacheDir ? join(cacheDir, networkName, 'network_config.json') : undefined,
+    });
+  } else if (url.protocol === 'file:') {
+    rawConfig = JSON.parse(await readFile(url.pathname, 'utf-8'));
+  } else {
+    throw new Error('Unsupported Aztec network config protocol: ' + url.href);
+  }
 
-    const networkConfigMap = NetworkConfigMapSchema.parse(rawConfig);
-    if (networkName in networkConfigMap) {
-      return networkConfigMap[networkName];
-    } else {
-      return undefined;
-    }
-  } catch {
+  if (!rawConfig) {
+    return undefined;
+  }
+
+  const networkConfigMap = NetworkConfigMapSchema.parse(rawConfig);
+  if (networkName in networkConfigMap) {
+    return networkConfigMap[networkName];
+  } else {
     return undefined;
   }
 }
@@ -75,9 +109,11 @@ export async function getNetworkConfig(
 /**
  * Enriches environment variables with remote network configuration.
  * This function is called before node config initialization to set env vars
- * from the remote config, following the same pattern as enrichEnvironmentWithChainConfig().
+ * from the remote config.
  *
  * @param networkName - The network name to fetch remote config for
+ * @throws Error if network config fetch fails (network errors, parse errors, etc.)
+ * Does not throw if the network simply doesn't exist in the config - just returns without enriching
  */
 export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNames) {
   if (networkName === 'local') {
@@ -88,7 +124,7 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
   const networkConfig = await getNetworkConfig(networkName, cacheDir);
 
   if (!networkConfig) {
-    return;
+    return; // Network not found in config, continue without enriching
   }
 
   enrichVar('BOOTSTRAP_NODES', networkConfig.bootnodes.join(','));
@@ -99,4 +135,14 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
   if (networkConfig.feeAssetHandlerAddress) {
     enrichEthAddressVar('FEE_ASSET_HANDLER_CONTRACT_ADDRESS', networkConfig.feeAssetHandlerAddress.toString());
   }
+
+  if (networkConfig.blobFileStoreUrls?.length) {
+    enrichVar('BLOB_FILE_STORE_URLS', networkConfig.blobFileStoreUrls.join(','));
+  }
+  if (networkConfig.blockDurationMs !== undefined) {
+    enrichVar('SEQ_BLOCK_DURATION_MS', String(networkConfig.blockDurationMs));
+  }
+  if (networkConfig.txPublicSetupAllowListExtend) {
+    enrichVar('TX_PUBLIC_SETUP_ALLOWLIST', networkConfig.txPublicSetupAllowListExtend);
+  }
 }

package/src/utils/aztec.ts

@@ -6,23 +6,23 @@ import {
   loadContractArtifact,
 } from '@aztec/aztec.js/abi';
 import { EthAddress } from '@aztec/aztec.js/addresses';
-import {
-  type DeployL1ContractsReturnType,
-  type L1ContractsConfig,
-  type Operator,
-  RollupContract,
-} from '@aztec/ethereum';
+import type { L1ContractsConfig } from '@aztec/ethereum/config';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { Operator } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type LogFn, createLogger } from '@aztec/foundation/log';
 import type { NoirPackageConfig } from '@aztec/foundation/noir';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 
 import TOML from '@iarna/toml';
 import { readFile } from 'fs/promises';
+import type { HDAccount, Hex, PrivateKeyAccount } from 'viem';
 
 import { encodeArgs } from './encoding.js';
 
+const logger = createLogger('cli:utils:aztec');
+
 /**
  * Helper to get an ABI function or throw error if it doesn't exist.
  * @param artifact - Contract's build artifact in JSON format.
@@ -37,89 +37,32 @@ export function getFunctionAbi(artifact: ContractArtifact, fnName: string): Func
   return fn;
 }
 
-/**
- * Function to execute the 'deployRollupContracts' command.
- * @param rpcUrls - The RPC URL of the ethereum node.
- * @param chainId - The chain ID of the L1 host.
- * @param privateKey - The private key to be used in contract deployment.
- * @param mnemonic - The mnemonic to be used in contract deployment.
- */
-export async function deployAztecContracts(
-  rpcUrls: string[],
-  chainId: number,
-  privateKey: string | undefined,
-  mnemonic: string,
-  mnemonicIndex: number,
-  salt: number | undefined,
-  initialValidators: Operator[],
-  genesisArchiveRoot: Fr,
-  feeJuicePortalInitialBalance: bigint,
-  acceleratedTestDeployments: boolean,
-  config: L1ContractsConfig,
-  existingToken: EthAddress | undefined,
-  realVerifier: boolean,
-  createVerificationJson: string | false,
-  debugLogger: Logger,
-): Promise<DeployL1ContractsReturnType> {
-  const { createEthereumChain, deployL1Contracts } = await import('@aztec/ethereum');
-  const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
-
-  const account = !privateKey
-    ? mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex })
-    : privateKeyToAccount(addLeadingHex(privateKey));
-  const chain = createEthereumChain(rpcUrls, chainId);
-
-  const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
-
-  const result = await deployL1Contracts(
-    chain.rpcUrls,
-    account,
-    chain.chainInfo,
-    debugLogger,
-    {
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractsHash,
-      genesisArchiveRoot,
-      salt,
-      initialValidators,
-      acceleratedTestDeployments,
-      feeJuicePortalInitialBalance,
-      realVerifier,
-      existingTokenAddress: existingToken,
-      ...config,
-    },
-    config,
-    createVerificationJson,
-  );
-
-  return result;
-}
-
 export async function deployNewRollupContracts(
   registryAddress: EthAddress,
   rpcUrls: string[],
-  chainId: number,
   privateKey: string | undefined,
+  chainId: number,
   mnemonic: string,
   mnemonicIndex: number,
-  salt: number | undefined,
   initialValidators: Operator[],
   genesisArchiveRoot: Fr,
   feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
   realVerifier: boolean,
-  createVerificationJson: string | false,
-  logger: Logger,
 ): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
-  const { createEthereumChain, deployRollupForUpgrade, createExtendedL1Client } = await import('@aztec/ethereum');
+  const { deployRollupForUpgrade } = await import('@aztec/ethereum/deploy-aztec-l1-contracts');
   const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
   const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
 
-  const account = !privateKey
-    ? mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex })
-    : privateKeyToAccount(addLeadingHex(privateKey));
-  const chain = createEthereumChain(rpcUrls, chainId);
-  const client = createExtendedL1Client(rpcUrls, account, chain.chainInfo, undefined, mnemonicIndex);
+  let account: HDAccount | PrivateKeyAccount;
+  if (privateKey) {
+    account = privateKeyToAccount(addLeadingHex(privateKey));
+  } else {
+    account = mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex });
+    const privateKeyBuf = account.getHdKey().privateKey;
+    const privateKeyHex = Buffer.from(privateKeyBuf!).toString('hex');
+    privateKey = `0x${privateKeyHex}`;
+  }
 
   if (!initialValidators || initialValidators.length === 0) {
     // initialize the new rollup with Amin's validator address.
@@ -138,9 +81,11 @@ export async function deployNewRollupContracts(
   }
 
   const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
-    client,
+    privateKey as Hex,
+    rpcUrls[0],
+    chainId,
+    registryAddress,
     {
-      salt,
       vkTreeRoot: getVKTreeRoot(),
       protocolContractsHash,
       genesisArchiveRoot,
@@ -149,13 +94,9 @@ export async function deployNewRollupContracts(
       realVerifier,
       ...config,
     },
-    registryAddress,
-    logger,
-    config,
-    createVerificationJson,
   );
 
-  return { rollup, slashFactoryAddress };
+  return { rollup, slashFactoryAddress: EthAddress.fromString(slashFactoryAddress!) };
 }
 
 /**

package/src/utils/commands.ts

@@ -1,11 +1,12 @@
-import { FunctionSelector } from '@aztec/aztec.js/abi';
-import { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
-import { Fr } from '@aztec/aztec.js/fields';
-import { LogId } from '@aztec/aztec.js/log';
-import { TxHash } from '@aztec/aztec.js/tx';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import type { LogFn } from '@aztec/foundation/log';
 import type { PXE } from '@aztec/pxe/server';
+import { FunctionSelector } from '@aztec/stdlib/abi/function-selector';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { PublicKeys } from '@aztec/stdlib/keys';
+import { LogId } from '@aztec/stdlib/logs/log-id';
+import { TxHash } from '@aztec/stdlib/tx/tx-hash';
 
 import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
 import { lookup } from 'dns/promises';
@@ -112,6 +113,34 @@ export async function getTxSender(pxe: PXE, _from?: string) {
   return from;
 }
 
+/**
+ * Parses and validates a hex string. Removes leading 0x if present, checks for hex validity,
+ * and enforces an optional minimum length.
+ * @param hex - The hex string to validate.
+ * @param minLen - Optional minimum length (in hex characters, after stripping '0x').
+ * @returns The normalized hex string (without leading 0x).
+ * @throws InvalidArgumentError if the string is not valid hex or does not meet the minimum length.
+ */
+// minLen is now interpreted as the minimum number of bytes (2 hex characters per byte)
+export function parseHex(hex: string, minLen?: number): `0x${string}` {
+  const normalized = hex.startsWith('0x') ? hex.slice(2) : hex;
+
+  if (!/^[0-9a-fA-F]*$/.test(normalized)) {
+    throw new InvalidArgumentError('Invalid hex string');
+  }
+
+  if (minLen !== undefined) {
+    const minHexLen = minLen * 2;
+    if (normalized.length < minHexLen) {
+      throw new InvalidArgumentError(
+        `Hex string is too short (length ${normalized.length}), minimum byte length is ${minLen} (hex chars: ${minHexLen})`,
+      );
+    }
+  }
+
+  return `0x${normalized}`;
+}
+
 /**
  * Removes the leading 0x from a hex string. If no leading 0x is found the string is returned unchanged.
  * @param hex - A hex string
@@ -166,7 +195,7 @@ export function parseAztecAddress(address: string): AztecAddress {
   try {
     return AztecAddress.fromString(address);
   } catch {
-    throw new InvalidArgumentError(`Invalid address: ${address}`);
+    throw new InvalidArgumentError(`Invalid Aztec address: ${address}`);
   }
 }
 
@@ -180,7 +209,7 @@ export function parseEthereumAddress(address: string): EthAddress {
   try {
     return EthAddress.fromString(address);
   } catch {
-    throw new InvalidArgumentError(`Invalid address: ${address}`);
+    throw new InvalidArgumentError(`Invalid Ethereumaddress: ${address}`);
   }
 }
 
@@ -234,7 +263,11 @@ export function parseOptionalSelector(selector: string): FunctionSelector | unde
  * @returns The parsed integer, or undefined if the input string is falsy.
  * @throws If the input is not a valid integer.
  */
-export function parseOptionalInteger(value: string): number | undefined {
+export function parseOptionalInteger(
+  value: string,
+  min: number = Number.MIN_SAFE_INTEGER,
+  max: number = Number.MAX_SAFE_INTEGER,
+): number | undefined {
   if (!value) {
     return undefined;
   }
@@ -242,6 +275,12 @@ export function parseOptionalInteger(value: string): number | undefined {
   if (!Number.isInteger(parsed)) {
     throw new InvalidArgumentError('Invalid integer.');
   }
+  if (parsed < min) {
+    throw new InvalidArgumentError(`Value must be greater than ${min}.`);
+  }
+  if (parsed > max) {
+    throw new InvalidArgumentError(`Value must be less than ${max}.`);
+  }
   return parsed;
 }
 

package/src/utils/encoding.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ABIParameter, AbiType, StructType } from '@aztec/stdlib/abi';
 
 /**

package/src/utils/inspect.ts

@@ -1,10 +1,11 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { LogFn } from '@aztec/foundation/log';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 export async function inspectBlock(
   aztecNode: AztecNode,
-  blockNumber: number,
+  blockNumber: BlockNumber,
   log: LogFn,
   opts: { showTxs?: boolean } = {},
 ) {
@@ -43,7 +44,10 @@ export async function inspectTx(
   const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
   // Base tx data
   log(`Tx ${txHash.toString()}`);
-  log(` Status: ${receipt.status} ${effectsInBlock ? `(${effectsInBlock.data.revertCode.getDescription()})` : ''}`);
+  log(` Status: ${receipt.status}`);
+  if (receipt.executionResult) {
+    log(` Execution result: ${receipt.executionResult}`);
+  }
   if (receipt.error) {
     log(` Error: ${receipt.error}`);
   }