@aztec/cli 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/dest/cmds/validator_keys/shared.js

@@ -1,14 +1,59 @@
 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';
+import { EthAddress } from '@aztec/foundation/eth-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';
+// 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) {
+    const result = new Error(error.message);
+    result.name = error.name ?? result.name;
+    result.stack = error.stack;
+    return result;
+}
+function encryptEthJsonV3InWorker(privateKeyHex, password) {
+    return new Promise((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)=>{
+            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, password) {
+    if (process.env.JEST_WORKER_ID !== undefined) {
+        return await new Wallet(privateKeyHex).encrypt(password);
+    }
+    return await encryptEthJsonV3InWorker(privateKeyHex, password);
+}
 export function withValidatorIndex(path, accountIndex = 0, addressIndex = 0) {
     // NOTE: The legacy BLS CLI is to allow users who generated keys in 2.1.4 to be able to use the same command
     // to re-generate their keys. In 2.1.5 we switched how we append addresses to the path so this is to maintain backwards compatibility.
@@ -50,6 +95,22 @@ export function deriveEthAttester(mnemonic, baseAccountIndex, addressIndex, remo
         remoteSignerUrl: remoteSigner
     } : '0x' + Buffer.from(acct.getHdKey().privateKey).toString('hex');
 }
+/**
+ * Resolve a `--funding-account` value into a keystore `EthAccount`. A 66-char value is a private key
+ * (used verbatim). A 42-char value is an address: with an explicit `remoteSigner` URL it becomes an
+ * `{ address, remoteSignerUrl }` pair; without one it is stored as a bare address that falls back to
+ * the keystore-level remote signer at runtime. Callers must validate the value first (see
+ * `validateFundingAccountOptions`).
+ */ export function resolveFundingAccount(fundingAccount, remoteSigner) {
+    if (fundingAccount.length === 66) {
+        return fundingAccount;
+    }
+    const address = EthAddress.fromString(fundingAccount);
+    return remoteSigner ? {
+        address,
+        remoteSignerUrl: remoteSigner
+    } : address;
+}
 export async function buildValidatorEntries(input) {
     const { validatorCount, publisherCount = 0, publishers, accountIndex, baseAddressIndex, mnemonic, ikm, blsPath, feeRecipient, coinbase, remoteSigner } = input;
     const summaries = [];
@@ -188,7 +249,7 @@ export function maybePrintJson(log, jsonFlag, obj) {
     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`);
     await writeFile(outPath, JSON.stringify(keystore, null, 2), {
@@ -197,16 +258,15 @@ export function maybePrintJson(log, jsonFlag, obj) {
     return outPath;
 }
 /** Replace plaintext BLS keys in validators with { path, password } pointing to BN254 keystore files. */ export async function writeBlsBn254ToFile(validators, options) {
-    for(let i = 0; i < validators.length; i++){
-        const v = validators[i];
+    await Promise.all(validators.map(async (v, i)=>{
         if (!v || typeof v !== 'object' || !('attester' in v)) {
-            continue;
+            return;
         }
         const att = v.attester;
         // Shapes: { bls: <hex> } or { eth: <ethAccount>, bls?: <hex> } or plain EthAccount
         const blsKey = typeof att === 'object' && 'bls' in att ? att.bls : undefined;
         if (!blsKey || typeof blsKey !== 'string') {
-            continue;
+            return;
         }
         const pub = await computeBlsPublicKeyCompressed(blsKey);
         const path = options.blsPath ?? defaultBlsPath;
@@ -218,32 +278,50 @@ export function maybePrintJson(log, jsonFlag, obj) {
                 password: options.password
             };
         }
-    }
+    }));
 }
 /** Writes an Ethereum JSON V3 keystore using ethers, returns absolute path */ export async function writeEthJsonV3Keystore(outDir, fileNameBase, password, privateKeyHex) {
     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;
 }
+/**
+ * If `account` is a plaintext ETH private key, encrypt it to a JSON V3 file and return a
+ * { path, password } reference; otherwise return it unchanged.
+ */ async function maybeEncryptEthAccount(account, label, options) {
+    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
+        };
+    }
+    return account;
+}
+/** Encrypt a plaintext funding-account key to a JSON V3 file, replacing it with a { path, password } reference. */ export async function encryptFundingAccountToFile(account, options) {
+    return await maybeEncryptEthAccount(account, 'funding', options);
+}
 /** Replace plaintext ETH keys in validators with { path, password } pointing to JSON V3 files. */ export async function writeEthJsonV3ToFile(validators, options) {
-    const maybeEncryptEth = async (account, label)=>{
+    const tasks = [];
+    const maybeQueueEncryptEth = (account, label, setEncryptedAccount)=>{
         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++){
         const v = validators[i];
@@ -253,22 +331,21 @@ export function maybePrintJson(log, jsonFlag, obj) {
         // attester may be string (eth), object with eth, or remote signer
         const att = v.attester;
         if (typeof att === 'string') {
-            v.attester = await maybeEncryptEth(att, `attester_${i + 1}`);
+            maybeQueueEncryptEth(att, `attester_${i + 1}`, (account)=>v.attester = account);
         } else if (att && typeof att === 'object' && 'eth' in att) {
-            att.eth = await maybeEncryptEth(att.eth, `attester_${i + 1}`);
+            maybeQueueEncryptEth(att.eth, `attester_${i + 1}`, (account)=>att.eth = account);
         }
         // publisher can be single or array
         if ('publisher' in v) {
             const pub = v.publisher;
             if (Array.isArray(pub)) {
-                const out = [];
                 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.publisher = out;
             } else if (pub !== undefined) {
-                v.publisher = await maybeEncryptEth(pub, `publisher_${i + 1}`);
+                maybeQueueEncryptEth(pub, `publisher_${i + 1}`, (account)=>v.publisher = account);
             }
         }
     }
+    await asyncPool(maxEthKeystoreWorkers, tasks, (task)=>task());
 }

package/dest/cmds/validator_keys/utils.d.ts

@@ -1,4 +1,4 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 export declare const defaultBlsPath = "m/12381/3600/0/0/0";
 export declare function validateBlsPathOptions(options: {
     count?: number;
@@ -22,4 +22,14 @@ export declare function validatePublisherOptions(options: {
     publishers?: string[];
     publisherCount?: number;
 }): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL3ZhbGlkYXRvcl9rZXlzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBSWhFLGVBQU8sTUFBTSxjQUFjLHVCQUF1QixDQUFDO0FBRW5ELHdCQUFnQixzQkFBc0IsQ0FBQyxPQUFPLEVBQUU7SUFDOUMsS0FBSyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2YsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN0QixZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLEdBQUcsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNkLFFBV0E7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQ25ELFlBQVksQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUN2QixVQUFVLENBQUMsRUFBRSxVQUFVLENBQUM7SUFDeEIsU0FBUyxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDckIsU0FBUyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ3BCLFFBZUE7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsT0FBTyxFQUFFO0lBQUUsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQUMsUUFBUSxDQUFDLEVBQUUsTUFBTSxDQUFBO0NBQUUsUUFNaEc7QUFFRCx3QkFBZ0Isd0JBQXdCLENBQUMsT0FBTyxFQUFFO0lBQUUsVUFBVSxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFBQyxjQUFjLENBQUMsRUFBRSxNQUFNLENBQUE7Q0FBRSxRQXdCbkcifQ==
+/**
+ * Validates and normalizes the `--funding-account` option in place. The value may be a private key
+ * (used as a local signer) or an ETH address. An address needs a remote signer to sign funding txs:
+ * either `--remote-signer`, or a keystore that already defines one (pass `hasKeystoreRemoteSigner`),
+ * which a bare address inherits at runtime.
+ */
+export declare function validateFundingAccountOptions(options: {
+    fundingAccount?: string;
+    remoteSigner?: string;
+}, hasKeystoreRemoteSigner?: boolean): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL3ZhbGlkYXRvcl9rZXlzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUkzRCxlQUFPLE1BQU0sY0FBYyx1QkFBdUIsQ0FBQztBQUVuRCx3QkFBZ0Isc0JBQXNCLENBQUMsT0FBTyxFQUFFO0lBQzlDLEtBQUssQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNmLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN4QixZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsWUFBWSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLE9BQU8sQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUNqQixHQUFHLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDZCxRQVdBO0FBRUQsd0JBQWdCLDJCQUEyQixDQUFDLE9BQU8sRUFBRTtJQUNuRCxZQUFZLENBQUMsRUFBRSxPQUFPLENBQUM7SUFDdkIsVUFBVSxDQUFDLEVBQUUsVUFBVSxDQUFDO0lBQ3hCLFNBQVMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ3JCLFNBQVMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNwQixRQWVBO0FBRUQsd0JBQWdCLDJCQUEyQixDQUFDLE9BQU8sRUFBRTtJQUFFLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUFDLFFBQVEsQ0FBQyxFQUFFLE1BQU0sQ0FBQTtDQUFFLFFBTWhHO0FBRUQsd0JBQWdCLHdCQUF3QixDQUFDLE9BQU8sRUFBRTtJQUFFLFVBQVUsQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQUMsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFBO0NBQUUsUUF3Qm5HO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsNkJBQTZCLENBQzNDLE9BQU8sRUFBRTtJQUFFLGNBQWMsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUFDLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQTtDQUFFLEVBQzNELHVCQUF1QixVQUFRLFFBaUNoQyJ9

package/dest/cmds/validator_keys/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/cmds/validator_keys/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAIhE,eAAO,MAAM,cAAc,uBAAuB,CAAC;AAEnD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,QAWA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,QAeA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,QAMhG;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,QAwBnG"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/cmds/validator_keys/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAI3D,eAAO,MAAM,cAAc,uBAAuB,CAAC;AAEnD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,QAWA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IACnD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,QAeA;AAED,wBAAgB,2BAA2B,CAAC,OAAO,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,QAMhG;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,QAwBnG;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,EAC3D,uBAAuB,UAAQ,QAiChC"}

package/dest/cmds/validator_keys/utils.js

@@ -1,3 +1,4 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { ethPrivateKeySchema } from '@aztec/node-keystore/schemas';
 export const defaultBlsPath = 'm/12381/3600/0/0/0';
 export function validateBlsPathOptions(options) {
@@ -50,3 +51,36 @@ export function validatePublisherOptions(options) {
         options.publishers = normalizedKeys;
     }
 }
+/**
+ * Validates and normalizes the `--funding-account` option in place. The value may be a private key
+ * (used as a local signer) or an ETH address. An address needs a remote signer to sign funding txs:
+ * either `--remote-signer`, or a keystore that already defines one (pass `hasKeystoreRemoteSigner`),
+ * which a bare address inherits at runtime.
+ */ export function validateFundingAccountOptions(options, hasKeystoreRemoteSigner = false) {
+    if (!options.fundingAccount) {
+        return;
+    }
+    let value = options.fundingAccount.trim();
+    if (!value.startsWith('0x')) {
+        value = '0x' + value;
+    }
+    if (value.length === 66) {
+        try {
+            ethPrivateKeySchema.parse(value);
+        } catch (error) {
+            throw new Error(`Invalid funding account private key: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    } else if (value.length === 42) {
+        try {
+            EthAddress.fromString(value);
+        } catch (error) {
+            throw new Error(`Invalid funding account address: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!options.remoteSigner && !hasKeystoreRemoteSigner) {
+            throw new Error('--funding-account as an address requires --remote-signer, or a keystore that already defines a remote signer');
+        }
+    } else {
+        throw new Error('Invalid funding account: expected a 32-byte private key or a 20-byte address');
+    }
+    options.fundingAccount = value;
+}

package/dest/config/chain_l2_config.d.ts

@@ -1,4 +1,7 @@
 import type { NetworkNames } from '@aztec/foundation/config';
+import { type ConsensusEnvVar } from '@aztec/stdlib/config';
+/** Every generated network config must define every consensus-critical env var. */
+export type ConsensusComplete = Record<ConsensusEnvVar, string | number | boolean>;
 /**
  * Sets up environment for the given network.
  *
@@ -6,9 +9,11 @@ import type { NetworkNames } from '@aztec/foundation/config';
  * 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
  */
 export declare function enrichEnvironmentWithChainName(networkName: NetworkNames): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQTBCN0Q7Ozs7Ozs7Ozs7R0FVRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQXFCdkUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhaW5fbDJfY29uZmlnLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NoYWluX2wyX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUU3RCxPQUFPLEVBQUUsS0FBSyxlQUFlLEVBQThCLE1BQU0sc0JBQXNCLENBQUM7QUFjeEYsbUZBQW1GO0FBQ25GLE1BQU0sTUFBTSxpQkFBaUIsR0FBRyxNQUFNLENBQUMsZUFBZSxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsT0FBTyxDQUFDLENBQUM7QUFpQm5GOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILHdCQUFnQiw4QkFBOEIsQ0FBQyxXQUFXLEVBQUUsWUFBWSxRQXdCdkUifQ==

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,QAqBvE"}
+{"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;AAE7D,OAAO,EAAE,KAAK,eAAe,EAA8B,MAAM,sBAAsB,CAAC;AAcxF,mFAAmF;AACnF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAiBnF;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,YAAY,QAwBvE"}

package/dest/config/chain_l2_config.js

@@ -1,3 +1,5 @@
+import { createLogger } from '@aztec/foundation/log';
+import { checkConsensusEnvOverrides } from '@aztec/stdlib/config';
 import path from 'path';
 import { devnetConfig, mainnetConfig, testnetConfig } from './generated/networks.js';
 const NetworkConfigs = {
@@ -5,6 +7,12 @@ const NetworkConfigs = {
     testnet: testnetConfig,
     mainnet: mainnetConfig
 };
+({
+    devnetConfig,
+    testnetConfig,
+    mainnetConfig
+});
+const log = createLogger('cli:chain_l2_config');
 function enrichEnvironmentWithNetworkConfig(config) {
     for (const [key, value] of Object.entries(config)){
         if (process.env[key] === undefined && value !== undefined) {
@@ -22,7 +30,9 @@ function getDefaultDataDir(networkName) {
  * 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
  */ export function enrichEnvironmentWithChainName(networkName) {
@@ -38,6 +48,9 @@ function getDefaultDataDir(networkName) {
     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);
     }
     // Set DATA_DIRECTORY if not already set

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

@@ -1,12 +1,10 @@
 export declare const devnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
-    readonly AZTEC_SLOT_DURATION: 72;
-    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
     readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
     readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
     readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000;
     readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
-    readonly AZTEC_INBOX_LAG: 1;
+    readonly AZTEC_INBOX_LAG: 2;
     readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
     readonly AZTEC_MANA_TARGET: 100000000;
     readonly AZTEC_PROVING_COST_PER_MANA: 100;
@@ -21,6 +19,11 @@ export declare const devnetConfig: {
     readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
     readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 0;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 0;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 48;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 2;
+    readonly AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 48;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
     readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
@@ -30,7 +33,7 @@ export declare const devnetConfig: {
     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 CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 12;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -38,10 +41,16 @@ export declare const devnetConfig: {
     readonly PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824;
     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 OFFENSE_COLLECTION_ENABLED: true;
+    readonly AZTEC_SLOT_DURATION: 36;
     readonly AZTEC_EPOCH_DURATION: 8;
     readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 1;
     readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 1;
+    readonly AZTEC_TARGET_COMMITTEE_SIZE: 1;
+    readonly MAX_BLOCKS_PER_CHECKPOINT: 4;
     readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 1;
+    readonly AZTEC_SLASHING_QUORUM: 17;
+    readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 151;
     readonly L1_CHAIN_ID: 11155111;
     readonly TEST_ACCOUNTS: true;
     readonly SPONSORED_FPC: true;
@@ -70,7 +79,7 @@ export declare const devnetConfig: {
     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;
+    readonly ENABLE_AUTO_SHUTDOWN: false;
 };
 export declare const testnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
@@ -79,7 +88,7 @@ export declare const testnetConfig: {
     readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
     readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
     readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
-    readonly AZTEC_INBOX_LAG: 1;
+    readonly AZTEC_INBOX_LAG: 2;
     readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
     readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
     readonly AZTEC_SLASHER_ENABLED: true;
@@ -87,6 +96,11 @@ export declare const testnetConfig: {
     readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
     readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
     readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_VALIDATOR_SET_SIZE: 0;
+    readonly AZTEC_ENTRY_QUEUE_BOOTSTRAP_FLUSH_SIZE: 0;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_MIN: 48;
+    readonly AZTEC_ENTRY_QUEUE_FLUSH_SIZE_QUOTIENT: 2;
+    readonly AZTEC_ENTRY_QUEUE_MAX_FLUSH_SIZE: 48;
     readonly SLASH_OFFENSE_EXPIRATION_ROUNDS: 4;
     readonly SLASH_MAX_PAYLOAD_SIZE: 80;
     readonly SLASH_EXECUTE_ROUNDS_LOOK_BACK: 4;
@@ -96,7 +110,8 @@ export declare const testnetConfig: {
     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 MAX_BLOCKS_PER_CHECKPOINT: 10;
+    readonly CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 12;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -104,6 +119,7 @@ export declare const testnetConfig: {
     readonly PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824;
     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 OFFENSE_COLLECTION_ENABLED: true;
     readonly AZTEC_SLOT_DURATION: 72;
     readonly AZTEC_ACTIVATION_THRESHOLD: 2e+23;
     readonly AZTEC_EJECTION_THRESHOLD: 1e+23;
@@ -114,10 +130,10 @@ export declare const testnetConfig: {
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 100;
     readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 60;
     readonly AZTEC_MANA_TARGET: 75000000;
-    readonly AZTEC_PROVING_COST_PER_MANA: 25000000;
+    readonly AZTEC_PROVING_COST_PER_MANA: 12500000;
     readonly AZTEC_SLASH_AMOUNT_SMALL: 1e+23;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 1e+23;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 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: false;
@@ -126,20 +142,20 @@ export declare const testnetConfig: {
     readonly PROVER_REAL_PROOFS: true;
     readonly P2P_MAX_PENDING_TX_COUNT: 1000;
     readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
-    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_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_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;
+    readonly ENABLE_AUTO_SHUTDOWN: false;
 };
 export declare const mainnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
@@ -147,7 +163,7 @@ export declare const mainnetConfig: {
     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_INBOX_LAG: 2;
     readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
     readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
     readonly AZTEC_SLASHER_ENABLED: true;
@@ -162,7 +178,8 @@ export declare const mainnetConfig: {
     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 MAX_BLOCKS_PER_CHECKPOINT: 10;
+    readonly CHECKPOINT_PROPOSAL_SYNC_GRACE_SECONDS: 12;
     readonly DATA_STORE_MAP_SIZE_KB: 134217728;
     readonly ARCHIVER_STORE_MAP_SIZE_KB: 1073741824;
     readonly NOTE_HASH_TREE_MAP_SIZE_KB: 1073741824;
@@ -170,13 +187,14 @@ export declare const mainnetConfig: {
     readonly PUBLIC_DATA_TREE_MAP_SIZE_KB: 1073741824;
     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 OFFENSE_COLLECTION_ENABLED: true;
     readonly AZTEC_SLOT_DURATION: 72;
     readonly AZTEC_ACTIVATION_THRESHOLD: 2e+23;
     readonly AZTEC_EJECTION_THRESHOLD: 1e+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";
@@ -184,7 +202,7 @@ export declare const mainnetConfig: {
     readonly AZTEC_GOVERNANCE_PROPOSER_QUORUM: 600;
     readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 1000;
     readonly AZTEC_MANA_TARGET: 75000000;
-    readonly AZTEC_PROVING_COST_PER_MANA: 25000000;
+    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;
@@ -203,19 +221,19 @@ export declare const mainnetConfig: {
     readonly P2P_TX_POOL_DELETE_TXS_AFTER_REORG: true;
     readonly PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
     readonly PUBLIC_OTEL_COLLECT_FROM: "";
-    readonly ENABLE_VERSION_CHECK: false;
+    readonly ENABLE_AUTO_SHUTDOWN: false;
     readonly SLASH_DATA_WITHHOLDING_PENALTY: 0;
-    readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.8;
+    readonly SLASH_INACTIVITY_TARGET_PERCENTAGE: 0.7;
     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_DUPLICATE_ATTESTATION_PENALTY: 2e+21;
-    readonly SLASH_PROPOSE_DESCENDANT_OF_CHECKPOINT_WITH_INVALID_ATTESTATIONS_PENALTY: 2e+21;
-    readonly SLASH_ATTEST_INVALID_CHECKPOINT_PROPOSAL_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: 0;
-    readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
+    readonly SLASH_INVALID_CHECKPOINT_PROPOSAL_PENALTY: 2e+21;
+    readonly SLASH_GRACE_PERIOD_L2_SLOTS: 8400;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBeUVmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FvRWhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQTRFaEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBa0ZmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBMkVoQixDQUFDO0FBRVgsZUFBTyxNQUFNLGFBQWE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQThFaEIsQ0FBQyJ9

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EhB,CAAC"}
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../../../src/config/generated/networks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EhB,CAAC"}