@aztec-labs/cli 6.0.0-nightly.20260829

package/src/config/generated/networks.ts

@@ -0,0 +1,241 @@
+// 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_ACTIVATION_THRESHOLD: 100000000000000000000,
+  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
+  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
+  AZTEC_EXIT_DELAY_SECONDS: 172800,
+  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_MANA_TARGET: 100000000,
+  AZTEC_PROVING_COST_PER_MANA: 100,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_ENABLED: true,
+  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,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 0,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 0,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 48,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 2,
+  AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 48,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 1,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  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,
+  OFFENSE_COLLECTION_ENABLED: true,
+  AZTEC_SLOT_DURATION: 36,
+  AZTEC_EPOCH_DURATION: 8,
+  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 1,
+  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1,
+  AZTEC_TARGET_COMMITTEE_SIZE: 1,
+  SEQ_BLOCK_DURATION_MS: 3000,
+  MAX_BLOCKS_PER_CHECKPOINT: 9,
+  CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 6,
+  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 1,
+  AZTEC_SLASHING_QUORUM: 17,
+  AZTEC_GOVERNANCE_PROPOSER_QUORUM: 151,
+  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_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_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000,
+  SLASH_UNKNOWN_PENALTY: 10000000000000000000,
+  SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 0,
+  ENABLE_AUTO_SHUTDOWN: false,
+} 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_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_ENABLED: true,
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  AZTEC_SLASHING_DISABLE_DURATION: 432000,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 0,
+  AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 0,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 48,
+  AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 2,
+  AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 48,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 1,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  MAX_BLOCKS_PER_CHECKPOINT: 10,
+  CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 12,
+  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,
+  OFFENSE_COLLECTION_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: 12500000,
+  AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
+  AZTEC_SLASH_AMOUNT_MEDIUM: 2.5E+23,
+  AZTEC_SLASH_AMOUNT_LARGE: 2.5E+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_DATA_WITHHOLDING_PENALTY: 0,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1,
+  SLASH_INACTIVITY_PENALTY: 1E+23,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1E+23,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 2.5E+23,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 2.5E+23,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
+  SLASH_UNKNOWN_PENALTY: 1E+23,
+  SLASH_INVALID_BLOCK_PENALTY: 1E+23,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 1E+23,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 64,
+  ENABLE_AUTO_SHUTDOWN: false,
+} 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_PROOF_SUBMISSION_EPOCHS: 1,
+  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
+  AZTEC_SLASHER_ENABLED: true,
+  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
+  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
+  SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
+  SLASH_MAX_PAYLOAD_SIZE: 80,
+  SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4,
+  SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3,
+  P2P_ENABLED: true,
+  BOOTSTRAP_NODES: '',
+  SEQ_MIN_TX_PER_BLOCK: 1,
+  SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  MAX_BLOCKS_PER_CHECKPOINT: 10,
+  CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 12,
+  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,
+  OFFENSE_COLLECTION_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: 5E+21,
+  AZTEC_SLASH_AMOUNT_LARGE: 5E+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: 12500000,
+  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,
+  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_AUTO_SHUTDOWN: false,
+  SLASH_DATA_WITHHOLDING_PENALTY: 0,
+  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7,
+  SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,
+  SLASH_INACTIVITY_PENALTY: 2E+21,
+  SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2E+21,
+  SLASH_DUPLICATE_PROPOSAL_PENALTY: 5E+21,
+  SLASH_DUPLICATE_ATTESTATION_PENALTY: 5E+21,
+  SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0,
+  SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
+  SLASH_UNKNOWN_PENALTY: 2E+21,
+  SLASH_INVALID_BLOCK_PENALTY: 2E+21,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 2E+21,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 8400,
+} as const;
+

package/src/config/get_l1_config.ts

@@ -0,0 +1,31 @@
+import { getPublicClient } from '@aztec-labs/ethereum/client';
+import { RegistryContract } from '@aztec-labs/ethereum/contracts';
+import type { L1ContractAddresses } from '@aztec-labs/ethereum/l1-contract-addresses';
+import { getL1ContractsConfig } from '@aztec-labs/ethereum/queries';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+
+export async function getL1Config(
+  registryAddress: EthAddress,
+  l1RpcUrls: string[],
+  l1ChainId: number,
+  rollupVersion: number | 'canonical' = 'canonical',
+): Promise<{ addresses: L1ContractAddresses; config: Awaited<ReturnType<typeof getL1ContractsConfig>> }> {
+  const publicClient = getPublicClient({ l1RpcUrls, l1ChainId });
+  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, rollupVersion);
+
+  const config = await getL1ContractsConfig(publicClient, addresses);
+
+  return {
+    addresses,
+    config,
+  };
+}
+
+export async function getL1RollupAddressFromEnv(l1RpcUrls: string[], l1ChainId: number) {
+  const registryAddress = process.env.REGISTRY_CONTRACT_ADDRESS;
+  if (!registryAddress || !EthAddress.isAddress(registryAddress)) {
+    throw new Error(`Failed to extract registry address`);
+  }
+  const { addresses } = await getL1Config(EthAddress.fromString(registryAddress), l1RpcUrls, l1ChainId);
+  return addresses.rollupAddress;
+}

