@aztec/cli 0.0.1-commit.f2ce05ee → 0.0.1-commit.f5a9928

package/src/config/cached_fetch.ts

@@ -1,24 +1,48 @@
 import { createLogger } from '@aztec/aztec.js/log';
 
-import { mkdir, readFile, stat, writeFile } from 'fs/promises';
+import { mkdir, readFile, writeFile } from 'fs/promises';
 import { dirname } from 'path';
 
 export interface CachedFetchOptions {
-  /** Cache duration in milliseconds */
-  cacheDurationMs: number;
-  /** The cache file */
+  /** The cache file path for storing data. If not provided, no caching is performed. */
   cacheFile?: string;
+  /** Fallback max-age in milliseconds when server sends no Cache-Control header. Defaults to 5 minutes. */
+  defaultMaxAgeMs?: number;
+}
+
+/** Cache metadata stored in a sidecar .meta file alongside the data file. */
+interface CacheMeta {
+  etag?: string;
+  expiresAt: number;
+}
+
+const DEFAULT_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
+
+/** Extracts max-age value in milliseconds from a Response's Cache-Control header. Returns undefined if not present. */
+export function parseMaxAge(response: { headers: { get(name: string): string | null } }): number | undefined {
+  const cacheControl = response.headers.get('cache-control');
+  if (!cacheControl) {
+    return undefined;
+  }
+  const match = cacheControl.match(/max-age=(\d+)/);
+  if (!match) {
+    return undefined;
+  }
+  return parseInt(match[1], 10) * 1000;
 }
 
 /**
- * Fetches data from a URL with file-based caching support.
- * This utility can be used by both remote config and bootnodes fetching.
+ * Fetches data from a URL with file-based HTTP conditional caching.
+ *
+ * Data is stored as raw JSON in the cache file (same format as the server returns).
+ * Caching metadata (ETag, expiry) is stored in a separate sidecar `.meta` file.
+ * This keeps the data file human-readable and backward-compatible with older code.
  *
  * @param url - The URL to fetch from
- * @param networkName - Network name for cache directory structure
- * @param options - Caching and error handling options
- * @param cacheDir - Optional cache directory (defaults to no caching)
- * @returns The fetched and parsed JSON data, or undefined if fetch fails and throwOnError is false
+ * @param options - Caching options
+ * @param fetch - Fetch implementation (defaults to globalThis.fetch)
+ * @param log - Logger instance
+ * @returns The fetched and parsed JSON data, or undefined if fetch fails
  */
 export async function cachedFetch<T = any>(
   url: string,
@@ -26,42 +50,106 @@ export async function cachedFetch<T = any>(
   fetch = globalThis.fetch,
   log = createLogger('cached_fetch'),
 ): Promise<T | undefined> {
-  const { cacheDurationMs, cacheFile } = options;
+  const { cacheFile, defaultMaxAgeMs = DEFAULT_MAX_AGE_MS } = options;
+
+  // If no cacheFile, just fetch normally without caching
+  if (!cacheFile) {
+    return fetchAndParse<T>(url, fetch, log);
+  }
+
+  const metaFile = cacheFile + '.meta';
 
-  // Try to read from cache first
+  // Try to read metadata
+  let meta: CacheMeta | undefined;
   try {
-    if (cacheFile) {
-      const info = await stat(cacheFile);
-      if (info.mtimeMs + cacheDurationMs > Date.now()) {
-        const cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
-        return cachedData;
-      }
-    }
+    meta = JSON.parse(await readFile(metaFile, 'utf-8'));
   } catch {
-    log.trace('Failed to read data from cache');
+    log.trace('No usable cache metadata found');
   }
 
+  // Try to read cached data
+  let cachedData: T | undefined;
   try {
-    const response = await fetch(url);
+    cachedData = JSON.parse(await readFile(cacheFile, 'utf-8'));
+  } catch {
+    log.trace('No usable cached data found');
+  }
+
+  // If metadata and data exist and cache is fresh, return directly
+  if (meta && cachedData !== undefined && meta.expiresAt > Date.now()) {
+    return cachedData;
+  }
+
+  // Cache is stale or missing — make a (possibly conditional) request
+  try {
+    const headers: Record<string, string> = {};
+    if (meta?.etag && cachedData !== undefined) {
+      headers['If-None-Match'] = meta.etag;
+    }
+
+    const response = await fetch(url, { headers });
+
+    if (response.status === 304 && cachedData !== undefined) {
+      // Not modified — recompute expiry from new response headers and return cached data
+      const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
+      await writeMetaFile(metaFile, { etag: meta?.etag, expiresAt: Date.now() + maxAgeMs }, log);
+      return cachedData;
+    }
+
     if (!response.ok) {
       log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
-      return undefined;
+      return cachedData;
     }
 
-    const data = await response.json();
+    // 200 — parse new data and cache it
+    const data = (await response.json()) as T;
+    const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
+    const etag = response.headers.get('etag') ?? undefined;
 
-    try {
-      if (cacheFile) {
-        await mkdir(dirname(cacheFile), { recursive: true });
-        await writeFile(cacheFile, JSON.stringify(data), 'utf-8');
-      }
-    } catch (err) {
-      log.warn('Failed to cache data on disk: ' + cacheFile, { cacheFile, err });
-    }
+    await ensureDir(cacheFile, log);
+    await Promise.all([
+      writeFile(cacheFile, JSON.stringify(data), 'utf-8'),
+      writeFile(metaFile, JSON.stringify({ etag, expiresAt: Date.now() + maxAgeMs }), 'utf-8'),
+    ]);
 
     return data;
+  } catch (err) {
+    log.warn(`Failed to fetch from ${url}`, { err });
+    return cachedData;
+  }
+}
+
+async function fetchAndParse<T>(
+  url: string,
+  fetch: typeof globalThis.fetch,
+  log: ReturnType<typeof createLogger>,
+): Promise<T | undefined> {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      log.warn(`Failed to fetch from ${url}: ${response.status} ${response.statusText}`);
+      return undefined;
+    }
+    return (await response.json()) as T;
   } catch (err) {
     log.warn(`Failed to fetch from ${url}`, { err });
     return undefined;
   }
 }
