@aztec/aztec 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/{sandbox/sandbox.ts → local-network/local-network.ts}

@@ -1,37 +1,33 @@
 #!/usr/bin/env -S node --no-warnings
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
-import { type AztecNodeConfig, AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js';
-import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
-import { setupSponsoredFPC } from '@aztec/cli/cli-utils';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecNodeService } from '@aztec/aztec-node';
+import { type AztecNodeConfig, getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { type BlobClientInterface, createBlobClient } from '@aztec/blob-client/client';
 import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
-import {
-  NULL_KEY,
-  createEthereumChain,
-  deployL1Contracts,
-  deployMulticall3,
-  getL1ContractsConfigEnvVars,
-  waitForPublicClient,
-} from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { waitForPublicClient } from '@aztec/ethereum/client';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { NULL_KEY } from '@aztec/ethereum/constants';
+import { deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import { EthCheatCodes } from '@aztec/ethereum/test';
 import { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
-import { type LogFn, createLogger } from '@aztec/foundation/log';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
 import { DateProvider, TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { type PXEServiceConfig, createPXEService, getPXEServiceConfig } from '@aztec/pxe/server';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import {
   type TelemetryClient,
   getConfigEnvVars as getTelemetryClientConfig,
   initTelemetryClient,
 } from '@aztec/telemetry-client';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { type HDAccount, type PrivateKeyAccount, createPublicClient, fallback, http as httpViemTransport } from 'viem';
+import { type Hex, createPublicClient, fallback, http as httpViemTransport } from 'viem';
 import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
@@ -41,53 +37,37 @@ import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 
-const logger = createLogger('sandbox');
+const logger = createLogger('local-network');
 
 const localAnvil = foundry;
 
 /**
- * Function to deploy our L1 contracts to the sandbox L1
+ * Function to deploy our L1 contracts to the local network L1
  * @param aztecNodeConfig - The Aztec Node Config
  * @param hdAccount - Account for publishing L1 contracts
  */
 export async function deployContractsToL1(
   aztecNodeConfig: AztecNodeConfig,
-  hdAccount: HDAccount | PrivateKeyAccount,
-  contractDeployLogger = logger,
+  privateKey: Hex,
   opts: {
     assumeProvenThroughBlockNumber?: number;
-    salt?: number;
     genesisArchiveRoot?: Fr;
     feeJuicePortalInitialBalance?: bigint;
   } = {},
 ) {
-  const chain =
-    aztecNodeConfig.l1RpcUrls.length > 0
-      ? createEthereumChain(aztecNodeConfig.l1RpcUrls, aztecNodeConfig.l1ChainId)
-      : { chainInfo: localAnvil };
-
   await waitForPublicClient(aztecNodeConfig);
 
-  const l1Contracts = await deployL1Contracts(
-    aztecNodeConfig.l1RpcUrls,
-    hdAccount,
-    chain.chainInfo,
-    contractDeployLogger,
-    {
-      ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
-      ...aztecNodeConfig,
-      vkTreeRoot: getVKTreeRoot(),
-      protocolContractTreeRoot,
-      genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-      salt: opts.salt,
-      feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
-      aztecTargetCommitteeSize: 0, // no committee in sandbox
-      slasherFlavor: 'none', // no slashing in sandbox
-      realVerifier: false,
-    },
-  );
-
-  await deployMulticall3(l1Contracts.l1Client, logger);
+  const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
+    ...getL1ContractsConfigEnvVars(), // TODO: We should not need to be loading config from env again, caller should handle this
+    ...aztecNodeConfig,
+    vkTreeRoot: getVKTreeRoot(),
+    protocolContractsHash,
+    genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
+    feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
+    aztecTargetCommitteeSize: 0, // no committee in local network
+    slasherFlavor: 'none', // no slashing in local network
+    realVerifier: false,
+  });
 
   aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
   aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
@@ -95,31 +75,27 @@ export async function deployContractsToL1(
   return aztecNodeConfig.l1Contracts;
 }
 
-/** Sandbox settings. */
-export type SandboxConfig = AztecNodeConfig & {
+/** Local network settings. */
+export type LocalNetworkConfig = AztecNodeConfig & {
   /** Mnemonic used to derive the L1 deployer private key.*/
   l1Mnemonic: string;
-  /** Salt used to deploy L1 contracts.*/
-  deployAztecContractsSalt: string;
-  /** Whether to expose PXE service on sandbox start.*/
-  noPXE: boolean;
-  /** Whether to deploy test accounts on sandbox start.*/
+  /** Whether to deploy test accounts on local network start.*/
   testAccounts: boolean;
 };
 
 /**
  * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
  * Does not start any HTTP services nor populate any initial accounts.
- * @param config - Optional Sandbox settings.
+ * @param config - Optional local network settings.
  */
-export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog: LogFn) {
-  // sandbox is meant for test envs. We should only need one l1RpcUrl
+export async function createLocalNetwork(config: Partial<LocalNetworkConfig> = {}, userLog: LogFn) {
+  // local network is meant for test envs. We should only need one l1RpcUrl
   const l1RpcUrl = config.l1RpcUrls?.[0];
   if (!l1RpcUrl) {
     throw new Error('An L1 RPC URL is required');
   }
   if ((config.l1RpcUrls?.length || 0) > 1) {
-    logger.warn(`Multiple L1 RPC URLs provided. Sandbox will only use the first one: ${l1RpcUrl}`);
+    logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
   }
   const aztecNodeConfig: AztecNodeConfig = { ...getConfigEnvVars(), ...config };
   const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
@@ -145,7 +121,7 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
         userLog(`Not setting up test accounts as we are connecting to a network`);
       } else {
         userLog(`Setting up test accounts`);
-        return await getInitialTestAccounts();
+        return await getInitialTestAccountsData();
       }
     }
     return [];
@@ -161,12 +137,15 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
   let watcher: AnvilTestWatcher | undefined = undefined;
   const dateProvider = new TestDateProvider();
   if (!aztecNodeConfig.p2pEnabled) {
-    const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
-      assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
-      genesisArchiveRoot,
-      salt: config.deployAztecContractsSalt ? parseInt(config.deployAztecContractsSalt) : undefined,
-      feeJuicePortalInitialBalance: fundingNeeded,
-    });
+    const l1ContractAddresses = await deployContractsToL1(
+      aztecNodeConfig,
+      aztecNodeConfig.validatorPrivateKeys.getValue()[0],
+      {
+        assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
+        genesisArchiveRoot,
+        feeJuicePortalInitialBalance: fundingNeeded,
+      },
+    );
 
     const chain =
       aztecNodeConfig.l1RpcUrls.length > 0
@@ -179,39 +158,39 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
     });
 
     watcher = new AnvilTestWatcher(
-      new EthCheatCodes([l1RpcUrl]),
+      new EthCheatCodes([l1RpcUrl], dateProvider),
       l1ContractAddresses.rollupAddress,
       publicClient,
       dateProvider,
     );
