@aztec/cli 0.0.1-commit.e558bd1c → 0.0.1-commit.e57c76e

package/dest/config/cached_fetch.js

@@ -1,50 +1,105 @@
 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';
+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) {
+    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(url, options, fetch = globalThis.fetch, log = createLogger('cached_fetch')) {
-    const { cacheDurationMs, cacheFile } = options;
-    // Try to read from cache first
+    const { cacheFile, defaultMaxAgeMs = DEFAULT_MAX_AGE_MS } = options;
+    // If no cacheFile, just fetch normally without caching
+    if (!cacheFile) {
+        return fetchAndParse(url, fetch, log);
+    }
+    const metaFile = cacheFile + '.meta';
+    // Try to read metadata
+    let meta;
     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;
     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 = {};
+        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;
         }
+        // 200 — parse new data and cache it
         const data = await response.json();
-        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
-            });
-        }
+        const maxAgeMs = parseMaxAge(response) ?? defaultMaxAgeMs;
+        const etag = response.headers.get('etag') ?? undefined;
+        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(url, fetch, log) {
+    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();
     } catch (err) {
         log.warn(`Failed to fetch from ${url}`, {
             err
@@ -52,3 +107,26 @@ import { dirname } from 'path';
         return undefined;
     }
 }
+async function ensureDir(filePath, log) {
+    try {
+        await mkdir(dirname(filePath), {
+            recursive: true
+        });
+    } catch (err) {
+        log.warn('Failed to create cache directory for: ' + filePath, {
+            err
+        });
+    }
+}
+async function writeMetaFile(metaFile, meta, log) {
+    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/dest/config/chain_l2_config.d.ts

@@ -11,4 +11,4 @@ import type { NetworkNames } from '@aztec/foundation/config';
  * @param networkName - The network name
  */
 export declare function enrichEnvironmentWithChainName(networkName: NetworkNames): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQTBCN0Q7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQW1CdkUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQTBCN0Q7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQXFCdkUifQ==

package/dest/config/chain_l2_config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/config/chain_l2_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA0B7D;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,YAAY,QAmBvE"}
+{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/config/chain_l2_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA0B7D;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,YAAY,QAqBvE"}

package/dest/config/chain_l2_config.js

@@ -34,7 +34,9 @@ function getDefaultDataDir(networkName) {
         return;
     }
     // 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) {
         enrichEnvironmentWithNetworkConfig(generatedConfig);
     }

package/dest/config/generated/networks.d.ts

@@ -1,6 +1,6 @@
 export declare const devnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
-    readonly AZTEC_SLOT_DURATION: 36;
+    readonly AZTEC_SLOT_DURATION: 72;
     readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
     readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
     readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
@@ -11,7 +11,7 @@ export declare const devnetConfig: {
     readonly AZTEC_MANA_TARGET: 100000000;
     readonly AZTEC_PROVING_COST_PER_MANA: 100;
     readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_FLAVOR: "tally";
+    readonly AZTEC_SLASHER_ENABLED: true;
     readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
     readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
     readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
@@ -21,15 +21,16 @@ export declare const devnetConfig: {
     readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
     readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
-    readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
-    readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
-    readonly SLASH_MAX_PAYLOAD_SIZE: 50;
+    readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
+    readonly SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3;
     readonly P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
-    readonly SEQ_MIN_TX_PER_BLOCK: 0;
+    readonly SEQ_MIN_TX_PER_BLOCK: 1;
     readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
+    readonly SEQ_BLOCK_DURATION_MS: 6000;
+    readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -45,7 +46,7 @@ export declare const devnetConfig: {
     readonly TEST_ACCOUNTS: true;
     readonly SPONSORED_FPC: true;
     readonly TRANSACTIONS_DISABLED: false;
-    readonly SEQ_MAX_TX_PER_BLOCK: 32;
+    readonly SEQ_MAX_TX_PER_BLOCK: 18;
     readonly PROVER_REAL_PROOFS: false;
     readonly PXE_PROVER_ENABLED: false;
     readonly SYNC_SNAPSHOTS_URLS: "";
@@ -53,22 +54,23 @@ export declare const devnetConfig: {
     readonly BLOB_ALLOW_EMPTY_SOURCES: false;
     readonly P2P_MAX_PENDING_TX_COUNT: 1000;
     readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: false;
-    readonly AUTO_UPDATE: "none";
-    readonly AUTO_UPDATE_URL: "";
     readonly PUBLIC_OTEL_OPT_OUT: true;
     readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
     readonly PUBLIC_OTEL_COLLECT_FROM: "";
-    readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
     readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
     readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9;
     readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1;
     readonly SLASH_INACTIVITY_PENALTY: 10000000000000000000;
     readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
     readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000;
-    readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
+    readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 10000000000000000000;
+    readonly SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
+    readonly SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 10000000000000000000;
     readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
     readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
+    readonly SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
+    readonly ENABLE_VERSION_CHECK: true;
 };
 export declare const testnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
@@ -79,25 +81,22 @@ export declare const testnetConfig: {
     readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
     readonly AZTEC_INBOX_LAG: 1;
     readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
-    readonly AZTEC_PROVING_COST_PER_MANA: 100;
     readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_FLAVOR: "tally";
+    readonly AZTEC_SLASHER_ENABLED: true;
     readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
     readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
     readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
     readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
-    readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
-    readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
-    readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
-    readonly SLASH_MAX_PAYLOAD_SIZE: 50;
+    readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
+    readonly SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3;
     readonly P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
-    readonly SEQ_MIN_TX_PER_BLOCK: 0;
+    readonly SEQ_MIN_TX_PER_BLOCK: 1;
     readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
+    readonly SEQ_BLOCK_DURATION_MS: 6000;
+    readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -114,46 +113,56 @@ export declare const testnetConfig: {
     readonly AZTEC_SLASHING_QUORUM: 33;
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100;
     readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60;
-    readonly AZTEC_MANA_TARGET: 150000000;
+    readonly AZTEC_MANA_TARGET: 75000000;
+    readonly AZTEC_PROVING_COST_PER_MANA: 12500000;
+    readonly AZTEC_SLASH_AMOUNT_SMALL: 1e+23;
+    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 2.5e+23;
+    readonly AZTEC_SLASH_AMOUNT_LARGE: 2.5e+23;
     readonly L1_CHAIN_ID: 11155111;
     readonly TEST_ACCOUNTS: false;
-    readonly SPONSORED_FPC: true;
+    readonly SPONSORED_FPC: false;
     readonly TRANSACTIONS_DISABLED: false;
-    readonly SEQ_MAX_TX_PER_BLOCK: 8;
+    readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
     readonly PROVER_REAL_PROOFS: true;
+    readonly P2P_MAX_PENDING_TX_COUNT: 1000;
     readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
-    readonly SLASH_PRUNE_PENALTY: 10000000000000000000;
-    readonly SLASH_DATA_WITHHOLDING_PENALTY: 10000000000000000000;
+    readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
     readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.9;
     readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 1;
-    readonly SLASH_INACTIVITY_PENALTY: 10000000000000000000;
-    readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 10000000000000000000;
-    readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 10000000000000000000;
-    readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
-    readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
-    readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
+    readonly SLASH_INACTIVITY_PENALTY: 1e+23;
+    readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 1e+23;
+    readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 2.5e+23;
+    readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 2.5e+23;
+    readonly SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0;
+    readonly SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0;
+    readonly SLASH_UNKNOWN_PENALTY: 1e+23;
+    readonly SLASH_INVALID_BLOCK_PENALTY: 1e+23;
+    readonly SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 1e+23;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 64;
+    readonly ENABLE_VERSION_CHECK: true;
 };
 export declare const mainnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
     readonly AZTEC_EPOCH_DURATION: 32;
+    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
     readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
     readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
     readonly AZTEC_INBOX_LAG: 1;
     readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
     readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_FLAVOR: "tally";
+    readonly AZTEC_SLASHER_ENABLED: true;
     readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
     readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
-    readonly SLASH_MIN_PENALTY_PERCENTAGE: 0.5;
-    readonly SLASH_MAX_PENALTY_PERCENTAGE: 2;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
-    readonly SLASH_MAX_PAYLOAD_SIZE: 50;
+    readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
+    readonly SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS: 3;
     readonly P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
-    readonly SEQ_MIN_TX_PER_BLOCK: 0;
+    readonly SEQ_MIN_TX_PER_BLOCK: 1;
     readonly SEQ_BUILD_CHECKPOINT_IF_EMPTY: true;
+    readonly SEQ_BLOCK_DURATION_MS: 6000;
+    readonly SEQ_L1_PUBLISHING_TIME_ALLOWANCE_IN_SLOT: 36;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -162,47 +171,51 @@ export declare const mainnetConfig: {
     readonly PUBLIC_OTEL_INCLUDE_METRICS: "aztec.validator,aztec.tx_collector,aztec.mempool,aztec.p2p.gossip.agg_,aztec.ivc_verifier.agg_";
     readonly SENTINEL_ENABLED: true;
     readonly AZTEC_SLOT_DURATION: 72;
-    readonly AZTEC_TARGET_COMMITTEE_SIZE: 24;
     readonly AZTEC_ACTIVATION_THRESHOLD: 2e+23;
     readonly AZTEC_EJECTION_THRESHOLD: 1e+23;
-    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.96e+23;
+    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 1.9e+23;
     readonly AZTEC_SLASH_AMOUNT_SMALL: 2e+21;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 2e+21;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 2e+21;
+    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 5e+21;
+    readonly AZTEC_SLASH_AMOUNT_LARGE: 5e+21;
     readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 34;
     readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 28;
     readonly AZTEC_SLASHING_VETOER: "0xBbB4aF368d02827945748b28CD4b2D42e4A37480";
     readonly AZTEC_SLASHING_QUORUM: 65;
     readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600;
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000;
-    readonly AZTEC_MANA_TARGET: 0;
-    readonly AZTEC_PROVING_COST_PER_MANA: 0;
+    readonly AZTEC_MANA_TARGET: 75000000;
+    readonly AZTEC_PROVING_COST_PER_MANA: 12500000;
     readonly AZTEC_EXIT_DELAY_SECONDS: 345600;
     readonly AZTEC_SLASHING_DISABLE_DURATION: 259200;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 500;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 500;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 1;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 400;
+    readonly AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 4;
     readonly L1_CHAIN_ID: 1;
     readonly TEST_ACCOUNTS: false;
     readonly SPONSORED_FPC: false;
-    readonly TRANSACTIONS_DISABLED: true;
-    readonly SEQ_MAX_TX_PER_BLOCK: 0;
+    readonly TRANSACTIONS_DISABLED: false;
+    readonly SEQ_MAX_TX_PER_CHECKPOINT: 72;
     readonly PROVER_REAL_PROOFS: true;
-    readonly SYNC_SNAPSHOTS_URLS: "https://aztec-labs-snapshots.com/mainnet/";
     readonly BLOB_ALLOW_EMPTY_SOURCES: true;
-    readonly P2P_MAX_PENDING_TX_COUNT: 0;
+    readonly P2P_MAX_PENDING_TX_COUNT: 1000;
     readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
-    readonly AUTO_UPDATE: "notify";
-    readonly AUTO_UPDATE_URL: "https://storage.googleapis.com/aztec-mainnet/auto-update/mainnet.json";
-    readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "https://telemetry.alpha-testnet.aztec-labs.com/v1/metrics";
-    readonly PUBLIC_OTEL_COLLECT_FROM: "sequencer";
-    readonly SLASH_PRUNE_PENALTY: 0;
+    readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
+    readonly PUBLIC_OTEL_COLLECT_FROM: "";
+    readonly ENABLE_VERSION_CHECK: false;
     readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
     readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8;
     readonly SLASH_INACTIVITY_CONSECUTIVE_EPOCH_THRESHOLD: 2;
     readonly SLASH_INACTIVITY_PENALTY: 2e+21;
     readonly SLASH_PROPOSE_INVALID_ATTESTATIONS_PENALTY: 2e+21;
-    readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 2e+21;
-    readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2e+21;
+    readonly SLASH_DUPLICATE_PROPOSAL_PENALTY: 5e+21;
+    readonly SLASH_DUPLICATE_ATTESTATION_PENALTY: 5e+21;
+    readonly SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 0;
+    readonly SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 0;
     readonly SLASH_UNKNOWN_PENALTY: 2e+21;
     readonly SLASH_INVALID_BLOCK_PENALTY: 2e+21;
+    readonly SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 2e+21;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXVFZixDQUFDO0FBRVgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQStEaEIsQ0FBQztBQUVYLGVBQU8sTUFBTSxhQUFhOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBc0VoQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBeUVmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FvRWhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQTRFaEIsQ0FBQyJ9

package/dest/config/generated/networks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/config/generated/networks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEhB,CAAC"}
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/config/generated/networks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EhB,CAAC"}