+
+async function ensureDir(filePath: string, log: ReturnType<typeof createLogger>) {
+  try {
+    await mkdir(dirname(filePath), { recursive: true });
+  } catch (err) {
+    log.warn('Failed to create cache directory for: ' + filePath, { err });
+  }
+}
+
+async function writeMetaFile(metaFile: string, meta: CacheMeta, log: ReturnType<typeof createLogger>) {
+  try {
+    await mkdir(dirname(metaFile), { recursive: true });
+    await writeFile(metaFile, JSON.stringify(meta), 'utf-8');
+  } catch (err) {
+    log.warn('Failed to write cache metadata: ' + metaFile, { err });
+  }
+}

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
  */
@@ -45,8 +55,13 @@ export function enrichEnvironmentWithChainName(networkName: NetworkNames) {
   }
 
   // Apply generated network config from defaults.yml
-  const generatedConfig = NetworkConfigs[networkName];
+  // For devnet iterations (v4-devnet-1, etc.), use the base devnet config
+  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: 36,
-  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,15 +22,16 @@ 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,
   SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
-  SLASH_MAX_PAYLOAD_SIZE: 50,
+  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: 0,
+  SEQ_MIN_TX_PER_BLOCK: 1,
   SEQ_BUILD_CHECKPOINT_IF_EMPTY: true,
+  SEQ_BLOCK_DURATION_MS: 6000,
+  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,
@@ -40,15 +39,21 @@ 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,
   TRANSACTIONS_DISABLED: false,
-  SEQ_MAX_TX_PER_BLOCK: 32,
+  SEQ_MAX_TX_PER_BLOCK: 18,
   PROVER_REAL_PROOFS: false,
   PXE_PROVER_ENABLED: false,
   SYNC_SNAPSHOTS_URLS: '',
