@aztec/aztec 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/dest/local-network/local-network.js

@@ -1,55 +1,62 @@
 #!/usr/bin/env -S node --no-warnings
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
-import { AztecNodeService, getConfigEnvVars } from '@aztec/aztec-node';
-import { EthAddress } from '@aztec/aztec.js/addresses';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { createAztecNodeService } from '@aztec/aztec-node';
+import { getConfigEnvVars } from '@aztec/aztec-node/config';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createLogger } from '@aztec/aztec.js/log';
+import { 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 { EthCheatCodes } from '@aztec/ethereum/test';
+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 { SecretValue } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { TestDateProvider } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { TxStatus } from '@aztec/stdlib/tx';
 import { getConfigEnvVars as getTelemetryClientConfig, initTelemetryClient } from '@aztec/telemetry-client';
-import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+import { createFundedInitializerlessAccounts } from '@aztec/wallets/testing';
 import { getGenesisValues } from '@aztec/world-state/testing';
-import { createPublicClient, fallback, http as httpViemTransport } from 'viem';
 import { mnemonicToAccount, privateKeyToAddress } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 import { createAccountLogs } from '../cli/util.js';
 import { DefaultMnemonic } from '../mnemonic.js';
-import { AnvilTestWatcher } from '../testing/anvil_test_watcher.js';
+import { getTokenAllowedSetupFunctions } from '../testing/token_allowed_setup.js';
+import { publishStandardAuthRegistry } from './auth_registry.js';
 import { getBananaFPCAddress, setupBananaFPC } from './banana_fpc.js';
 import { getSponsoredFPCAddress } from './sponsored_fpc.js';
 const logger = createLogger('local-network');
-const localAnvil = foundry;
+// The embedded wallet defaults to waiting for PROPOSED, which returns as soon as a tx lands in a
+// proposed L2 block. That is flaky for the serial sandbox setup below: a proposed block can be
+// pruned before its checkpoint is published, dropping a tx we already moved on from ("Tx dropped by
+// P2P node"). Wait for the checkpoint so each setup tx is durably included before the next is sent.
+const setupWaitOpts = {
+    waitForStatus: TxStatus.CHECKPOINTED
+};
 /**
  * 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, hdAccount, contractDeployLogger = logger, opts = {}) {
-    const chain = aztecNodeConfig.l1RpcUrls.length > 0 ? createEthereumChain(aztecNodeConfig.l1RpcUrls, aztecNodeConfig.l1ChainId) : {
-        chainInfo: localAnvil
-    };
+ */ export async function deployContractsToL1(aztecNodeConfig, privateKey, opts = {}) {
     await waitForPublicClient(aztecNodeConfig);
-    const l1Contracts = await deployL1Contracts(aztecNodeConfig.l1RpcUrls, hdAccount, chain.chainInfo, contractDeployLogger, {
+    const l1Contracts = await deployAztecL1Contracts(aztecNodeConfig.l1RpcUrls[0], privateKey, foundry.id, {
         ...getL1ContractsConfigEnvVars(),
         ...aztecNodeConfig,
         vkTreeRoot: getVKTreeRoot(),
         protocolContractsHash,
         genesisArchiveRoot: opts.genesisArchiveRoot ?? new Fr(GENESIS_ARCHIVE_ROOT),
-        salt: opts.salt,
         feeJuicePortalInitialBalance: opts.feeJuicePortalInitialBalance,
         aztecTargetCommitteeSize: 0,
-        slasherFlavor: 'none',
+        slasherEnabled: false,
         realVerifier: false
     });
-    await deployMulticall3(l1Contracts.l1Client, logger);
-    aztecNodeConfig.l1Contracts = l1Contracts.l1ContractAddresses;
+    Object.assign(aztecNodeConfig, l1Contracts.l1ContractAddresses);
     aztecNodeConfig.rollupVersion = l1Contracts.rollupVersion;
-    return aztecNodeConfig.l1Contracts;
+    return l1Contracts.l1ContractAddresses;
 }
 /**
  * Create and start a new Aztec Node and PXE. Deploys L1 contracts.
@@ -64,14 +71,44 @@ const localAnvil = foundry;
     if ((config.l1RpcUrls?.length || 0) > 1) {
         logger.warn(`Multiple L1 RPC URLs provided. Local networks will only use the first one: ${l1RpcUrl}`);
     }
+    // The local network deploys a banana FPC with Token contracts, so include Token entries
+    // in the setup allowlist so FPC-based fee payments work out of the box.
+    const tokenAllowList = await getTokenAllowedSetupFunctions();
+    const envConfig = getConfigEnvVars();
     const aztecNodeConfig = {
-        ...getConfigEnvVars(),
-        ...config
+        ...envConfig,
+        ...config,
+        skipOrphanProposedBlockPruning: true,
+        // The local network builds node config from env without a DATA_DIRECTORY, so the validator's
+        // local signing protection runs against an ephemeral store. That is acceptable for this dev
+        // network; production validators must persist it and fail-fast when the data directory is unset.
+        allowEphemeralSigningProtection: config.allowEphemeralSigningProtection ?? true,
+        txPublicSetupAllowListExtend: [
+            ...tokenAllowList,
+            ...config.txPublicSetupAllowListExtend ?? []
+        ],
+        // The local network runs against anvil with no committee, so it defaults to the deterministic
+        // AutomineSequencer, which owns L1 time control (warps the dateProvider and L1 timestamps to slot
+        // boundaries as it builds), replacing the deleted AnvilTestWatcher. This remains true when p2p is
+        // enabled for local peer testing; local-network is not a mode for connecting to an existing network.
+        useAutomineSequencer: config.useAutomineSequencer ?? true,
+        // The AutomineSequencer owns epoch proving in the local network — it writes epoch out hashes to
+        // the L1 Outbox and advances the proven tip as checkpoints land, through the same serial queue as
+        // its builds — replacing the standalone EpochTestSettler that used to race the build loop.
+        automineEnableProveEpoch: config.automineEnableProveEpoch ?? true,
+        // Defaults for the local network / sandbox; callers (e.g. the CLI) may override. No real proving
+        // happens here — the AutomineSequencer synthetically settles epochs. Short epochs let it write out
+        // hashes quickly (so users can consume L2-to-L1 messages without a long wait), with a wider
+        // proof-submission window so the synthetic settler has headroom before the rollup would prune an
+        // unproven checkpoint.
+        realProofs: config.realProofs ?? false,
+        aztecEpochDuration: config.aztecEpochDuration ?? 4,
+        aztecProofSubmissionEpochs: config.aztecProofSubmissionEpochs ?? 2
     };
     const hdAccount = mnemonicToAccount(config.l1Mnemonic || DefaultMnemonic);
-    if (aztecNodeConfig.publisherPrivateKeys == undefined || !aztecNodeConfig.publisherPrivateKeys.length || aztecNodeConfig.publisherPrivateKeys[0].getValue() === NULL_KEY) {
+    if (aztecNodeConfig.sequencerPublisherPrivateKeys == undefined || !aztecNodeConfig.sequencerPublisherPrivateKeys.length || aztecNodeConfig.sequencerPublisherPrivateKeys[0].getValue() === NULL_KEY) {
         const privKey = hdAccount.getHdKey().privateKey;
-        aztecNodeConfig.publisherPrivateKeys = [
+        aztecNodeConfig.sequencerPublisherPrivateKeys = [
             new SecretValue(`0x${Buffer.from(privKey).toString('hex')}`)
         ];
     }
@@ -85,7 +122,7 @@ const localAnvil = foundry;
     const initialAccounts = await (async ()=>{
         if (config.testAccounts === true || config.testAccounts === undefined) {
             if (aztecNodeConfig.p2pEnabled) {
-                userLog(`Not setting up test accounts as we are connecting to a network`);
+                userLog(`Not setting up test accounts when p2p is enabled`);
             } else {
                 userLog(`Setting up test accounts`);
                 return await getInitialTestAccountsData();
@@ -95,69 +132,53 @@ const localAnvil = foundry;
     })();
     const bananaFPC = await getBananaFPCAddress(initialAccounts);
     const sponsoredFPC = await getSponsoredFPCAddress();
-    const fundedAddresses = initialAccounts.length ? [
+    const prefundAddresses = (aztecNodeConfig.prefundAddresses ?? []).map((a)=>AztecAddress.fromStringUnsafe(a));
+    const fundedAddresses = [
         ...initialAccounts.map((a)=>a.address),
-        bananaFPC,
-        sponsoredFPC
-    ] : [];
-    const { genesisArchiveRoot, prefilledPublicData, fundingNeeded } = await getGenesisValues(fundedAddresses);
-    let watcher = undefined;
+        ...initialAccounts.length ? [
+            bananaFPC,
+            sponsoredFPC
+        ] : [],
+        ...prefundAddresses
+    ];
+    const { genesisArchiveRoot, genesis, fundingNeeded } = await getGenesisValues(fundedAddresses, config.initialAccountFeeJuice);
     const dateProvider = new TestDateProvider();
     if (!aztecNodeConfig.p2pEnabled) {
-        const l1ContractAddresses = await deployContractsToL1(aztecNodeConfig, hdAccount, undefined, {
-            assumeProvenThroughBlockNumber: Number.MAX_SAFE_INTEGER,
+        await deployContractsToL1(aztecNodeConfig, aztecNodeConfig.validatorPrivateKeys.getValue()[0], {
             genesisArchiveRoot,
-            salt: config.deployAztecContractsSalt ? parseInt(config.deployAztecContractsSalt) : undefined,
             feeJuicePortalInitialBalance: fundingNeeded
         });
-        const chain = aztecNodeConfig.l1RpcUrls.length > 0 ? createEthereumChain([
-            l1RpcUrl
-        ], aztecNodeConfig.l1ChainId) : {
-            chainInfo: localAnvil
-        };
-        const publicClient = createPublicClient({
-            chain: chain.chainInfo,
-            transport: fallback([
-                httpViemTransport(l1RpcUrl)
-            ])
-        });
-        watcher = new AnvilTestWatcher(new EthCheatCodes([
-            l1RpcUrl
-        ], dateProvider), l1ContractAddresses.rollupAddress, publicClient, dateProvider);
-        watcher.setisLocalNetwork(true);
-        await watcher.start();
     }
-    const telemetry = initTelemetryClient(getTelemetryClientConfig());
-    // Create a local blob sink client inside the local network, no http connectivity
-    const blobSinkClient = createBlobSinkClient();
+    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,
-        blobSinkClient,
+        blobClient,
         dateProvider
     }, {
-        prefilledPublicData
+        genesis
     });
     if (initialAccounts.length) {
-        const PXEConfig = {
-            proverEnabled: aztecNodeConfig.realProofs
-        };
-        const wallet = await TestWallet.create(node, PXEConfig);
+        const wallet = await EmbeddedWallet.create(node, {
+            pxeConfig: {
+                proverEnabled: aztecNodeConfig.realProofs
+            },
+            ephemeral: true
+        });
         userLog('Setting up funded test accounts...');
-        const accountManagers = await deployFundedSchnorrAccounts(wallet, node, initialAccounts);
-        const accountsWithSecrets = accountManagers.map((manager, i)=>({
-                account: manager,
-                secretKey: initialAccounts[i].secret
-            }));
-        const accLogs = await createAccountLogs(accountsWithSecrets, wallet);
+        const accountManagers = await createFundedInitializerlessAccounts(wallet, initialAccounts);
+        const accLogs = await createAccountLogs(accountManagers, wallet);
         userLog(accLogs.join(''));
-        await setupBananaFPC(initialAccounts, wallet, userLog);
+        userLog('Publishing standard AuthRegistry contract...');
+        await publishStandardAuthRegistry(wallet, initialAccounts[0].address, setupWaitOpts);
+        await setupBananaFPC(initialAccounts, wallet, userLog, setupWaitOpts);
         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 ()=>{
         await node.stop();
-        await watcher?.stop();
     };
     return {
         node,
@@ -169,15 +190,16 @@ const localAnvil = foundry;
  * @param config - Optional Aztec node settings.
  */ export async function createAztecNode(config = {}, deps = {}, options = {}) {
     // TODO(#12272): will clean this up. This is criminal.
-    const { l1Contracts, ...rest } = getConfigEnvVars();
+    // Not sure why this was ever done. Will be fixed in A-989, A-991, A-990.
     const aztecNodeConfig = {
-        ...rest,
-        ...config,
-        l1Contracts: {
-            ...l1Contracts,
-            ...config.l1Contracts
-        }
+        ...getConfigEnvVars(),
+        ...config
     };
-    const node = await AztecNodeService.createAndSync(aztecNodeConfig, deps, options);
+    const node = await createAztecNodeService(aztecNodeConfig, {
+        ...deps,
+        proverNodeDeps: {
+            broker: deps.proverBroker
+        }
+    }, options);
     return node;
 }

package/dest/testing/cheat_codes.d.ts

@@ -1,15 +1,14 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { SequencerClient } from '@aztec/sequencer-client';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, AztecNodeDebug } 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.
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
  */
 export declare class CheatCodes {
+    /** Cheat codes for L1.*/
     eth: EthCheatCodes;
+    /** Cheat codes for the Aztec Rollup contract on L1. */
     rollup: RollupCheatCodes;
     constructor(
     /** Cheat codes for L1.*/
@@ -18,24 +17,21 @@ export declare class CheatCodes {
     rollup: RollupCheatCodes);
     static create(rpcUrls: string[], node: AztecNode, dateProvider: DateProvider): Promise<CheatCodes>;
     /**
-     * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-     * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
-     * by the slot number, which advances in fixed intervals.
-     * This is useful for testing time-dependent contract behavior.
-     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-     * @param node - The Aztec node used to query if a new block has been mined.
-     * @param targetTimestamp - The target timestamp to warp to (in seconds)
+     * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+     * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+     * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+     * @param targetTimestamp - The target timestamp to warp to (in seconds).
+     * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
      */
-    warpL2TimeAtLeastTo(sequencerClient: SequencerClient, node: AztecNode, targetTimestamp: bigint | number): Promise<void>;
+    warpL2TimeAtLeastTo(node: AztecNode & AztecNodeDebug, targetTimestamp: bigint | number): Promise<void>;
     /**
-     * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-     * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
-     * number, which advances in fixed intervals.
-     * This is useful for testing time-dependent contract behavior.
-     * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-     * @param node - The Aztec node used to query if a new block has been mined.
-     * @param duration - The duration to advance time by (in seconds)
+     * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+     * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+     * queue.
+     * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+     * @param duration - The duration to advance time by (in seconds).
+     * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
      */
-    warpL2TimeAtLeastBy(sequencerClient: SequencerClient, node: AztecNode, duration: bigint | number): Promise<void>;
+    warpL2TimeAtLeastBy(node: AztecNode & AztecNodeDebug, duration: bigint | number): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlYXRfY29kZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2NoZWF0X2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUd2RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMvRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUVqRTs7Ozs7R0FLRztBQUNILHFCQUFhLFVBQVU7SUFHWixHQUFHLEVBQUUsYUFBYTtJQUVsQixNQUFNLEVBQUUsZ0JBQWdCO0lBSmpDO0lBQ0UseUJBQXlCO0lBQ2xCLEdBQUcsRUFBRSxhQUFhO0lBQ3pCLHVEQUF1RDtJQUNoRCxNQUFNLEVBQUUsZ0JBQWdCLEVBQzdCO0lBRUosT0FBYSxNQUFNLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDLENBT3ZHO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDRyxtQkFBbUIsQ0FBQyxlQUFlLEVBQUUsZUFBZSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsZUFBZSxFQUFFLE1BQU0sR0FBRyxNQUFNLGlCQXVCNUc7SUFFRDs7Ozs7Ozs7T0FRRztJQUNHLG1CQUFtQixDQUFDLGVBQWUsRUFBRSxlQUFlLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLE1BQU0saUJBSXJHO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlYXRfY29kZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2NoZWF0X2NvZGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFakY7OztHQUdHO0FBQ0gscUJBQWEsVUFBVTtJQUVuQix5QkFBeUI7SUFDbEIsR0FBRyxFQUFFLGFBQWE7SUFDekIsdURBQXVEO0lBQ2hELE1BQU0sRUFBRSxnQkFBZ0I7SUFKakM7SUFDRSx5QkFBeUI7SUFDbEIsR0FBRyxFQUFFLGFBQWE7SUFDekIsdURBQXVEO0lBQ2hELE1BQU0sRUFBRSxnQkFBZ0IsRUFDN0I7SUFFSixPQUFhLE1BQU0sQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FPdkc7SUFFRDs7Ozs7O09BTUc7SUFDSCxtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsU0FBUyxHQUFHLGNBQWMsRUFBRSxlQUFlLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXJHO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILG1CQUFtQixDQUFDLElBQUksRUFBRSxTQUFTLEdBQUcsY0FBYyxFQUFFLFFBQVEsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFOUY7Q0FDRiJ9

package/dest/testing/cheat_codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/testing/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,UAAU;IAGZ,GAAG,EAAE,aAAa;IAElB,MAAM,EAAE,gBAAgB;IAJjC;IACE,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB,EAC7B;IAEJ,OAAa,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAOvG;IAED;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,iBAuB5G;IAED;;;;;;;;OAQG;IACG,mBAAmB,CAAC,eAAe,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,iBAIrG;CACF"}
+{"version":3,"file":"cheat_codes.d.ts","sourceRoot":"","sources":["../../src/testing/cheat_codes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEjF;;;GAGG;AACH,qBAAa,UAAU;IAEnB,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB;IAJjC;IACE,yBAAyB;IAClB,GAAG,EAAE,aAAa;IACzB,uDAAuD;IAChD,MAAM,EAAE,gBAAgB,EAC7B;IAEJ,OAAa,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,CAOvG;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErG;IAED;;;;;;;OAOG;IACH,mBAAmB,CAAC,IAAI,EAAE,SAAS,GAAG,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9F;CACF"}

package/dest/testing/cheat_codes.js

@@ -1,10 +1,7 @@
 import { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
-import { retryUntil } from '@aztec/foundation/retry';
 /**
- * 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.
+ * Wrapper for Aztec Debug API.
+ * @deprecated use the AztecNode debug API directly.
  */ export class CheatCodes {
     eth;
     rollup;
@@ -18,45 +15,22 @@ import { retryUntil } from '@aztec/foundation/retry';
         return new CheatCodes(ethCheatCodes, rollupCheatCodes);
     }
     /**
-   * Warps the L1 timestamp to a target timestamp and mines an L2 block that advances the L2 timestamp to at least
-   * the target timestamp. L2 timestamp is not advanced exactly to the target timestamp because it is determined
-   * by the slot number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
-   * @param targetTimestamp - The target timestamp to warp to (in seconds)
-   */ async warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp) {
-        const currentL2BlockNumber = await node.getBlockNumber();
-        // We warp the L1 timestamp
-        await this.eth.warp(targetTimestamp, {
-            resetBlockInterval: true
-        });
-        // Wait until an L2 block is mined
-        const sequencer = sequencerClient.getSequencer();
-        const minTxsPerBlock = sequencer.getConfig().minTxsPerBlock;
-        sequencer.updateConfig({
-            minTxsPerBlock: 0
-        });
-        await retryUntil(async ()=>{
-            const newL2BlockNumber = await node.getBlockNumber();
-            return newL2BlockNumber > currentL2BlockNumber;
-        }, 'new block after warping L2 time', 36, 1);
-        // Restore original minTxsPerBlock
-        sequencer.updateConfig({
-            minTxsPerBlock
-        });
+   * Warps the L1 timestamp to at least `targetTimestamp` and mines an L2 block advancing the L2 timestamp to at least
+   * the target. Forwards to the node's debug API, which serializes the warp through the automine sequencer queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param targetTimestamp - The target timestamp to warp to (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastTo(targetTimestamp)` on the node debug API directly.
+   */ warpL2TimeAtLeastTo(node, targetTimestamp) {
+        return node.warpL2TimeAtLeastTo(Number(targetTimestamp));
     }
     /**
-   * Warps the L1 timestamp forward by a specified duration and mines an L2 block that advances the L2 timestamp at
-   * least by the duration. L2 timestamp is not advanced exactly by the duration because it is determined by the slot
-   * number, which advances in fixed intervals.
-   * This is useful for testing time-dependent contract behavior.
-   * @param sequencerClient - The sequencer client to use to force an empty block to be mined.
-   * @param node - The Aztec node used to query if a new block has been mined.
-   * @param duration - The duration to advance time by (in seconds)
-   */ async warpL2TimeAtLeastBy(sequencerClient, node, duration) {
-        const currentTimestamp = await this.eth.timestamp();
-        const targetTimestamp = BigInt(currentTimestamp) + BigInt(duration);
-        await this.warpL2TimeAtLeastTo(sequencerClient, node, targetTimestamp);
+   * Warps the L1 timestamp forward by at least `duration` seconds and mines an L2 block advancing the L2 timestamp at
+   * least by the duration. Forwards to the node's debug API, which serializes the warp through the automine sequencer
+   * queue.
+   * @param node - The Aztec node whose debug API performs the warp. Must run an automine sequencer.
+   * @param duration - The duration to advance time by (in seconds).
+   * @deprecated Call `node.warpL2TimeAtLeastBy(duration)` on the node debug API directly.
+   */ warpL2TimeAtLeastBy(node, duration) {
+        return node.warpL2TimeAtLeastBy(Number(duration));
     }
 }

package/dest/testing/epoch_test_settler.d.ts

@@ -0,0 +1,19 @@
+import { type EthCheatCodes } from '@aztec/ethereum/test';
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { EthAddress, L2BlockSource } from '@aztec/stdlib/block';
+export declare class EpochTestSettler {
+    private l2BlockSource;
+    private log;
+    private options;
+    private rollupCheatCodes;
+    private epochMonitor?;
+    constructor(cheatcodes: EthCheatCodes, rollupAddress: EthAddress, l2BlockSource: L2BlockSource, log: Logger, options: {
+        pollingIntervalMs: number;
+        provingDelayMs?: number;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleEpochReadyToProve(epoch: EpochNumber): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2hfdGVzdF9zZXR0bGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9lcG9jaF90ZXN0X3NldHRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssYUFBYSxFQUFvQixNQUFNLHNCQUFzQixDQUFDO0FBQzVFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBR3BELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRSxxQkFBYSxnQkFBZ0I7SUFPekIsT0FBTyxDQUFDLGFBQWE7SUFDckIsT0FBTyxDQUFDLEdBQUc7SUFDWCxPQUFPLENBQUMsT0FBTztJQVJqQixPQUFPLENBQUMsZ0JBQWdCLENBQW1CO0lBQzNDLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FBZTtJQUVwQyxZQUNFLFVBQVUsRUFBRSxhQUFhLEVBQ3pCLGFBQWEsRUFBRSxVQUFVLEVBQ2pCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLEdBQUcsRUFBRSxNQUFNLEVBQ1gsT0FBTyxFQUFFO1FBQUUsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO1FBQUMsY0FBYyxDQUFDLEVBQUUsTUFBTSxDQUFBO0tBQUUsRUFHeEU7SUFFSyxLQUFLLGtCQUlWO0lBRUssSUFBSSxrQkFFVDtJQUVLLHVCQUF1QixDQUFDLEtBQUssRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWNsRTtDQUNGIn0=

package/dest/testing/epoch_test_settler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch_test_settler.d.ts","sourceRoot":"","sources":["../../src/testing/epoch_test_settler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAErE,qBAAa,gBAAgB;IAOzB,OAAO,CAAC,aAAa;IACrB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IARjB,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,YACE,UAAU,EAAE,aAAa,EACzB,aAAa,EAAE,UAAU,EACjB,aAAa,EAAE,aAAa,EAC5B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,EAGxE;IAEK,KAAK,kBAIV;IAEK,IAAI,kBAET;IAEK,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAclE;CACF"}

package/dest/testing/epoch_test_settler.js

@@ -0,0 +1,42 @@
+import { RollupCheatCodes } from '@aztec/ethereum/test';
+import { settleEpochOutbox } from '@aztec/prover-client/test';
+import { EpochMonitor } from '@aztec/prover-node';
+export class EpochTestSettler {
+    l2BlockSource;
+    log;
+    options;
+    rollupCheatCodes;
+    epochMonitor;
+    constructor(cheatcodes, rollupAddress, l2BlockSource, log, options){
+        this.l2BlockSource = l2BlockSource;
+        this.log = log;
+        this.options = options;
+        this.rollupCheatCodes = new RollupCheatCodes(cheatcodes, {
+            rollupAddress
+        });
+    }
+    async start() {
+        const { epochDuration } = await this.rollupCheatCodes.getConfig();
+        this.epochMonitor = new EpochMonitor(this.l2BlockSource, {
+            epochDuration: Number(epochDuration)
+        }, this.options);
+        this.epochMonitor.start(this);
+    }
+    async stop() {
+        await this.epochMonitor?.stop();
+    }
+    async handleEpochReadyToProve(epoch) {
+        const lastCheckpoint = await settleEpochOutbox({
+            rollupCheatCodes: this.rollupCheatCodes,
+            l2BlockSource: this.l2BlockSource,
+            epoch,
+            log: this.log
+        });
+        if (lastCheckpoint !== undefined) {
+            await this.rollupCheatCodes.markAsProven(lastCheckpoint);
+        } else {
+            this.log.warn(`No checkpoint found for epoch ${epoch}`);
+        }
+        return true;
+    }
+}

package/dest/testing/index.d.ts

@@ -1,4 +1,6 @@
-export { AnvilTestWatcher } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 export { CheatCodes } from './cheat_codes.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzNELE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUMifQ==
+export { EpochTestSettler } from './epoch_test_settler.js';
+export { setupLocalNetwork, TEST_FEE_PADDING, type LocalNetwork, type LocalNetworkOptions } from './local-network.js';
+export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN2RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLEtBQUssWUFBWSxFQUFFLEtBQUssbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN0SCxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyJ9

package/dest/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACtH,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC"}

package/dest/testing/index.js

@@ -1,3 +1,5 @@
-export { AnvilTestWatcher } from './anvil_test_watcher.js';
 export { EthCheatCodes, RollupCheatCodes } from '@aztec/ethereum/test';
 export { CheatCodes } from './cheat_codes.js';
+export { EpochTestSettler } from './epoch_test_settler.js';
+export { setupLocalNetwork, TEST_FEE_PADDING } from './local-network.js';
+export { getTokenAllowedSetupFunctions } from './token_allowed_setup.js';

package/dest/testing/local-network.d.ts

@@ -0,0 +1,51 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import type { AztecNodeConfig } from '@aztec/aztec-node/config';
+import type { Fr } from '@aztec/aztec.js/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+/** A running in-process local network: an inline Aztec node backed by its own anvil L1. */
+export interface LocalNetwork extends AsyncDisposable {
+    /** Fully-synced Aztec node, ready to serve client requests. */
+    node: AztecNodeService;
+    /** RPC URL of the spawned anvil instance. */
+    l1RpcUrl: string;
+    /** Chain id used on L1 (foundry's default 31337). */
+    l1ChainId: number;
+    /** Stops every process started by the fixture: node and anvil. Also invoked by `await using`. */
+    stop: () => Promise<void>;
+}
+/** Options for {@link setupLocalNetwork}. */
+export interface LocalNetworkOptions {
+    /**
+     * Addresses that should hold fee juice at genesis. Saves each of these the round-trip of bridging
+     * + claiming fee juice before they can pay for gas.
+     */
+    fundedAddresses?: AztecAddress[];
+    /** Override the default per-address genesis fee juice granted to {@link fundedAddresses}. */
+    initialAccountFeeJuice?: Fr;
+    /** Node config overrides, e.g. `realProofs`, `aztecEpochDuration`, `p2pEnabled`. */
+    config?: Partial<AztecNodeConfig>;
+}
+/**
+ * Spin up an in-process local network with the given addresses pre-funded.
+ *
+ * Each call spawns its own anvil on an OS-assigned random port and runs the Aztec node inline via
+ * the same {@link createLocalNetwork} codepath that backs `aztec start --local-network` (with the
+ * sandbox account/FPC/token setup skipped). Distinct ports let independent suites run in parallel.
+ * The caller must `await result.stop()` in its teardown (or hold the result with `await using`).
+ *
+ * Requires a Foundry toolchain (`anvil`/`forge`), installed via `aztec-up` or `foundryup`. Binaries
+ * are located in the standard install directories or on `PATH`; set `$ANVIL_BIN` / `$FORGE_BIN` to
+ * pin specific ones.
+ */
+export declare function setupLocalNetwork(opts?: LocalNetworkOptions): Promise<LocalNetwork>;
+/**
+ * Min-fee padding multiplier for test wallets whose txs may mine well after their fee estimate.
+ * The automine sequencer builds one block per tx and advances L1 time in big jumps, and proposer
+ * pipelining evolves the fee-asset price across the build/publish gap (~20x observed in CI), so the
+ * network's congestion base fee can swing sharply between the wallet's fee estimate and the block
+ * the tx actually lands in. The default wallet padding isn't enough and trips
+ * `maxFeesPerGas.feePerL2Gas must be >= gasFees.feePerL2Gas`. Apply via
+ * `wallet.setMinFeePadding(TEST_FEE_PADDING)` on every test wallet that sends txs.
+ */
+export declare const TEST_FEE_PADDING = 30;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwtbmV0d29yay5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Rlc3RpbmcvbG9jYWwtbmV0d29yay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFELE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRWpELE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBTWhFLDJGQUEyRjtBQUMzRixNQUFNLFdBQVcsWUFBYSxTQUFRLGVBQWU7SUFDbkQsK0RBQStEO0lBQy9ELElBQUksRUFBRSxnQkFBZ0IsQ0FBQztJQUN2Qiw2Q0FBNkM7SUFDN0MsUUFBUSxFQUFFLE1BQU0sQ0FBQztJQUNqQixxREFBcUQ7SUFDckQsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixpR0FBaUc7SUFDakcsSUFBSSxFQUFFLE1BQU0sT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQzNCO0FBRUQsNkNBQTZDO0FBQzdDLE1BQU0sV0FBVyxtQkFBbUI7SUFDbEM7OztPQUdHO0lBQ0gsZUFBZSxDQUFDLEVBQUUsWUFBWSxFQUFFLENBQUM7SUFDakMsNkZBQTZGO0lBQzdGLHNCQUFzQixDQUFDLEVBQUUsRUFBRSxDQUFDO0lBQzVCLG9GQUFvRjtJQUNwRixNQUFNLENBQUMsRUFBRSxPQUFPLENBQUMsZUFBZSxDQUFDLENBQUM7Q0FDbkM7QUFFRDs7Ozs7Ozs7Ozs7R0FXRztBQUNILHdCQUFzQixpQkFBaUIsQ0FBQyxJQUFJLEdBQUUsbUJBQXdCLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQXNDN0Y7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILGVBQU8sTUFBTSxnQkFBZ0IsS0FBSyxDQUFDIn0=

package/dest/testing/local-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-network.d.ts","sourceRoot":"","sources":["../../src/testing/local-network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAMhE,2FAA2F;AAC3F,MAAM,WAAW,YAAa,SAAQ,eAAe;IACnD,+DAA+D;IAC/D,IAAI,EAAE,gBAAgB,CAAC;IACvB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,iGAAiG;IACjG,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,6CAA6C;AAC7C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,eAAe,CAAC,EAAE,YAAY,EAAE,CAAC;IACjC,6FAA6F;IAC7F,sBAAsB,CAAC,EAAE,EAAE,CAAC;IAC5B,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CAsC7F;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC"}

package/dest/testing/local-network.js

@@ -0,0 +1,60 @@
+import { startAnvil } from '@aztec/ethereum/test';
+import { foundry } from 'viem/chains';
+import { createLocalNetwork } from '../local-network/local-network.js';
+/**
+ * Spin up an in-process local network with the given addresses pre-funded.
+ *
+ * Each call spawns its own anvil on an OS-assigned random port and runs the Aztec node inline via
+ * the same {@link createLocalNetwork} codepath that backs `aztec start --local-network` (with the
+ * sandbox account/FPC/token setup skipped). Distinct ports let independent suites run in parallel.
+ * The caller must `await result.stop()` in its teardown (or hold the result with `await using`).
+ *
+ * Requires a Foundry toolchain (`anvil`/`forge`), installed via `aztec-up` or `foundryup`. Binaries
+ * are located in the standard install directories or on `PATH`; set `$ANVIL_BIN` / `$FORGE_BIN` to
+ * pin specific ones.
+ */ export async function setupLocalNetwork(opts = {}) {
+    // `--port 0` → anvil binds an ephemeral port that `startAnvil` reads back, so parallel suites
+    // never collide on a fixed port.
+    const { rpcUrl, stop: stopAnvil } = await startAnvil({
+        port: 0
+    });
+    try {
+        const { node, stop: stopNode } = await createLocalNetwork({
+            ...opts.config,
+            l1RpcUrls: [
+                rpcUrl
+            ],
+            testAccounts: false,
+            prefundAddresses: (opts.fundedAddresses ?? []).map((a)=>a.toString()),
+            initialAccountFeeJuice: opts.initialAccountFeeJuice
+        }, ()=>{});
+        // Stop the node before anvil (its teardown still talks to L1); the finally guarantees anvil is
+        // reaped even if node shutdown throws.
+        const stop = async ()=>{
+            try {
+                await stopNode();
+            } finally{
+                await stopAnvil();
+            }
+        };
+        return {
+            node,
+            l1RpcUrl: rpcUrl,
+            l1ChainId: foundry.id,
+            stop,
+            [Symbol.asyncDispose]: stop
+        };
+    } catch (err) {
+        await stopAnvil();
+        throw err;
+    }
+}
+/**
+ * Min-fee padding multiplier for test wallets whose txs may mine well after their fee estimate.
+ * The automine sequencer builds one block per tx and advances L1 time in big jumps, and proposer
+ * pipelining evolves the fee-asset price across the build/publish gap (~20x observed in CI), so the
+ * network's congestion base fee can swing sharply between the wallet's fee estimate and the block
+ * the tx actually lands in. The default wallet padding isn't enough and trips
+ * `maxFeesPerGas.feePerL2Gas must be >= gasFees.feePerL2Gas`. Apply via
+ * `wallet.setMinFeePadding(TEST_FEE_PADDING)` on every test wallet that sends txs.
+ */ export const TEST_FEE_PADDING = 30;