@aztec/cli 0.0.1-commit.ee80a48 → 0.0.1-commit.ef17749e1

package/dest/cmds/infrastructure/setup_l2_contract.d.ts

@@ -1,3 +1,3 @@
 import type { LogFn } from '@aztec/foundation/log';
 export declare function setupL2Contracts(nodeUrl: string, testAccounts: boolean, json: boolean, log: LogFn): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXBfbDJfY29udHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2luZnJhc3RydWN0dXJlL3NldHVwX2wyX2NvbnRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBSW5ELHdCQUFzQixnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxpQkF3QnZHIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dXBfbDJfY29udHJhY3QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2luZnJhc3RydWN0dXJlL3NldHVwX2wyX2NvbnRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBS25ELHdCQUFzQixnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxpQkF3QnZHIn0=

package/dest/cmds/infrastructure/setup_l2_contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup_l2_contract.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/setup_l2_contract.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,iBAwBvG"}
+{"version":3,"file":"setup_l2_contract.d.ts","sourceRoot":"","sources":["../../../src/cmds/infrastructure/setup_l2_contract.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,iBAwBvG"}

package/dest/cmds/infrastructure/setup_l2_contract.js

@@ -2,7 +2,8 @@ import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { createAztecNodeClient } from '@aztec/aztec.js/node';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { deployFundedSchnorrAccounts } from '@aztec/wallets/testing';
 export async function setupL2Contracts(nodeUrl, testAccounts, json, log) {
     const waitOpts = {
         timeout: 180,
@@ -11,7 +12,7 @@ export async function setupL2Contracts(nodeUrl, testAccounts, json, log) {
     log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
     log('setupL2Contracts: Creating PXE client...');
     const node = createAztecNodeClient(nodeUrl);
-    const wallet = await TestWallet.create(node);
+    const wallet = await EmbeddedWallet.create(node);
     let deployedAccountManagers = [];
     if (testAccounts) {
         log('setupL2Contracts: Deploying test accounts...');

package/dest/cmds/l1/index.d.ts

@@ -1,4 +1,4 @@
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import { type Command } from 'commander';
 export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF3QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBdWYvRSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF3QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBK2YvRSJ9

package/dest/cmds/l1/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAwBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAuf/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAwBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WA+f/E"}

package/dest/cmds/l1/index.js

@@ -17,7 +17,7 @@ export function injectCommands(program, log, debugLogger) {
         const initialValidators = options.validators?.split(',').map((validator)=>EthAddress.fromString(validator)) || [];
         await deployNewRollup(options.registryAddress, options.l1RpcUrls, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.testAccounts, options.sponsoredFpc, options.json, initialValidators, options.realVerifier, log);
     });
-    program.command('compute-genesis-values').description('Computes genesis values (VK tree root, protocol contracts hash, genesis archive root).').addOption(new Option('--test-accounts', 'Include initial test accounts in genesis state').env('TEST_ACCOUNTS')).addOption(new Option('--sponsored-fpc', 'Include sponsored FPC contract in genesis state').env('SPONSORED_FPC')).action(async (options)=>{
+    program.command('compute-genesis-values').description('Computes genesis values (VK tree root, protocol contracts hash, genesis archive root).').addOption(new Option('--test-accounts <boolean>', 'Include initial test accounts in genesis state').env('TEST_ACCOUNTS').argParser((arg)=>arg === 'true')).addOption(new Option('--sponsored-fpc <boolean>', 'Include sponsored FPC contract in genesis state').env('SPONSORED_FPC').argParser((arg)=>arg === 'true')).action(async (options)=>{
         const { computeGenesisValuesCmd } = await import('./compute_genesis_values.js');
         await computeGenesisValuesCmd(options.testAccounts, options.sponsoredFpc, log);
     });

package/dest/cmds/l1/update_l1_validators.js

@@ -2,7 +2,7 @@ import { createEthereumChain, isAnvilTestChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client, getPublicClient } from '@aztec/ethereum/client';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { GSEContract, RollupContract } from '@aztec/ethereum/contracts';
-import { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
+import { createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { EthCheatCodes } from '@aztec/ethereum/test';
 import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi, StakingAssetHandlerAbi, TestERC20Abi } from '@aztec/l1-artifacts';
@@ -38,7 +38,7 @@ export async function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, a
     const gseAddress = await rollup.read.getGSE();
     const gse = new GSEContract(l1Client, gseAddress);
     const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client, {
+    const l1TxUtils = createL1TxUtils(l1Client, {
         logger: debugLogger
     });
     const proofParamsObj = ZkPassportProofParams.fromBuffer(proofParams);
@@ -130,7 +130,7 @@ export async function addL1ValidatorViaRollup({ rpcUrls, chainId, privateKey, mn
     const gseAddress = await rollup.read.getGSE();
     const gse = new GSEContract(l1Client, gseAddress);
     const registrationTuple = await gse.makeRegistrationTuple(blsSecretKey);
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client, {
+    const l1TxUtils = createL1TxUtils(l1Client, {
         logger: debugLogger
     });
     const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
@@ -172,7 +172,7 @@ export async function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic
     const account = getAccount(privateKey, mnemonic);
     const chain = createEthereumChain(rpcUrls, chainId);
     const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client, {
+    const l1TxUtils = createL1TxUtils(l1Client, {
         logger: debugLogger
     });
     dualLog(`Removing validator ${validatorAddress.toString()} from rollup ${rollupAddress.toString()}`);
@@ -194,7 +194,7 @@ export async function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, roll
     const account = getAccount(privateKey, mnemonic);
     const chain = createEthereumChain(rpcUrls, chainId);
     const l1Client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
-    const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client, {
+    const l1TxUtils = createL1TxUtils(l1Client, {
         logger: debugLogger
     });
     dualLog(`Trying prune`);

package/dest/config/cached_fetch.d.ts

@@ -1,18 +1,27 @@
 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;
 }
+/** Extracts max-age value in milliseconds from a Response's Cache-Control header. Returns undefined if not present. */
+export declare function parseMaxAge(response: {
+    headers: {
+        get(name: string): string | null;
+    };
+}): number | undefined;
 /**
- * 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 declare function cachedFetch<T = any>(url: string, options: CachedFetchOptions, fetch?: typeof globalThis.fetch, log?: import("@aztec/aztec.js/log").Logger): Promise<T | undefined>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkX2ZldGNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NhY2hlZF9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLHFDQUFxQztJQUNyQyxlQUFlLEVBQUUsTUFBTSxDQUFDO0lBQ3hCLHFCQUFxQjtJQUNyQixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDcEI7QUFFRDs7Ozs7Ozs7O0dBU0c7QUFDSCx3QkFBc0IsV0FBVyxDQUFDLENBQUMsR0FBRyxHQUFHLEVBQ3ZDLEdBQUcsRUFBRSxNQUFNLEVBQ1gsT0FBTyxFQUFFLGtCQUFrQixFQUMzQixLQUFLLDBCQUFtQixFQUN4QixHQUFHLHVDQUErQixHQUNqQyxPQUFPLENBQUMsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxDQXVDeEIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVkX2ZldGNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2NhY2hlZF9mZXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLHNGQUFzRjtJQUN0RixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbkIseUdBQXlHO0lBQ3pHLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUMxQjtBQVVELHVIQUF1SDtBQUN2SCx3QkFBZ0IsV0FBVyxDQUFDLFFBQVEsRUFBRTtJQUFFLE9BQU8sRUFBRTtRQUFFLEdBQUcsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxJQUFJLENBQUE7S0FBRSxDQUFBO0NBQUUsR0FBRyxNQUFNLEdBQUcsU0FBUyxDQVUzRztBQUVEOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILHdCQUFzQixXQUFXLENBQUMsQ0FBQyxHQUFHLEdBQUcsRUFDdkMsR0FBRyxFQUFFLE1BQU0sRUFDWCxPQUFPLEVBQUUsa0JBQWtCLEVBQzNCLEtBQUssMEJBQW1CLEVBQ3hCLEdBQUcsdUNBQStCLEdBQ2pDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLENBb0V4QiJ9

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

@@ -1 +1 @@
-{"version":3,"file":"cached_fetch.d.ts","sourceRoot":"","sources":["../../src/config/cached_fetch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAC3B,KAAK,0BAAmB,EACxB,GAAG,uCAA+B,GACjC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAuCxB"}
+{"version":3,"file":"cached_fetch.d.ts","sourceRoot":"","sources":["../../src/config/cached_fetch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yGAAyG;IACzG,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAUD,uHAAuH;AACvH,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,OAAO,EAAE;QAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;KAAE,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAU3G;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,CAAC,GAAG,GAAG,EACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAC3B,KAAK,0BAAmB,EACxB,GAAG,uCAA+B,GACjC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAoExB"}

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;
@@ -24,12 +24,14 @@ export declare const devnetConfig: {
     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 P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
     readonly SEQ_MIN_TX_PER_BLOCK: 0;
     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 +47,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,8 +55,6 @@ 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: "";
@@ -64,10 +64,13 @@ export declare const devnetConfig: {
     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_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
     readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
     readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 0;
+    readonly ENABLE_VERSION_CHECK: true;
 };
 export declare const testnetConfig: {
     readonly ETHEREUM_SLOT_DURATION: 12;
@@ -78,25 +81,23 @@ 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_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 P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
     readonly SEQ_MIN_TX_PER_BLOCK: 0;
     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;
@@ -113,13 +114,18 @@ 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: 25000000;
+    readonly AZTEC_SLASH_AMOUNT_SMALL: 1e+23;
+    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 1e+23;
+    readonly AZTEC_SLASH_AMOUNT_LARGE: 1e+23;
     readonly L1_CHAIN_ID: 11155111;
     readonly TEST_ACCOUNTS: false;
     readonly SPONSORED_FPC: true;
     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;
@@ -127,14 +133,18 @@ export declare const testnetConfig: {
     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_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 10000000000000000000;
     readonly SLASH_UNKNOWN_PENALTY: 10000000000000000000;
     readonly SLASH_INVALID_BLOCK_PENALTY: 10000000000000000000;
     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;
@@ -146,12 +156,14 @@ export declare const mainnetConfig: {
     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 P2P_ENABLED: true;
     readonly BOOTSTRAP_NODES: "";
     readonly SEQ_MIN_TX_PER_BLOCK: 0;
     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;
@@ -160,10 +172,9 @@ 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;
@@ -173,33 +184,39 @@ export declare const mainnetConfig: {
     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: 25000000;
     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 PUBLIC_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "";
+    readonly PUBLIC_OTEL_COLLECT_FROM: "";
+    readonly ENABLE_VERSION_CHECK: false;
     readonly SLASH_PRUNE_PENALTY: 0;
     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_DUPLICATE_ATTESTATION_PENALTY: 2e+21;
     readonly SLASH_ATTEST_DESCENDANT_OF_INVALID_PENALTY: 2e+21;
     readonly SLASH_UNKNOWN_PENALTY: 2e+21;
     readonly SLASH_INVALID_BLOCK_PENALTY: 2e+21;
     readonly SLASH_GRACE_PERIOD_L2_SLOTS: 1200;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBc0VmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E4RGhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBcUVoQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV0d29ya3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb25maWcvZ2VuZXJhdGVkL25ldHdvcmtzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLGVBQU8sTUFBTSxZQUFZOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBeUVmLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0FvRWhCLENBQUM7QUFFWCxlQUFPLE1BQU0sYUFBYTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E2RWhCLENBQUMifQ==

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEf,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DhB,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEhB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EhB,CAAC"}