@@ -56,22 +61,23 @@ export const devnetConfig = {
   BLOB_ALLOW_EMPTY_SOURCES: false,
   P2P_MAX_PENDING_TX_COUNT: 1000,
   P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false,
-  AUTO_UPDATE: 'none',
-  AUTO_UPDATE_URL: '',
   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_ATTEST_DESCENDANT_OF_INVALID_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 = {
@@ -81,27 +87,25 @@ 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_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,
   AZTEC_SLASHING_DISABLE_DURATION: 432000,
-  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-  SLASH_MIN_PENALTY_PERCENTAGE: 0.5,
-  SLASH_MAX_PENALTY_PERCENTAGE: 2,
   SLASH_OFFENSE_EXPIRATION_ROUNDS: 4,
-  SLASH_MAX_PAYLOAD_SIZE: 50,
+  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: 0,
+  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,
@@ -109,6 +113,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,
@@ -118,47 +123,58 @@ export const testnetConfig = {
   AZTEC_SLASHING_QUORUM: 33,
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100,
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60,
-  AZTEC_MANA_TARGET: 150000000,
+  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: true,
+  SPONSORED_FPC: false,
   TRANSACTIONS_DISABLED: false,
-  SEQ_MAX_TX_PER_BLOCK: 8,
+  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_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_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_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_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: 50,
+  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: 0,
+  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,
@@ -166,48 +182,53 @@ 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_TARGET_COMMITTEE_SIZE: 24,
   AZTEC_ACTIVATION_THRESHOLD: 2E+23,
   AZTEC_EJECTION_THRESHOLD: 1E+23,
-  AZTEC_LOCAL_EJECTION_THRESHOLD: 1.96E+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',
   AZTEC_SLASHING_QUORUM: 65,
   AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600,
   AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000,
-  AZTEC_MANA_TARGET: 0,
-  AZTEC_PROVING_COST_PER_MANA: 0,
+  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: true,
-  SEQ_MAX_TX_PER_BLOCK: 0,
+  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: 0,
+  P2P_MAX_PENDING_TX_COUNT: 1000,
   P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true,
-  AUTO_UPDATE: 'notify',
-  AUTO_UPDATE_URL: 'https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json',
-  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: 'https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics',
-  PUBLIC_OTEL_COLLECT_FROM: 'sequencer',
-  SLASH_PRUNE_PENALTY: 0,
+  PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '',
+  PUBLIC_OTEL_COLLECT_FROM: '',
+  ENABLE_AUTO_SHUTDOWN: false,
   SLASH_DATA_WITHHOLDING_PENALTY: 0,
-  SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8,
+  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: 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/config/network_config.ts

@@ -9,7 +9,6 @@ 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';
-const NETWORK_CONFIG_CACHE_DURATION_MS = 60 * 60 * 1000; // 1 hour
 
 /**
  * Fetches remote network configuration from GitHub with caching support.
@@ -87,7 +86,6 @@ async function fetchNetworkConfigFromUrl(
 
   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:') {
@@ -141,7 +139,13 @@ export async function enrichEnvironmentWithNetworkConfig(networkName: NetworkNam
   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

@@ -3,7 +3,7 @@ import {
   type FunctionAbi,
   FunctionType,
   getAllFunctionAbis,
-  loadContractArtifact,
+  loadContractArtifactWithValidation,
 } from '@aztec/aztec.js/abi';
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import type { L1ContractsConfig } from '@aztec/ethereum/config';
@@ -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 };
 }
 
 /**
@@ -138,7 +132,7 @@ export async function getContractArtifact(fileDir: string, log: LogFn) {
   }
 
   try {
-    return loadContractArtifact(JSON.parse(contents));
+    return loadContractArtifactWithValidation(JSON.parse(contents));
   } catch (err) {
     log('Invalid file used. Please try again.');
     throw err;