@aztec/cli 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

package/src/cmds/validator_keys/new.ts

@@ -6,7 +6,7 @@ import type { LogFn } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import { wordlist } from '@scure/bip39/wordlists/english.js';
-import { writeFile } from 'fs/promises';
+import { readFile, writeFile } from 'fs/promises';
 import { basename, dirname, join } from 'path';
 import { createPublicClient, fallback, http } from 'viem';
 import { generateMnemonic, mnemonicToAccount } from 'viem/accounts';
@@ -42,6 +42,11 @@ export type NewValidatorKeystoreOptions = {
   ikm?: string;
   blsPath?: string;
   password?: string;
+  passwordFile?: string;
+  ethPassword?: string;
+  ethPasswordFile?: string;
+  blsPassword?: string;
+  blsPasswordFile?: string;
   encryptedKeystoreDir?: string;
   json?: boolean;
   feeRecipient: AztecAddress;
@@ -53,6 +58,86 @@ export type NewValidatorKeystoreOptions = {
   l1ChainId?: number;
 };
 
+type PasswordSourceOptions = Pick<
+  NewValidatorKeystoreOptions,
+  'password' | 'passwordFile' | 'ethPassword' | 'ethPasswordFile' | 'blsPassword' | 'blsPasswordFile'
+>;
+
+type PasswordSource = {
+  password?: string;
+  passwordFile?: string;
+  passwordOption: string;
+  passwordFileOption: string;
+};
+
+function validatePassword(password: string, source: string): string {
+  if (password.length === 0) {
+    throw new Error(`${source} cannot be empty`);
+  }
+  return password;
+}
+
+function stripOneTrailingNewline(password: string): string {
+  if (password.endsWith('\n')) {
+    password = password.slice(0, -1);
+  }
+  if (password.endsWith('\r')) {
+    password = password.slice(0, -1);
+  }
+  return password;
+}
+
+async function resolvePasswordSource(source: PasswordSource): Promise<string | undefined> {
+  if (source.password !== undefined && source.passwordFile !== undefined) {
+    throw new Error(`${source.passwordOption} and ${source.passwordFileOption} cannot be used together`);
+  }
+  if (source.password !== undefined) {
+    return validatePassword(source.password, source.passwordOption);
+  }
+  if (source.passwordFile !== undefined) {
+    if (source.passwordFile.length === 0) {
+      throw new Error(`${source.passwordFileOption} cannot be empty`);
+    }
+    const password = stripOneTrailingNewline(await readFile(source.passwordFile, 'utf-8'));
+    return validatePassword(password, source.passwordFileOption);
+  }
+
+  return undefined;
+}
+
+async function resolvePasswords(options: PasswordSourceOptions) {
+  const sharedPassword = await resolvePasswordSource({
+    password: options.password,
+    passwordFile: options.passwordFile,
+    passwordOption: '--password',
+    passwordFileOption: '--password-file',
+  });
+  const ethPassword =
+    (await resolvePasswordSource({
+      password: options.ethPassword,
+      passwordFile: options.ethPasswordFile,
+      passwordOption: '--eth-password',
+      passwordFileOption: '--eth-password-file',
+    })) ?? sharedPassword;
+  const blsPassword =
+    (await resolvePasswordSource({
+      password: options.blsPassword,
+      passwordFile: options.blsPasswordFile,
+      passwordOption: '--bls-password',
+      passwordFileOption: '--bls-password-file',
+    })) ?? sharedPassword;
+
+  if (ethPassword === undefined && blsPassword === undefined) {
+    return {};
+  }
+  if (ethPassword === undefined || blsPassword === undefined) {
+    throw new Error(
+      'Both ETH and BLS passwords are required when writing encrypted keystores. Provide --password to use one password for both, or provide both --eth-password and --bls-password.',
+    );
+  }
+  return { ethPassword, blsPassword };
+}
+
 export async function newValidatorKeystore(options: NewValidatorKeystoreOptions, log: LogFn) {
   // validate bls-path inputs before proceeding with key generation
   validateBlsPathOptions(options);
@@ -78,7 +163,12 @@ export async function newValidatorKeystore(options: NewValidatorKeystoreOptions,
     blsPath,
     ikm,
     mnemonic: _mnemonic,
-    password,
+    password: passwordOption,
+    passwordFile,
+    ethPassword: ethPasswordOption,
+    ethPasswordFile,
+    blsPassword: blsPasswordOption,
+    blsPasswordFile,
     encryptedKeystoreDir,
     stakerOutput,
     gseAddress,
@@ -86,9 +176,18 @@ export async function newValidatorKeystore(options: NewValidatorKeystoreOptions,
     l1ChainId,
   } = options;
 
+  const { ethPassword, blsPassword } = await resolvePasswords({
+    password: passwordOption,
+    passwordFile,
+    ethPassword: ethPasswordOption,
+    ethPasswordFile,
+    blsPassword: blsPasswordOption,
+    blsPasswordFile,
+  });
+  const shouldEncryptKeystores = ethPassword !== undefined && blsPassword !== undefined;
   const mnemonic = _mnemonic ?? generateMnemonic(wordlist);
 
-  if (!_mnemonic && !json) {
+  if (!_mnemonic && !json && !shouldEncryptKeystores) {
     log('No mnemonic provided, generating new one...');
     log(`Using new mnemonic:`);
     log('');
@@ -115,11 +214,11 @@ export async function newValidatorKeystore(options: NewValidatorKeystoreOptions,
   });
 
   // If password provided, write ETH JSON V3 and BLS BN254 keystores and replace plaintext
-  if (password !== undefined) {
+  if (shouldEncryptKeystores) {
     const encryptedKeystoreOutDir =
       encryptedKeystoreDir && encryptedKeystoreDir.length > 0 ? encryptedKeystoreDir : keystoreOutDir;
-    await writeEthJsonV3ToFile(validators, { outDir: encryptedKeystoreOutDir, password });
-    await writeBlsBn254ToFile(validators, { outDir: encryptedKeystoreOutDir, password });
+    await writeEthJsonV3ToFile(validators, { outDir: encryptedKeystoreOutDir, password: ethPassword });
+    await writeBlsBn254ToFile(validators, { outDir: encryptedKeystoreOutDir, password: blsPassword });
   }
 
   const keystore = {
@@ -145,7 +244,7 @@ export async function newValidatorKeystore(options: NewValidatorKeystoreOptions,
     // Process each validator
     for (let i = 0; i < validators.length; i++) {
       const validator = validators[i];
-      const outputs = await processAttesterAccounts(validator.attester, gse, password);
+      const outputs = await processAttesterAccounts(validator.attester, gse);
 
       // Collect all staker outputs
       for (let j = 0; j < outputs.length; j++) {
@@ -160,7 +259,7 @@ export async function newValidatorKeystore(options: NewValidatorKeystoreOptions,
     }
   }
 
-  const outputData = !_mnemonic ? { ...keystore, generatedMnemonic: mnemonic } : keystore;
+  const outputData = !_mnemonic && !shouldEncryptKeystores ? { ...keystore, generatedMnemonic: mnemonic } : keystore;
 
   // Handle JSON output
   if (json) {

package/src/cmds/validator_keys/shared.ts

@@ -1,4 +1,5 @@
 import { prettyPrintJSON } from '@aztec/cli/utils';
+import { asyncPool } from '@aztec/foundation/async-pool';
 import { deriveBlsPrivateKey } from '@aztec/foundation/crypto/bls';
 import { createBn254Keystore } from '@aztec/foundation/crypto/bls/bn254_keystore';
 import { computeBn254G1PublicKeyCompressed } from '@aztec/foundation/crypto/bn254';
@@ -10,12 +11,60 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Wallet } from '@ethersproject/wallet';
 import { constants as fsConstants, mkdirSync } from 'fs';
 import { access, writeFile } from 'fs/promises';
-import { homedir } from 'os';
+import { availableParallelism, homedir } from 'os';
 import { dirname, isAbsolute, join } from 'path';
 import { mnemonicToAccount } from 'viem/accounts';
+import { Worker } from 'worker_threads';
 
 import { defaultBlsPath } from './utils.js';
 
+type EthJsonV3WorkerResult = { json: string } | { error: { message: string; name?: string; stack?: string } };
+
+// ethers' default scrypt parameters use substantial memory, so keep worker fan-out bounded.
+const maxEthKeystoreWorkers = Math.max(1, Math.min(4, availableParallelism()));
+
+function deserializeWorkerError(error: { message: string; name?: string; stack?: string }) {
+  const result = new Error(error.message);
+  result.name = error.name ?? result.name;
+  result.stack = error.stack;
+  return result;
+}
+
+function encryptEthJsonV3InWorker(privateKeyHex: string, password: string): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    const worker = new Worker(new URL('./eth_json_v3_worker.js', import.meta.url), {
+      workerData: { privateKeyHex, password },
+    });
+    let settled = false;
+
+    worker.once('message', (result: EthJsonV3WorkerResult) => {
+      settled = true;
+
+      if ('json' in result) {
+        resolve(result.json);
+      } else {
+        reject(deserializeWorkerError(result.error));
+      }
+    });
+    worker.once('error', error => {
+      settled = true;
+      reject(error);
+    });
+    worker.once('exit', code => {
+      if (!settled) {
+        reject(new Error(`ETH JSON V3 worker stopped with exit code ${code}`));
+      }
+    });
+  });
+}
+
+async function encryptEthJsonV3(privateKeyHex: string, password: string): Promise<string> {
+  if (process.env.JEST_WORKER_ID !== undefined) {
+    return await new Wallet(privateKeyHex).encrypt(password);
+  }
+  return await encryptEthJsonV3InWorker(privateKeyHex, password);
+}
+
 export type ValidatorSummary = { attesterEth?: string; attesterBls?: string; publisherEth?: string[] };
 
 export type BuildValidatorsInput = {
@@ -228,7 +277,7 @@ export async function writeBn254BlsKeystore(
 ): Promise<string> {
   mkdirSync(outDir, { recursive: true });
 
-  const keystore = createBn254Keystore(password, privateKeyHex, pubkeyHex, derivationPath);
+  const keystore = await createBn254Keystore(password, privateKeyHex, pubkeyHex, derivationPath);
 
   const safeBase = fileNameBase.replace(/[^a-zA-Z0-9_-]/g, '_');
   const outPath = join(outDir, `keystore-${safeBase}.json`);
@@ -241,28 +290,29 @@ export async function writeBlsBn254ToFile(
   validators: ValidatorKeyStore[],
   options: { outDir: string; password: string; blsPath?: string },
 ): Promise<void> {
-  for (let i = 0; i < validators.length; i++) {
-    const v = validators[i];
-    if (!v || typeof v !== 'object' || !('attester' in v)) {
-      continue;
-    }
-    const att = (v as any).attester;
+  await Promise.all(
+    validators.map(async (v, i) => {
+      if (!v || typeof v !== 'object' || !('attester' in v)) {
+        return;
+      }
+      const att = (v as any).attester;
 
-    // Shapes: { bls: <hex> } or { eth: <ethAccount>, bls?: <hex> } or plain EthAccount
-    const blsKey: string | undefined = typeof att === 'object' && 'bls' in att ? (att as any).bls : undefined;
-    if (!blsKey || typeof blsKey !== 'string') {
-      continue;
-    }
+      // Shapes: { bls: <hex> } or { eth: <ethAccount>, bls?: <hex> } or plain EthAccount
+      const blsKey: string | undefined = typeof att === 'object' && 'bls' in att ? (att as any).bls : undefined;
+      if (!blsKey || typeof blsKey !== 'string') {
+        return;
+      }
 
-    const pub = await computeBlsPublicKeyCompressed(blsKey);
-    const path = options.blsPath ?? defaultBlsPath;
-    const fileBase = `${String(i + 1)}_${pub.slice(2, 18)}`;
-    const keystorePath = await writeBn254BlsKeystore(options.outDir, fileBase, options.password, blsKey, pub, path);
+      const pub = await computeBlsPublicKeyCompressed(blsKey);
+      const path = options.blsPath ?? defaultBlsPath;
+      const fileBase = `${String(i + 1)}_${pub.slice(2, 18)}`;
+      const keystorePath = await writeBn254BlsKeystore(options.outDir, fileBase, options.password, blsKey, pub, path);
 
-    if (typeof att === 'object') {
-      (att as any).bls = { path: keystorePath, password: options.password };
-    }
-  }
+      if (typeof att === 'object') {
+        (att as any).bls = { path: keystorePath, password: options.password };
+      }
+    }),
+  );
 }
 
 /** Writes an Ethereum JSON V3 keystore using ethers, returns absolute path */
@@ -274,8 +324,7 @@ export async function writeEthJsonV3Keystore(
 ): Promise<string> {
   const safeBase = fileNameBase.replace(/[^a-zA-Z0-9_-]/g, '_');
   mkdirSync(outDir, { recursive: true });
-  const wallet = new Wallet(privateKeyHex);
-  const json = await wallet.encrypt(password);
+  const json = await encryptEthJsonV3(privateKeyHex, password);
   const outPath = join(outDir, `keystore-eth-${safeBase}.json`);
   await writeFile(outPath, json, { encoding: 'utf-8' });
   return outPath;
@@ -286,13 +335,16 @@ export async function writeEthJsonV3ToFile(
   validators: ValidatorKeyStore[],
   options: { outDir: string; password: string },
 ): Promise<void> {
-  const maybeEncryptEth = async (account: any, label: string) => {
+  const tasks: (() => Promise<void>)[] = [];
+
+  const maybeQueueEncryptEth = (account: any, label: string, setEncryptedAccount: (account: any) => void) => {
     if (typeof account === 'string' && account.startsWith('0x') && account.length === 66) {
-      const fileBase = `${label}_${account.slice(2, 10)}`;
-      const p = await writeEthJsonV3Keystore(options.outDir, fileBase, options.password, account);
-      return { path: p, password: options.password };
+      tasks.push(async () => {
+        const fileBase = `${label}_${account.slice(2, 10)}`;
+        const path = await writeEthJsonV3Keystore(options.outDir, fileBase, options.password, account);
+        setEncryptedAccount({ path, password: options.password });
+      });
     }
-    return account;
   };
 
   for (let i = 0; i < validators.length; i++) {
@@ -304,23 +356,23 @@ export async function writeEthJsonV3ToFile(
     // attester may be string (eth), object with eth, or remote signer
     const att = (v as any).attester;
     if (typeof att === 'string') {
-      (v as any).attester = await maybeEncryptEth(att, `attester_${i + 1}`);
+      maybeQueueEncryptEth(att, `attester_${i + 1}`, account => ((v as any).attester = account));
     } else if (att && typeof att === 'object' && 'eth' in att) {
-      (att as any).eth = await maybeEncryptEth((att as any).eth, `attester_${i + 1}`);
+      maybeQueueEncryptEth((att as any).eth, `attester_${i + 1}`, account => ((att as any).eth = account));
     }
 
     // publisher can be single or array
     if ('publisher' in v) {
       const pub = (v as any).publisher;
       if (Array.isArray(pub)) {
-        const out: any[] = [];
         for (let j = 0; j < pub.length; j++) {
-          out.push(await maybeEncryptEth(pub[j], `publisher_${i + 1}_${j + 1}`));
+          maybeQueueEncryptEth(pub[j], `publisher_${i + 1}_${j + 1}`, account => (pub[j] = account));
         }
-        (v as any).publisher = out;
       } else if (pub !== undefined) {
-        (v as any).publisher = await maybeEncryptEth(pub, `publisher_${i + 1}`);
+        maybeQueueEncryptEth(pub, `publisher_${i + 1}`, account => ((v as any).publisher = account));
       }
     }
   }
+
+  await asyncPool(maxEthKeystoreWorkers, tasks, task => task());
 }

package/src/config/chain_l2_config.ts

@@ -1,4 +1,6 @@
 import type { NetworkNames } from '@aztec/foundation/config';
+import { createLogger } from '@aztec/foundation/log';
+import { type ConsensusEnvVar, checkConsensusEnvOverrides } from '@aztec/stdlib/config';
 
 import path from 'path';
 
@@ -12,6 +14,12 @@ const NetworkConfigs: Partial<Record<NetworkNames, NetworkConfigEnv>> = {
   mainnet: mainnetConfig,
 };
 
+/** Every generated network config must define every consensus-critical env var. */
+export type ConsensusComplete = Record<ConsensusEnvVar, string | number | boolean>;
+({ devnetConfig, testnetConfig, mainnetConfig }) satisfies Record<string, ConsensusComplete>;
+
+const log = createLogger('cli:chain_l2_config');
+
 function enrichEnvironmentWithNetworkConfig(config: NetworkConfigEnv): void {
   for (const [key, value] of Object.entries(config)) {
     if (process.env[key] === undefined && value !== undefined) {
@@ -31,7 +39,9 @@ function getDefaultDataDir(networkName: NetworkNames): string {
  * and DefaultSlasherConfig (which match the 'defaults' section of defaults.yml).
  *
  * For deployed networks: applies network configuration from generated defaults.yml,
- * merging base defaults with network-specific overrides.
+ * merging base defaults with network-specific overrides. Before merging, enforces that operators have not
+ * overridden any consensus-critical env var with a value diverging from the network config (throwing unless
+ * ALLOW_OVERRIDING_NETWORK_CONFIG is set), so all nodes of a network agree on consensus-critical values.
  *
  * @param networkName - The network name
  */
@@ -49,6 +59,9 @@ export function enrichEnvironmentWithChainName(networkName: NetworkNames) {
   const configKey = /^v\d+-devnet-\d+$/.test(networkName) ? 'devnet' : networkName;
   const generatedConfig = NetworkConfigs[configKey];
   if (generatedConfig) {
+    // The check is pure; this layer owns env mutation, so apply its canonical writes before enriching.
+    const canonical = checkConsensusEnvOverrides(generatedConfig, process.env, msg => log.warn(msg));
+    Object.assign(process.env, canonical);
     enrichEnvironmentWithNetworkConfig(generatedConfig);
   }
 

package/src/config/generated/networks.ts

@@ -3,13 +3,11 @@
 
 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_INBOX_LAG: 2,
   AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
   AZTEC_MANA_TARGET: 100000000,
   AZTEC_PROVING_COST_PER_MANA: 100,
@@ -24,6 +22,11 @@ export const devnetConfig = {
   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,
@@ -33,7 +36,7 @@ export const devnetConfig = {
   SEQ_MIN_TX_PER_BLOCK: 1,
   SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
   SEQ_BLOCK_DURATION_MS: 6000,
-  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  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,
@@ -41,10 +44,16 @@ export const devnetConfig = {
   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,
+  MAX_BLOCKS_PER_CHECKPOINT: 4,
   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,
@@ -73,7 +82,7 @@ export const devnetConfig = {
   SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000,
   SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0,
   SLASH_GRACE_PERIOD_L2_SLOTS: 0,
-  ENABLE_VERSION_CHECK: true,
+  ENABLE_AUTO_SHUTDOWN: false,
 } as const;
 
 export const testnetConfig = {
@@ -83,7 +92,7 @@ export const testnetConfig = {
   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_INBOX_LAG: 2,
   AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
   AZTEC_SLASHER_ENABLED: true,
@@ -91,6 +100,11 @@ export const testnetConfig = {
   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,
@@ -100,7 +114,8 @@ export const testnetConfig = {
   SEQ_MIN_TX_PER_BLOCK: 1,
   SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
   SEQ_BLOCK_DURATION_MS: 6000,
-  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  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,
@@ -108,6 +123,7 @@ export const testnetConfig = {
   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,
@@ -143,7 +159,7 @@ export const testnetConfig = {
   SLASH_INVALID_BLOCK_PENALTY: 1E+23,
   SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 1E+23,
   SLASH_GRACE_PERIOD_L2_SLOTS: 64,
-  ENABLE_VERSION_CHECK: true,
+  ENABLE_AUTO_SHUTDOWN: false,
 } as const;
 
 export const mainnetConfig = {
@@ -152,7 +168,7 @@ export const mainnetConfig = {
   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_INBOX_LAG: 2,
   AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
   AZTEC_SLASHER_ENABLED: true,
@@ -167,7 +183,8 @@ export const mainnetConfig = {
   SEQ_MIN_TX_PER_BLOCK: 1,
   SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
   SEQ_BLOCK_DURATION_MS: 6000,
-  SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36,
+  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,
@@ -175,6 +192,7 @@ export const mainnetConfig = {
   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,
@@ -208,7 +226,7 @@ export const mainnetConfig = {
   P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
   PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
   PUBLIC_OTEL_COLLECT_FROM: '',
-  ENABLE_VERSION_CHECK: false,
+  ENABLE_AUTO_SHUTDOWN: false,
   SLASH_DATA_WITHHOLDING_PENALTY: 0,
   SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
   SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2,

package/src/utils/commands.ts

@@ -101,7 +101,7 @@ export async function getTxSender(pxe: PXE, _from?: string) {
   let from: AztecAddress;
   if (_from) {
     try {
-      from = AztecAddress.fromString(_from);
+      from = AztecAddress.fromStringUnsafe(_from);
     } catch {
       throw new InvalidArgumentError(`Invalid option 'from' passed: ${_from}`);
     }
@@ -195,7 +195,7 @@ export function parseFieldFromHexString(str: string): Fr {
  */
 export function parseAztecAddress(address: string): AztecAddress {
   try {
-    return AztecAddress.fromString(address);
+    return AztecAddress.fromStringUnsafe(address);
   } catch {
     throw new InvalidArgumentError(`Invalid Aztec address: ${address}`);
   }