-    watcher.setIsSandbox(true);
+    watcher.setisLocalNetwork(true);
     await watcher.start();
   }
 
-  const telemetry = initTelemetryClient(getTelemetryClientConfig());
-  // Create a local blob sink client inside the sandbox, no http connectivity
-  const blobSinkClient = createBlobSinkClient();
-  const node = await createAztecNode(
-    aztecNodeConfig,
-    { telemetry, blobSinkClient, dateProvider },
-    { prefilledPublicData },
-  );
-  const pxeServiceConfig = { proverEnabled: aztecNodeConfig.realProofs };
-  const pxe = await createAztecPXE(node, pxeServiceConfig);
+  const telemetry = await initTelemetryClient(getTelemetryClientConfig());
+  // Create a local blob client client inside the local network, no http connectivity
+  const blobClient = createBlobClient();
+  const node = await createAztecNode(aztecNodeConfig, { telemetry, blobClient, dateProvider }, { prefilledPublicData });
 
   if (initialAccounts.length) {
+    const PXEConfig = { proverEnabled: aztecNodeConfig.realProofs };
+    const wallet = await TestWallet.create(node, PXEConfig);
+
     userLog('Setting up funded test accounts...');
-    const accounts = await deployFundedSchnorrAccounts(pxe, initialAccounts);
-    const accountsWithSecrets = accounts.map((account, i) => ({
-      account,
+    const accountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccounts);
+    const accountsWithSecrets = accountManagers.map((manager, i) => ({
+      account: manager,
       secretKey: initialAccounts[i].secret,
     }));
-    const accLogs = await createAccountLogs(accountsWithSecrets, pxe);
+    const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
     userLog(accLogs.join(''));
 
-    const deployer = await getSchnorrWallet(pxe, initialAccounts[0].address, initialAccounts[0].signingKey);
-    await setupBananaFPC(initialAccounts, deployer, userLog);
-    await setupSponsoredFPC(pxe, userLog);
+    await setupBananaFPC(initialAccounts, wallet, userLog);
+
+    userLog(`SponsoredFPC: ${await getSponsoredFPCAddress()}`);
+
+    // We no longer need the wallet once we've setup the accounts so we stop the underlying PXE job queue
+    await wallet.stop();
   }
 
   const stop = async () => {
@@ -219,7 +198,7 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
     await watcher?.stop();
   };
 
-  return { node, pxe, stop };
+  return { node, stop };
 }
 
 /**
@@ -228,7 +207,7 @@ export async function createSandbox(config: Partial<SandboxConfig> = {}, userLog
  */
 export async function createAztecNode(
   config: Partial<AztecNodeConfig> = {},
-  deps: { telemetry?: TelemetryClient; blobSinkClient?: BlobSinkClientInterface; dateProvider?: DateProvider } = {},
+  deps: { telemetry?: TelemetryClient; blobClient?: BlobClientInterface; dateProvider?: DateProvider } = {},
   options: { prefilledPublicData?: PublicDataTreeLeaf[] } = {},
 ) {
   // TODO(#12272): will clean this up. This is criminal.
@@ -241,13 +220,3 @@ export async function createAztecNode(
   const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
   return node;
 }
-
-/**
- * Create and start a new Aztec PXE HTTP Server
- * @param config - Optional PXE settings.
- */
-export async function createAztecPXE(node: AztecNode, config: Partial<PXEServiceConfig> = {}) {
-  const pxeServiceConfig: PXEServiceConfig = { ...getPXEServiceConfig(), ...config };
-  const pxe = await createPXEService(node, pxeServiceConfig);
-  return pxe;
-}

package/src/local-network/sponsored_fpc.ts

@@ -0,0 +1,26 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import {
+  type ContractInstanceWithAddress,
+  getContractInstanceFromInstantiationParams,
+} from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { SPONSORED_FPC_SALT } from '@aztec/constants';
+import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
+
+async function getSponsoredFPCInstance(): Promise<ContractInstanceWithAddress> {
+  return await getContractInstanceFromInstantiationParams(SponsoredFPCContract.artifact, {
+    salt: new Fr(SPONSORED_FPC_SALT),
+  });
+}
+
+export async function getSponsoredFPCAddress(): Promise<AztecAddress> {
+  return (await getSponsoredFPCInstance()).address;
+}
+
+export async function registerDeployedSponsoredFPCInWalletAndGetAddress(wallet: Wallet): Promise<AztecAddress> {
+  const fpc = await getSponsoredFPCInstance();
+  // The following is no-op if the contract is already registered
+  await wallet.registerContract(fpc, SponsoredFPCContract.artifact);
+  return fpc.address;
+}

package/src/testing/anvil_test_watcher.ts

@@ -1,5 +1,6 @@
-import type { ViemClient } from '@aztec/ethereum';
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -16,11 +17,11 @@ import { type GetContractReturnType, getAddress, getContract } from 'viem';
  * block within the slot. And if so, it will time travel into the next slot.
  */
 export class AnvilTestWatcher {
-  private isSandbox: boolean = false;
+  private isLocalNetwork: boolean = false;
 
   private rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
   private rollupCheatCodes: RollupCheatCodes;
-  private l2SlotDuration!: bigint;
+  private l2SlotDuration!: number;
 
   private filledRunningPromise?: RunningPromise;
   private syncDateProviderPromise?: RunningPromise;
@@ -50,11 +51,12 @@ export class AnvilTestWatcher {
   }
 
   setIsMarkingAsProven(isMarkingAsProven: boolean) {
+    this.logger.warn(`Watcher is now ${isMarkingAsProven ? 'marking' : 'not marking'} blocks as proven`);
     this.isMarkingAsProven = isMarkingAsProven;
   }
 
-  setIsSandbox(isSandbox: boolean) {
-    this.isSandbox = isSandbox;
+  setisLocalNetwork(isLocalNetwork: boolean) {
+    this.isLocalNetwork = isLocalNetwork;
   }
 
   async start() {
@@ -67,7 +69,7 @@ export class AnvilTestWatcher {
 
     // If auto mining is not supported (e.g., we are on a real network), then we
     // will simple do nothing. But if on an anvil or the like, this make sure that
-    // the sandbox and tests don't break because time is frozen and we never get to
+    // the local network and tests don't break because time is frozen and we never get to
     // the next slot.
     const isAutoMining = await this.cheatcodes.isAutoMining();
 
@@ -104,7 +106,7 @@ export class AnvilTestWatcher {
   }
 
   async syncDateProviderToL1IfBehind() {
-    // this doesn't apply to the sandbox, because we don't have a date provider in the sandbox
+    // this doesn't apply to the local network, because we don't have a date provider in the local network
     if (!this.dateProvider) {
       return;
     }
@@ -122,17 +124,17 @@ export class AnvilTestWatcher {
 
   async warpTimeIfNeeded() {
     try {
-      const currentSlot = await this.rollup.read.getCurrentSlot();
-      const pendingBlockNumber = BigInt(await this.rollup.read.getPendingBlockNumber());
-      const blockLog = await this.rollup.read.getBlock([pendingBlockNumber]);
-      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([currentSlot + 1n]));
+      const currentSlot = SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+      const pendingCheckpointNumber = await this.rollup.read.getPendingCheckpointNumber();
+      const checkpointLog = await this.rollup.read.getCheckpoint([pendingCheckpointNumber]);
+      const nextSlot = SlotNumber(currentSlot + 1);
+      const nextSlotTimestamp = Number(await this.rollup.read.getTimestampForSlot([BigInt(nextSlot)]));
 
-      if (currentSlot === blockLog.slotNumber) {
+      if (BigInt(currentSlot) === checkpointLog.slotNumber) {
         // We should jump to the next slot
         try {
           await this.cheatcodes.warp(nextSlotTimestamp, {
             resetBlockInterval: true,
-            updateDateProvider: this.dateProvider,
           });
         } catch (e) {
           this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
@@ -142,18 +144,15 @@ export class AnvilTestWatcher {
         return;
       }
 
-      // If we are not in sandbox, we don't need to warp time
-      if (!this.isSandbox) {
+      // If we are not in local network, we don't need to warp time
+      if (!this.isLocalNetwork) {
         return;
       }
 
       const currentTimestamp = this.dateProvider?.now() ?? Date.now();
       if (currentTimestamp > nextSlotTimestamp * 1000) {
         try {
-          await this.cheatcodes.warp(nextSlotTimestamp, {
-            resetBlockInterval: true,
-            updateDateProvider: this.dateProvider,
-          });
+          await this.cheatcodes.warp(nextSlotTimestamp, { resetBlockInterval: true });
         } catch (e) {
           this.logger.error(`Failed to warp to timestamp ${nextSlotTimestamp}: ${e}`);
         }

package/src/testing/cheat_codes.ts

@@ -1,31 +1,31 @@
-import { retryUntil } from '@aztec/aztec.js';
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { retryUntil } from '@aztec/foundation/retry';
+import type { DateProvider } from '@aztec/foundation/timer';
 import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
-
-import { AztecCheatCodes } from './aztec_cheat_codes.js';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 /**
  * A class that provides utility functions for interacting with the chain.
+ * @deprecated There used to be 3 kinds of cheat codes: eth, rollup and aztec. We have nuked the Aztec ones because
+ * they became unused (we now have better testing tools). If you are introducing a new functionality to the cheat
+ * codes, please consider whether it makes sense to just introduce new utils in your tests instead.
  */
 export class CheatCodes {
   constructor(
     /** Cheat codes for L1.*/
     public eth: EthCheatCodes,
-    /** Cheat codes for Aztec L2. */
-    public aztec: AztecCheatCodes,
     /** Cheat codes for the Aztec Rollup contract on L1. */
     public rollup: RollupCheatCodes,
   ) {}
 
-  static async create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes> {
-    const ethCheatCodes = new EthCheatCodes(rpcUrls);
-    const aztecCheatCodes = new AztecCheatCodes(pxe);
+  static async create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes> {
+    const ethCheatCodes = new EthCheatCodes(rpcUrls, dateProvider);
     const rollupCheatCodes = new RollupCheatCodes(
       ethCheatCodes,
-      await pxe.getNodeInfo().then(n => n.l1ContractAddresses),
+      await node.getNodeInfo().then(n => n.l1ContractAddresses),
     );
-    return new CheatCodes(ethCheatCodes, aztecCheatCodes, rollupCheatCodes);
+    return new CheatCodes(ethCheatCodes, rollupCheatCodes);
   }
 
   /**
@@ -38,7 +38,7 @@ export class CheatCodes {
    * @param targetTimestamp - The target timestamp to warp to (in seconds)
    */
   async warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number) {
-    const currentL2BlockNumber = await node.getBlockNumber();
+    const currentL2BlockNumber: BlockNumber = await node.getBlockNumber();
 
     // We warp the L1 timestamp
     await this.eth.warp(targetTimestamp, { resetBlockInterval: true });
@@ -50,7 +50,7 @@ export class CheatCodes {
 
     await retryUntil(
       async () => {
-        const newL2BlockNumber = await node.getBlockNumber();
+        const newL2BlockNumber: BlockNumber = await node.getBlockNumber();
         return newL2BlockNumber > currentL2BlockNumber;
       },
       'new block after warping L2 time',

package/src/testing/index.ts

@@ -1,4 +1,3 @@
 export { AnvilTestWatcher } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-export { AztecCheatCodes } from './aztec_cheat_codes.js';
 export { CheatCodes } from './cheat_codes.js';

package/dest/cli/chain_l2_config.d.ts

@@ -1,31 +0,0 @@
-import { type L1ContractsConfig } from '@aztec/ethereum';
-import type { NetworkNames } from '@aztec/foundation/config';
-import type { SharedNodeConfig } from '@aztec/node-lib/config';
-import type { SlasherConfig } from '@aztec/stdlib/interfaces/server';
-export type L2ChainConfig = L1ContractsConfig & Omit<SlasherConfig, 'slashValidatorsNever' | 'slashValidatorsAlways'> & {
-    l1ChainId: number;
-    testAccounts: boolean;
-    sponsoredFPC: boolean;
-    p2pEnabled: boolean;
-    p2pBootstrapNodes: string[];
-    registryAddress: string;
-    slashFactoryAddress: string;
-    feeAssetHandlerAddress: string;
-    seqMinTxsPerBlock: number;
-    seqMaxTxsPerBlock: number;
-    realProofs: boolean;
-    snapshotsUrl: string;
-    autoUpdate: SharedNodeConfig['autoUpdate'];
-    autoUpdateUrl?: string;
-    maxTxPoolSize: number;
-    publicIncludeMetrics?: string[];
-    publicMetricsCollectorUrl?: string;
-    publicMetricsCollectFrom?: string[];
-    sentinelEnabled: boolean;
-};
-export declare const testnetIgnitionL2ChainConfig: L2ChainConfig;
-export declare const alphaTestnetL2ChainConfig: L2ChainConfig;
-export declare function getBootnodes(networkName: NetworkNames, cacheDir?: string): Promise<any>;
-export declare function getL2ChainConfig(networkName: NetworkNames, cacheDir?: string): Promise<L2ChainConfig | undefined>;
-export declare function enrichEnvironmentWithChainConfig(networkName: NetworkNames): Promise<void>;
-//# sourceMappingURL=chain_l2_config.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chain_l2_config.d.ts","sourceRoot":"","sources":["../../src/cli/chain_l2_config.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,KAAK,EAAU,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAOrE,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAC3C,IAAI,CAAC,aAAa,EAAE,sBAAsB,GAAG,uBAAuB,CAAC,GAAG;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;IAGpC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEJ,eAAO,MAAM,4BAA4B,EAAE,aAqD1C,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,aA4EvC,CAAC;AAIF,wBAAsB,YAAY,CAAC,WAAW,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,gBAgC9E;AAED,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,YAAY,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAWpC;AAgCD,wBAAsB,gCAAgC,CAAC,WAAW,EAAE,YAAY,iBAyF/E"}