package/src/config/index.ts

@@ -0,0 +1,4 @@
+export * from './cached_fetch.js';
+export * from './chain_l2_config.js';
+export * from './get_l1_config.js';
+export * from './network_config.js';

package/src/config/network_config.ts

@@ -0,0 +1,150 @@
+import { type NetworkConfig, NetworkConfigMapSchema, type NetworkNames } from '@aztec-labs/foundation/config';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { cachedFetch } from './cached_fetch.js';
+import { enrichEthAddressVar, enrichVar } from './enrich_env.js';
+
+const DEFAULT_CONFIG_URL =
+  'https://raw.githubusercontent.com/AztecProtocol/networks/refs/heads/main/network_config.json';
+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. 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 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> {
+  // Try with the primary URL (env var or default)
+  const configLocation = process.env.NETWORK_CONFIG_LOCATION || DEFAULT_CONFIG_URL;
+
+  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);
+    } else {
+      url = new URL(`file://${configLocation}`);
+    }
+  } catch {
+    /* no-op */
+  }
+
+  if (!url) {
+    return undefined;
+  }
+
+  let rawConfig: any;
+
+  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);
+  }
+
+  if (!rawConfig) {
+    return undefined;
+  }
+
+  const networkConfigMap = NetworkConfigMapSchema.parse(rawConfig);
+  if (networkName in networkConfigMap) {
+    return networkConfigMap[networkName];
+  } else {
+    return undefined;
+  }
+}
+
+/**
+ * Enriches environment variables with remote network configuration.
+ * This function is called before node config initialization to set env vars
+ * 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') {
+    return; // No remote config for local development
+  }
+
+  const cacheDir = process.env.DATA_DIRECTORY ? join(process.env.DATA_DIRECTORY, 'cache') : undefined;
+  const networkConfig = await getNetworkConfig(networkName, cacheDir);
+
+  if (!networkConfig) {
+    return; // Network not found in config, continue without enriching
+  }
+
+  enrichVar('BOOTSTRAP_NODES', networkConfig.bootnodes.join(','));
+  enrichVar('L1_CHAIN_ID', String(networkConfig.l1ChainId));
+  enrichVar('SYNC_SNAPSHOTS_URLS', networkConfig.snapshots.join(','));
+
+  enrichEthAddressVar('REGISTRY_CONTRACT_ADDRESS', networkConfig.registryAddress.toString());
+  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.txCollectionFileStoreUrls?.length) {
+    enrichVar('TX_COLLECTION_FILE_STORE_URLS', networkConfig.txCollectionFileStoreUrls.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

@@ -0,0 +1,203 @@
+import {
+  type ContractArtifact,
+  type FunctionAbi,
+  FunctionType,
+  getAllFunctionAbis,
+  loadContractArtifact,
+} from '@aztec-labs/aztec.js/abi';
+import { EthAddress } from '@aztec-labs/aztec.js/addresses';
+import type { L1ContractsConfig } from '@aztec-labs/ethereum/config';
+import { RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { Operator } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type LogFn, createLogger } from '@aztec-labs/foundation/log';
+import type { NoirPackageConfig } from '@aztec-labs/foundation/noir';
+import { protocolContractsHash } from '@aztec-labs/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.
+ * @param fnName - Function name to be found.
+ * @returns The function's ABI.
+ */
+export function getFunctionAbi(artifact: ContractArtifact, fnName: string): FunctionAbi {
+  const fn = getAllFunctionAbis(artifact).find(({ name }) => name === fnName);
+  if (!fn) {
+    throw Error(`Function ${fnName} not found in contract ABI.`);
+  }
+  return fn;
+}
+
+export async function deployNewRollupContracts(
+  registryAddress: EthAddress,
+  rpcUrls: string[],
+  privateKey: string | undefined,
+  chainId: number,
+  mnemonic: string,
+  mnemonicIndex: number,
+  initialValidators: Operator[],
+  genesisArchiveRoot: Fr,
+  feeJuicePortalInitialBalance: bigint,
+  config: L1ContractsConfig,
+  realVerifier: boolean,
+): Promise<{ rollup: RollupContract }> {
+  const { deployRollupForUpgrade } = await import('@aztec-labs/ethereum/deploy-aztec-l1-contracts');
+  const { mnemonicToAccount, privateKeyToAccount } = await import('viem/accounts');
+  const { getVKTreeRoot } = await import('@aztec-labs/noir-protocol-circuits-types/vk-tree');
+
+  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.
+    const aminAddressString = '0x3b218d0F26d15B36C715cB06c949210a0d630637';
+    const amin = EthAddress.fromString(aminAddressString);
+
+    initialValidators = [
+      {
+        attester: amin,
+        withdrawer: amin,
+        // No secrets here. The actual keys are not currently used.
+        bn254SecretKey: new SecretValue(Fr.fromHexString(aminAddressString).toBigInt()),
+      },
+    ];
+    logger.info('Initializing new rollup with old attesters', { initialValidators });
+  }
+
+  const { rollup } = await deployRollupForUpgrade(privateKey as Hex, rpcUrls[0], chainId, registryAddress, {
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot,
+    initialValidators,
+    feeJuicePortalInitialBalance,
+    realVerifier,
+    ...config,
+  });
+
+  return { rollup };
+}
+
+/**
+ * Gets all contracts available in \@aztec-labs/noir-contracts.js.
+ * @returns The contract names.
+ */
+export async function getExampleContractNames(): Promise<string[]> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { ContractNames } = await import('@aztec-labs/noir-contracts.js');
+  return ContractNames;
+}
+
+/**
+ * Reads a file and converts it to an Aztec Contract ABI.
+ * @param fileDir - The directory of the compiled contract ABI.
+ * @returns The parsed contract artifact.
+ */
+export async function getContractArtifact(fileDir: string, log: LogFn) {
+  // first check if it's a noir-contracts example
+  const allNames = await getExampleContractNames();
+  const contractName = fileDir.replace(/Contract(Artifact)?$/, '');
+  if (allNames.includes(contractName)) {
+    // This can load any generated contract module (noir-contracts.js/src, gitignored), so
+    // depend on all of them — the CI dependency map content-hashes generated files from the
+    // working tree — plus the generator side.
+    // @dependency ../../../noir-contracts.js/src/*.ts, ../../../noir-contracts.js/scripts/generate-types.sh, ../../../noir-contracts.js/package.json
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    const imported = await import(`@aztec-labs/noir-contracts.js/${contractName}`);
+    const artifact = imported[`${contractName}ContractArtifact`] as ContractArtifact;
+    if (!artifact) {
+      throw Error(
+        `Could not import ${contractName}ContractArtifact from @aztec-labs/noir-contracts.js/${contractName}`,
+      );
+    }
+    return artifact;
+  }
+
+  let contents: string;
+  try {
+    contents = await readFile(fileDir, 'utf8');
+  } catch {
+    throw Error(`Contract ${fileDir} not found`);
+  }
+
+  try {
+    return loadContractArtifact(JSON.parse(contents));
+  } catch (err) {
+    log('Invalid file used. Please try again.');
+    throw err;
+  }
+}
+
+/**
+ * Performs necessary checks, conversions & operations to call a contract fn from the CLI.
+ * @param contractFile - Directory of the compiled contract ABI.
+ * @param functionName - Name of the function to be called.
+ * @param _functionArgs - Arguments to call the function with.
+ * @param log - Logger instance that will output to the CLI
+ * @returns Formatted contract address, function arguments and caller's aztec address.
+ */
+export async function prepTx(contractFile: string, functionName: string, _functionArgs: string[], log: LogFn) {
+  const contractArtifact = await getContractArtifact(contractFile, log);
+  const functionArtifact = getFunctionAbi(contractArtifact, functionName);
+  const functionArgs = encodeArgs(_functionArgs, functionArtifact.parameters);
+  const isPrivate = functionArtifact.functionType === FunctionType.PRIVATE;
+
+  return { functionArgs, contractArtifact, isPrivate };
+}
+
+/**
+ * Removes the leading 0x from a hex string. If no leading 0x is found the string is returned unchanged.
+ * @param hex - A hex string
+ * @returns A new string with leading 0x removed
+ */
+export const stripLeadingHex = (hex: string): string => {
+  if (hex.length > 2 && hex.startsWith('0x')) {
+    return hex.substring(2);
+  }
+  return hex;
+};
+
+/**
+ * Adds a leading 0x to a hex string. If a leading 0x is already present the string is returned unchanged.
+ * @param hex - A hex string
+ * @returns A new string with leading 0x added
+ */
+export const addLeadingHex = (hex: string): `0x${string}` => {
+  if (hex.length > 2 && hex.startsWith('0x')) {
+    return hex as `0x${string}`;
+  }
+  return `0x${hex}`;
+};
+
+/*
+ * Pretty prints Nargo.toml contents to a string
+ * @param config - Nargo.toml contents
+ * @returns The Nargo.toml contents as a string
+ */
+export function prettyPrintNargoToml(config: NoirPackageConfig): string {
+  const withoutDependencies = Object.fromEntries(Object.entries(config).filter(([key]) => key !== 'dependencies'));
+
+  const partialToml = TOML.stringify(withoutDependencies);
+  const dependenciesToml = Object.entries(config.dependencies).map(([name, dep]) => {
+    const depToml = TOML.stringify.value(dep);
+    return `${name} = ${depToml}`;
+  });
+
+  return partialToml + '\n[dependencies]\n' + dependenciesToml.join('\n') + '\n';
+}