@aztec/cli 0.0.1-commit.9ef841308 → 0.0.1-commit.a4600f49

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,18 +3,16 @@
 
 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,
   AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_FLAVOR: 'tally',
+  AZTEC_SLASHER_ENABLED: true,
   AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
   AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
   AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
@@ -24,17 +22,21 @@ export const devnetConfig = {
   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,
+  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,
-  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,
@@ -42,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,
@@ -61,7 +69,6 @@ export const devnetConfig = {
   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,
@@ -69,11 +76,13 @@ export const devnetConfig = {
   SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000,
   SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000,
   SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000,
-  SLASH_ATTEST_DESCENDANT_OF_INVALID_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_VERSION_CHECK: true,
+  ENABLE_AUTO_SHUTDOWN: false,
 } as const;
 
 export const testnetConfig = {
@@ -83,25 +92,30 @@ 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_FLAVOR: 'tally',
+  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,
-  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-  SLASH_MAX_PENALTY_PERCENTAGE: 2,
+  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,
-  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,
@@ -109,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,
@@ -119,10 +134,10 @@ export const testnetConfig = {
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
   AZTEC_MANA_TARGET: 75000000,
-  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_PROVING_COST_PER_MANA: 12500000,
   AZTEC_SLASH_AMOUNT_SMALL: 1E+23,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 1E+23,
-  AZTEC_SLASH_AMOUNT_LARGE: 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,
@@ -131,19 +146,20 @@ export const testnetConfig = {
   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_DATA_WITHHOLDING_PENALTY: 0,
   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_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_VERSION_CHECK: true,
+  ENABLE_AUTO_SHUTDOWN: false,
 } as const;
 
 export const mainnetConfig = {
@@ -152,23 +168,23 @@ 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_FLAVOR: 'tally',
+  AZTEC_SLASHER_ENABLED: true,
   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,
+  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,
-  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,
@@ -176,13 +192,14 @@ 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,
   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_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',
@@ -190,7 +207,7 @@ export const mainnetConfig = {
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
   AZTEC_MANA_TARGET: 75000000,
-  AZTEC_PROVING_COST_PER_MANA: 25000000,
+  AZTEC_PROVING_COST_PER_MANA: 12500000,
   AZTEC_EXIT_DELAY_SECONDS: 345600,
   AZTEC_SLASHING_DISABLE_DURATION: 259200,
   AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500,
@@ -209,18 +226,19 @@ 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,
-  SLASH_PRUNE_PENALTY: 0,
+  ENABLE_AUTO_SHUTDOWN: false,
   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_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_GRACE_PERIOD_L2_SLOTS: 1200,
+  SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 2E+21,
+  SLASH_GRACE_PERIOD_L2_SLOTS: 8400,
 } as const;
 

package/src/utils/aztec.ts

@@ -49,7 +49,7 @@ export async function deployNewRollupContracts(
   feeJuicePortalInitialBalance: bigint,
   config: L1ContractsConfig,
   realVerifier: boolean,
-): Promise<{ rollup: RollupContract; slashFactoryAddress: EthAddress }> {
+): Promise<{ rollup: RollupContract }> {
   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');
@@ -80,23 +80,17 @@ export async function deployNewRollupContracts(
     logger.info('Initializing new rollup with old attesters', { initialValidators });
   }
 
-  const { rollup, slashFactoryAddress } = await deployRollupForUpgrade(
-    privateKey as Hex,
-    rpcUrls[0],
-    chainId,
-    registryAddress,
-    {
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractsHash,
-      genesisArchiveRoot,
-      initialValidators,
-      feeJuicePortalInitialBalance,
-      realVerifier,
-      ...config,
-    },
-  );
-
-  return { rollup, slashFactoryAddress: EthAddress.fromString(slashFactoryAddress!) };
+  const { rollup } = await deployRollupForUpgrade(privateKey as Hex, rpcUrls[0], chainId, registryAddress, {
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot,
+    initialValidators,
+    feeJuicePortalInitialBalance,
+    realVerifier,
+    ...config,
+  });
+
+  return { rollup };
 }
 
 /**

package/src/utils/commands.ts

@@ -5,13 +5,15 @@ 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 { LogCursor, Tag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx/tx-hash';
 
 import { type Command, CommanderError, InvalidArgumentError, Option } from 'commander';
 import { lookup } from 'dns/promises';
 import { rename, writeFile } from 'fs/promises';
 
+export { LogCursor };
+
 /**
  * If we can successfully resolve 'host.docker.internal', then we are running in a container, and we should treat
  * localhost as being host.docker.internal.
@@ -99,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}`);
     }
@@ -193,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}`);
   }
@@ -227,16 +229,27 @@ export function parseOptionalAztecAddress(address: string): AztecAddress | undef
 }
 
 /**
- * Parses an optional log ID string into a LogId object.
- *
- * @param logId - The log ID string to parse.
- * @returns The parsed LogId object, or undefined if the log ID is missing or empty.
+ * Parses an optional `<blockNumber>-<txIndexWithinBlock>-<logIndexWithinTx>` triple into a {@link LogCursor},
+ * used as the `--after-log` argument of `get-logs` to resume pagination strictly after a previously-seen log.
+ * Thin wrapper over {@link LogCursor.parseOptional} that surfaces parse errors as commander's
+ * {@link InvalidArgumentError}.
  */
-export function parseOptionalLogId(logId: string): LogId | undefined {
-  if (!logId) {
-    return undefined;
+export function parseOptionalLogCursor(value: string): LogCursor | undefined {
+  try {
+    return LogCursor.parseOptional(value);
+  } catch (err) {
+    throw new InvalidArgumentError(err instanceof Error ? err.message : String(err));
   }
-  return LogId.fromString(logId);
+}
+
+/**
+ * Parses a log tag from a string. Tags are field-element values; we delegate to the {@link parseField} parser.
+ *
+ * @param tag - A hex string, integer, or boolean string representing the tag.
+ * @returns A {@link Tag} wrapping the parsed field.
+ */
+export function parseTag(tag: string): Tag {
+  return new Tag(parseField(tag));
 }
 
 /**

package/src/utils/inspect.ts

@@ -9,14 +9,13 @@ export async function inspectBlock(
   log: LogFn,
   opts: { showTxs?: boolean } = {},
 ) {
-  const block = await aztecNode.getBlock(blockNumber);
+  const block = await aztecNode.getBlock(blockNumber, { includeTransactions: opts.showTxs });
   if (!block) {
     log(`No block found for block number ${blockNumber}`);
     return;
   }
 
-  const blockHash = await block.hash();
-  log(`Block ${blockNumber} (${blockHash.toString()})`);
+  log(`Block ${blockNumber} (${block.hash.toString()})`);
   log(` Total fees: ${block.header.totalFees.toBigInt()}`);
   log(` Total mana used: ${block.header.totalManaUsed.toBigInt()}`);
   log(
@@ -25,12 +24,12 @@ export async function inspectBlock(
   log(` Coinbase: ${block.header.globalVariables.coinbase}`);
   log(` Fee recipient: ${block.header.globalVariables.feeRecipient}`);
   log(` Timestamp: ${new Date(Number(block.header.globalVariables.timestamp) * 500)}`);
-  if (opts.showTxs) {
+  if (opts.showTxs && block.body) {
     log(``);
     for (const txHash of block.body.txEffects.map(tx => tx.txHash)) {
       await inspectTx(aztecNode, txHash, log, { includeBlockInfo: false });
     }
-  } else {
+  } else if (block.body) {
     log(` Transactions: ${block.body.txEffects.length}`);
   }
 }
@@ -41,7 +40,7 @@ export async function inspectTx(
   log: LogFn,
   opts: { includeBlockInfo?: boolean } = {},
 ) {
-  const [receipt, effectsInBlock] = await Promise.all([aztecNode.getTxReceipt(txHash), aztecNode.getTxEffect(txHash)]);
+  const receipt = await aztecNode.getTxReceipt(txHash, { includeTxEffect: true });
   // Base tx data
   log(`Tx ${txHash.toString()}`);
   log(` Status: ${receipt.status}`);
@@ -52,11 +51,11 @@ export async function inspectTx(
     log(` Error: ${receipt.error}`);
   }
 
-  if (!effectsInBlock) {
+  if (!receipt.isMined() || !receipt.txEffect) {
     return;
   }
 
-  const effects = effectsInBlock.data;
+  const effects = receipt.txEffect;
 
   if (opts.includeBlockInfo) {
     log(` Block: ${receipt.blockNumber} (${receipt.blockHash?.toString()})`);