@aztec/end-to-end 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/dest/fixtures/e2e_prover_test.js

@@ -1,114 +1,116 @@
-import { createArchiver } from '@aztec/archiver';
+import { generateSchnorrAccounts } from '@aztec/accounts/testing';
+import { createAztecNodeService } from '@aztec/aztec-node';
 import { EthAddress } from '@aztec/aztec.js/addresses';
 import { createLogger } from '@aztec/aztec.js/log';
-import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import { createBlobSinkClient } from '@aztec/blob-sink/client';
+import { BackendType, Barretenberg } from '@aztec/bb.js';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { SecretValue } from '@aztec/foundation/config';
 import { FeeAssetHandlerAbi } from '@aztec/l1-artifacts';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import { createProverNode } from '@aztec/prover-node';
 import { getGenesisValues } from '@aztec/world-state/testing';
 import { getContract } from 'viem';
 import { privateKeyToAddress } from 'viem/accounts';
 import { TokenSimulator } from '../simulators/token_simulator.js';
+import { SingleNodeTestContext } from '../single-node/single_node_test_context.js';
 import { getACVMConfig } from './get_acvm_config.js';
 import { getBBConfig } from './get_bb_config.js';
-import { createSnapshotManager, deployAccounts, publicDeployAccounts } from './snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setupPXEAndGetWallet } from './utils.js';
-const { E2E_DATA_PATH: dataPath } = process.env;
+import { getPrivateKeyFromIndex, getSponsoredFPCAddress, setup, setupPXEAndGetWallet } from './setup.js';
 /**
  * Largely taken from the e2e_token_contract test file. We deploy 2 accounts and a token contract.
  * However, we then setup a second PXE with a full prover instance.
  * We configure this instance with all of the accounts and contracts.
  * We then prove and verify transactions created via this full prover PXE.
- */ export class FullProverTest {
-    minNumberOfTxsPerBlock;
-    realProofs;
+ *
+ * The real-prover sub-base of the single-node topology: extends {@link SingleNodeTestContext} so it
+ * reuses the base node tracking / chain monitor / teardown machinery, but builds its environment with
+ * the bespoke prover opts below (real BB, `realVerifier` L1, the snapshot/account + TokenSimulator
+ * harness, and a hand-built prover node) rather than the base's default fake-prover config.
+ */ export class FullProverTest extends SingleNodeTestContext {
     static TOKEN_NAME = 'USDC';
     static TOKEN_SYMBOL = 'USD';
     static TOKEN_DECIMALS = 18n;
-    snapshotManager;
-    logger;
     wallet;
     provenWallet;
-    accounts;
-    deployedAccounts;
+    accounts = [];
+    fundedAccounts;
     fakeProofsAsset;
+    fakeProofsAssetInstance;
     tokenSim;
     aztecNode;
     aztecNodeAdmin;
     cheatCodes;
-    blobSink;
-    provenComponents;
+    provenComponents = [];
     bbConfigCleanup;
     acvmConfigCleanup;
-    circuitProofVerifier;
+    /** Returns the proof verifier from the prover node (for test assertions). */ get circuitProofVerifier() {
+        return this.proverAztecNode?.getProofVerifier();
+    }
     provenAsset;
-    context;
-    proverNode;
-    simulatedProverNode;
+    proverAztecNode;
+    simulatedProverAztecNode;
     l1Contracts;
     proverAddress;
+    testName;
+    minNumberOfTxsPerBlock;
+    coinbase;
+    realProofs;
     constructor(testName, minNumberOfTxsPerBlock, coinbase, realProofs = true){
+        super();
+        this.testName = testName;
+        this.logger = createLogger(`e2e:full_prover_test:${testName}`);
         this.minNumberOfTxsPerBlock = minNumberOfTxsPerBlock;
+        this.coinbase = coinbase;
         this.realProofs = realProofs;
-        this.accounts = [];
-        this.provenComponents = [];
-        this.snapshot = (name, apply, restore = ()=>Promise.resolve())=>this.snapshotManager.snapshot(name, apply, restore);
-        this.logger = createLogger(`e2e:full_prover_test:${testName}`);
-        this.snapshotManager = createSnapshotManager(`full_prover_integration/${testName}`, dataPath, {
-            startProverNode: true,
-            fundRewardDistributor: true,
-            coinbase
-        }, {
-            realVerifier: realProofs
-        });
     }
     /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 2 accounts.
-   * 2. Publicly deploy accounts, deploy token contract
-   */ async applyBaseSnapshots() {
-        await this.snapshotManager.snapshot('2_accounts', deployAccounts(2, this.logger), ({ deployedAccounts }, { wallet })=>{
-            this.deployedAccounts = deployedAccounts;
-            this.accounts = deployedAccounts.map((a)=>a.address);
-            this.wallet = wallet;
-            return Promise.resolve();
-        });
-        await this.snapshotManager.snapshot('client_prover_integration', async ()=>{
-            // Create the token contract state.
-            // Move this account thing to addAccounts above?
-            this.logger.verbose(`Public deploy accounts...`);
-            await publicDeployAccounts(this.wallet, this.accounts.slice(0, 2));
-            this.logger.verbose(`Deploying TokenContract...`);
-            const asset = await TokenContract.deploy(this.wallet, this.accounts[0], FullProverTest.TOKEN_NAME, FullProverTest.TOKEN_SYMBOL, FullProverTest.TOKEN_DECIMALS).send({
-                from: this.accounts[0]
-            }).deployed();
-            this.logger.verbose(`Token deployed to ${asset.address}`);
-            return {
-                tokenContractAddress: asset.address
-            };
-        }, async ({ tokenContractAddress })=>{
-            // Restore the token contract state.
-            this.fakeProofsAsset = await TokenContract.at(tokenContractAddress, this.wallet);
-            this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
-            this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallet, this.accounts[0], this.logger, this.accounts);
-            expect(await this.fakeProofsAsset.methods.get_admin().simulate({
-                from: this.accounts[0]
-            })).toBe(this.accounts[0].toBigInt());
+   * Applies base setup: deploys 2 accounts and token contract.
+   */ async applyBaseSetup() {
+        this.logger.info('Applying base setup: registering funded accounts');
+        this.fundedAccounts = this.context.additionallyFundedAccounts;
+        this.accounts = this.fundedAccounts.map((a)=>a.address);
+        this.wallet = this.context.wallet;
+        for (const { secret, salt, signingKey } of this.fundedAccounts){
+            await this.wallet.createSchnorrInitializerlessAccount(secret, salt, signingKey);
+        }
+        this.logger.info('Applying base setup: deploying token contract');
+        const { contract: asset, instance } = await TokenContract.deploy(this.wallet, this.accounts[0], FullProverTest.TOKEN_NAME, FullProverTest.TOKEN_SYMBOL, FullProverTest.TOKEN_DECIMALS).send({
+            from: this.accounts[0]
         });
+        this.logger.verbose(`Token deployed to ${asset.address}`);
+        this.fakeProofsAsset = asset;
+        this.fakeProofsAssetInstance = instance;
+        this.logger.verbose(`Token contract address: ${this.fakeProofsAsset.address}`);
+        this.tokenSim = new TokenSimulator(this.fakeProofsAsset, this.wallet, this.accounts[0], this.logger, this.accounts);
+        expect((await this.fakeProofsAsset.methods.get_admin().simulate({
+            from: this.accounts[0]
+        })).result).toBe(this.accounts[0].toBigInt());
     }
-    async setup() {
-        this.context = await this.snapshotManager.setup();
-        // We don't wish to mark as proven automatically, so we set the flag to false
-        this.context.watcher.setIsMarkingAsProven(false);
-        this.simulatedProverNode = this.context.proverNode;
-        ({ aztecNode: this.aztecNode, deployL1ContractsValues: this.l1Contracts, cheatCodes: this.cheatCodes, blobSink: this.blobSink } = this.context);
-        this.aztecNodeAdmin = this.context.aztecNode;
-        const blobSinkClient = createBlobSinkClient({
-            blobSinkUrl: `http://localhost:${this.blobSink.port}`
+    async setup(opts = {}) {
+        this.logger.info('Setting up subsystems from fresh');
+        const context = await setup(0, {
+            ...opts,
+            startProverNode: true,
+            coinbase: this.coinbase,
+            fundSponsoredFPC: true,
+            additionallyFundedAccounts: await generateSchnorrAccounts(2),
+            l1ContractsArgs: {
+                realVerifier: this.realProofs
+            }
+        });
+        // Reuse the base context machinery (rollup, epoch cache, chain monitor, node tracking, teardown)
+        // over the environment built above. Restore the FullProverTest-named logger afterwards, since
+        // hydrateFromContext repoints `this.logger` at the context logger.
+        await this.hydrateFromContext(context);
+        this.logger = createLogger(`e2e:full_prover_test:${this.testName}`);
+        await this.applyBaseSetup();
+        await this.applyMint();
+        this.logger.info(`Enabling proving`, {
+            realProofs: this.realProofs
         });
+        this.simulatedProverAztecNode = this.context.proverNode;
+        ({ aztecNode: this.aztecNode, deployL1ContractsValues: this.l1Contracts, cheatCodes: this.cheatCodes } = this.context);
+        this.aztecNodeAdmin = this.context.aztecNodeService;
+        const config = this.context.aztecNodeConfig;
         // Configure a full prover PXE
         let acvmConfig;
         let bbConfig;
@@ -122,11 +124,9 @@ const { E2E_DATA_PATH: dataPath } = process.env;
             }
             this.acvmConfigCleanup = acvmConfig.cleanup;
             this.bbConfigCleanup = bbConfig.cleanup;
-            if (!bbConfig?.bbWorkingDirectory || !bbConfig?.bbBinaryPath) {
-                throw new Error(`Test must be run with BB native configuration`);
-            }
-            const verifier = await BBCircuitVerifier.new(bbConfig);
-            this.circuitProofVerifier = new QueuedIVCVerifier(bbConfig, verifier);
+            await Barretenberg.initSingleton({
+                backend: BackendType.NativeUnixSocket
+            });
             this.logger.debug(`Configuring the node for real proofs...`);
             await this.aztecNodeAdmin.setConfig({
                 realProofs: true,
@@ -134,7 +134,6 @@ const { E2E_DATA_PATH: dataPath } = process.env;
             });
         } else {
             this.logger.debug(`Configuring the node min txs per block ${this.minNumberOfTxsPerBlock}...`);
-            this.circuitProofVerifier = new TestCircuitVerifier();
             await this.aztecNodeAdmin.setConfig({
                 minTxsPerBlock: this.minNumberOfTxsPerBlock
             });
@@ -144,18 +143,18 @@ const { E2E_DATA_PATH: dataPath } = process.env;
         this.logger.verbose(`Marking current block as proven`);
         await this.context.cheatCodes.rollup.markAsProven();
         this.logger.verbose(`Main setup completed, initializing full prover PXE, Node, and Prover Node`);
-        const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(this.aztecNode, {
-            proverEnabled: this.realProofs,
-            bbBinaryPath: bbConfig?.bbBinaryPath,
-            bbWorkingDirectory: bbConfig?.bbWorkingDirectory
-        }, undefined, true);
+        const { wallet: provenWallet, teardown: provenTeardown } = await setupPXEAndGetWallet(this.aztecNode, this.context.aztecNode, {
+            proverEnabled: this.realProofs
+        }, undefined, 'pxe-proven');
         this.logger.debug(`Contract address ${this.fakeProofsAsset.address}`);
-        await provenWallet.registerContract(this.fakeProofsAsset);
+        await provenWallet.registerContract(this.fakeProofsAssetInstance, TokenContract.artifact);
         for(let i = 0; i < 2; i++){
-            await provenWallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
-            await this.wallet.createSchnorrAccount(this.deployedAccounts[i].secret, this.deployedAccounts[i].salt);
+            // Mirror the initializerless funded accounts (created via createFundedAccounts) in both wallets so
+            // their addresses match the genesis-funded ones.
+            await provenWallet.createSchnorrInitializerlessAccount(this.fundedAccounts[i].secret, this.fundedAccounts[i].salt);
+            await this.wallet.createSchnorrInitializerlessAccount(this.fundedAccounts[i].secret, this.fundedAccounts[i].salt);
         }
-        const asset = await TokenContract.at(this.fakeProofsAsset.address, provenWallet);
+        const asset = TokenContract.at(this.fakeProofsAsset.address, provenWallet);
         this.provenComponents.push({
             wallet: provenWallet,
             teardown: provenTeardown
@@ -163,35 +162,30 @@ const { E2E_DATA_PATH: dataPath } = process.env;
         this.provenAsset = asset;
         this.provenWallet = provenWallet;
         this.logger.info(`Full prover PXE started`);
-        // Shutdown the current, simulated prover node
+        // Shutdown the current, simulated prover node (by stopping its hosting aztec node)
         this.logger.verbose('Shutting down simulated prover node');
-        await this.simulatedProverNode.stop();
-        // Creating temp store and archiver for fully proven prover node
-        this.logger.verbose('Starting archiver for new prover node');
-        const archiver = await createArchiver({
-            ...this.context.aztecNodeConfig,
-            dataDirectory: undefined
-        }, {
-            blobSinkClient
-        }, {
-            blockUntilSync: true
-        });
+        await this.simulatedProverAztecNode.stop();
         // The simulated prover node (now shutdown) used private key index 2
         const proverNodePrivateKey = getPrivateKeyFromIndex(2);
+        const proverNodePrivateKeyHex = `0x${proverNodePrivateKey.toString('hex')}`;
         const proverNodeSenderAddress = privateKeyToAddress(new Buffer32(proverNodePrivateKey).toString());
         this.proverAddress = EthAddress.fromString(proverNodeSenderAddress);
         this.logger.verbose(`Funding prover node at ${proverNodeSenderAddress}`);
         await this.mintFeeJuice(proverNodeSenderAddress);
         this.logger.verbose('Starting prover node');
-        const proverConfig = {
-            ...this.context.aztecNodeConfig,
-            txCollectionNodeRpcUrls: [],
+        const sponsoredFPCAddress = await getSponsoredFPCAddress();
+        const { genesis } = await getGenesisValues(this.context.additionallyFundedAccounts.map((a)=>a.address).concat(sponsoredFPCAddress), undefined, undefined, this.context.genesis.genesisTimestamp);
+        const proverNodeConfig = {
+            ...config,
+            enableProverNode: true,
+            disableValidator: true,
             dataDirectory: undefined,
+            txCollectionNodeRpcUrls: [],
             proverId: this.proverAddress,
             realProofs: this.realProofs,
             proverAgentCount: 2,
-            publisherPrivateKeys: [
-                new SecretValue(`0x${proverNodePrivateKey.toString('hex')}`)
+            proverPublisherPrivateKeys: [
+                new SecretValue(proverNodePrivateKeyHex)
             ],
             proverNodeMaxPendingJobs: 100,
             proverNodeMaxParallelBlocksPerEpoch: 32,
@@ -199,22 +193,32 @@ const { E2E_DATA_PATH: dataPath } = process.env;
             txGatheringIntervalMs: 1000,
             txGatheringBatchSize: 10,
             txGatheringMaxParallelRequestsPerNode: 100,
-            txGatheringTimeoutMs: 24_000,
+            // The test warps the L1 clock forward a full epoch via cheatcodes; the prover-node
+            // tracks L1 time, so an in-flight tx-gather would see its deadline jump into the
+            // past. Use a generous window so the deadline survives the warp.
+            txGatheringTimeoutMs: 10 * 60 * 1000,
             proverNodeFailedEpochStore: undefined,
-            proverNodeEpochProvingDelayMs: undefined
+            proverNodeEpochProvingDelayMs: undefined,
+            validatorPrivateKeys: new SecretValue([])
         };
-        const sponsoredFPCAddress = await getSponsoredFPCAddress();
-        const { prefilledPublicData } = await getGenesisValues(this.context.initialFundedAccounts.map((a)=>a.address).concat(sponsoredFPCAddress));
-        this.proverNode = await createProverNode(proverConfig, {
-            aztecNodeTxProvider: this.aztecNode,
-            archiver: archiver,
-            blobSinkClient
+        this.proverAztecNode = await createAztecNodeService(proverNodeConfig, {
+            dateProvider: this.context.dateProvider,
+            p2pClientDeps: {
+                rpcTxProviders: [
+                    this.aztecNode
+                ]
+            }
         }, {
-            prefilledPublicData
+            genesis
+        });
+        // Track the real prover node so the base teardown stops it (the simulated one created by `setup`
+        // was already stopped above).
+        this.proverNodes = [
+            this.proverAztecNode
+        ];
+        this.logger.warn(`Proofs are now enabled`, {
+            realProofs: this.realProofs
         });
-        await this.proverNode.start();
-        this.logger.warn(`Proofs are now enabled`);
-        return this;
     }
     async mintFeeJuice(recipient) {
         const handlerAddress = this.context.deployL1ContractsValues.l1ContractAddresses.feeAssetHandlerAddress;
@@ -232,55 +236,51 @@ const { E2E_DATA_PATH: dataPath } = process.env;
             hash
         });
     }
-    snapshot;
     async teardown() {
-        await this.snapshotManager.teardown();
         // Cleanup related to the full prover PXEs
         for(let i = 0; i < this.provenComponents.length; i++){
             await this.provenComponents[i].teardown();
         }
-        // clean up the full prover node
-        await this.proverNode.stop();
+        // Stop the prover node before destroying the BB singleton it proves with.
+        await this.proverAztecNode.stop();
+        await Barretenberg.destroySingleton();
         await this.bbConfigCleanup?.();
         await this.acvmConfigCleanup?.();
+        // Stops the chain monitor, the tracked nodes (main node + the already-stopped prover node, a
+        // safe no-op), and the context.
+        await super.teardown();
     }
-    async applyMintSnapshot() {
-        await this.snapshotManager.snapshot('mint', async ()=>{
-            const { fakeProofsAsset: asset, accounts } = this;
-            const privateAmount = 10000n;
-            const publicAmount = 10000n;
-            this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
-            await asset.methods.mint_to_public(accounts[0], privateAmount + publicAmount).send({
-                from: accounts[0]
-            }).wait();
-            this.logger.verbose(`Transferring ${privateAmount} to private...`);
-            await asset.methods.transfer_to_private(accounts[0], privateAmount).send({
-                from: accounts[0]
-            }).wait();
-            this.logger.verbose(`Minting complete.`);
-            return {
-                amount: publicAmount
-            };
-        }, async ({ amount })=>{
-            const { fakeProofsAsset: asset, accounts: [address], tokenSim } = this;
-            tokenSim.mintPublic(address, amount);
-            const publicBalance = await asset.methods.balance_of_public(address).simulate({
-                from: address
-            });
-            this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
-            expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
-            tokenSim.mintPrivate(address, amount);
-            const privateBalance = await asset.methods.balance_of_private(address).simulate({
-                from: address
-            });
-            this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
-            expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
-            const totalSupply = await asset.methods.total_supply().simulate({
-                from: address
-            });
-            this.logger.verbose(`Total supply: ${totalSupply}`);
-            expect(totalSupply).toEqual(tokenSim.totalSupply);
-            return Promise.resolve();
+    async applyMint() {
+        this.logger.info('Applying mint setup');
+        const { fakeProofsAsset: asset, accounts } = this;
+        const privateAmount = 10000n;
+        const publicAmount = 10000n;
+        this.logger.verbose(`Minting ${privateAmount + publicAmount} publicly...`);
+        await asset.methods.mint_to_public(accounts[0], privateAmount + publicAmount).send({
+            from: accounts[0]
+        });
+        this.logger.verbose(`Transferring ${privateAmount} to private...`);
+        await asset.methods.transfer_to_private(accounts[0], privateAmount).send({
+            from: accounts[0]
+        });
+        this.logger.info(`Minting complete`);
+        const { fakeProofsAsset, accounts: [address], tokenSim } = this;
+        tokenSim.mintPublic(address, publicAmount);
+        const { result: publicBalance } = await fakeProofsAsset.methods.balance_of_public(address).simulate({
+            from: address
+        });
+        this.logger.verbose(`Public balance of wallet 0: ${publicBalance}`);
+        expect(publicBalance).toEqual(this.tokenSim.balanceOfPublic(address));
+        tokenSim.mintPrivate(address, publicAmount);
+        const { result: privateBalance } = await fakeProofsAsset.methods.balance_of_private(address).simulate({
+            from: address
+        });
+        this.logger.verbose(`Private balance of wallet 0: ${privateBalance}`);
+        expect(privateBalance).toEqual(tokenSim.balanceOfPrivate(address));
+        const { result: totalSupply } = await fakeProofsAsset.methods.total_supply().simulate({
+            from: address
         });
+        this.logger.verbose(`Total supply: ${totalSupply}`);
+        expect(totalSupply).toEqual(tokenSim.totalSupply);
     }
 }

package/dest/fixtures/elu_monitor.d.ts

@@ -0,0 +1,21 @@
+/** Samples event-loop utilization, delay histogram, and heap usage per test, writing columnar text to a file. */
+export declare class EluMonitor {
+    private filePath;
+    private intervalMs;
+    private timer;
+    private lastELU;
+    private histogram;
+    private testName;
+    private testStart;
+    private eluSamples;
+    constructor(filePath: string, intervalMs?: number);
+    /** Begin sampling for a test. Writes a header line and starts the periodic sampler. */
+    startTest(testName: string): void;
+    /** Stop sampling and write a summary line. */
+    stopTest(): void;
+    /** Alias for stopTest — call on process exit to flush any remaining data. */
+    stop(): void;
+    private sample;
+    private writeSummary;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWx1X21vbml0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy9lbHVfbW9uaXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxpSEFBaUg7QUFDakgscUJBQWEsVUFBVTtJQUNyQixPQUFPLENBQUMsUUFBUSxDQUFTO0lBQ3pCLE9BQU8sQ0FBQyxVQUFVLENBQVM7SUFDM0IsT0FBTyxDQUFDLEtBQUssQ0FBNkM7SUFDMUQsT0FBTyxDQUFDLE9BQU8sQ0FBbUM7SUFDbEQsT0FBTyxDQUFDLFNBQVMsQ0FBb0I7SUFDckMsT0FBTyxDQUFDLFFBQVEsQ0FBcUI7SUFDckMsT0FBTyxDQUFDLFNBQVMsQ0FBcUI7SUFDdEMsT0FBTyxDQUFDLFVBQVUsQ0FBZ0I7SUFFbEMsWUFBWSxRQUFRLEVBQUUsTUFBTSxFQUFFLFVBQVUsQ0FBQyxFQUFFLE1BQU0sRUFJaEQ7SUFFRCx1RkFBdUY7SUFDdkYsU0FBUyxDQUFDLFFBQVEsRUFBRSxNQUFNLEdBQUcsSUFBSSxDQW1CaEM7SUFFRCw4Q0FBOEM7SUFDOUMsUUFBUSxJQUFJLElBQUksQ0FtQmY7SUFFRCwrRUFBNkU7SUFDN0UsSUFBSSxJQUFJLElBQUksQ0FFWDtJQUVELE9BQU8sQ0FBQyxNQUFNO0lBOEJkLE9BQU8sQ0FBQyxZQUFZO0NBbUJyQiJ9

package/dest/fixtures/elu_monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elu_monitor.d.ts","sourceRoot":"","sources":["../../src/fixtures/elu_monitor.ts"],"names":[],"mappings":"AAKA,iHAAiH;AACjH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAA6C;IAC1D,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,UAAU,CAAgB;IAElC,YAAY,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAIhD;IAED,uFAAuF;IACvF,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAmBhC;IAED,8CAA8C;IAC9C,QAAQ,IAAI,IAAI,CAmBf;IAED,+EAA6E;IAC7E,IAAI,IAAI,IAAI,CAEX;IAED,OAAO,CAAC,MAAM;IA8Bd,OAAO,CAAC,YAAY;CAmBrB"}

package/dest/fixtures/elu_monitor.js

@@ -0,0 +1,102 @@
+import { appendFileSync } from 'node:fs';
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
+const NANOS_PER_MS = 1_000_000;
+/** Samples event-loop utilization, delay histogram, and heap usage per test, writing columnar text to a file. */ export class EluMonitor {
+    filePath;
+    intervalMs;
+    timer;
+    lastELU;
+    histogram;
+    testName;
+    testStart;
+    eluSamples = [];
+    constructor(filePath, intervalMs){
+        this.filePath = filePath;
+        this.intervalMs = intervalMs ?? 2000;
+        this.histogram = monitorEventLoopDelay({
+            resolution: 20
+        });
+    }
+    /** Begin sampling for a test. Writes a header line and starts the periodic sampler. */ startTest(testName) {
+        this.stopTest();
+        this.testName = testName;
+        this.testStart = performance.now();
+        this.eluSamples = [];
+        appendFileSync(this.filePath, `\n=== Test: ${testName} ===\n`);
+        appendFileSync(this.filePath, padColumns('TIME', 'ELU', 'EL_DLY_P50', 'EL_DLY_P99', 'EL_DLY_MAX', 'HEAP_MB') + '\n');
+        this.lastELU = performance.eventLoopUtilization();
+        this.histogram.enable();
+        this.timer = setInterval(()=>this.sample(), this.intervalMs);
+        // Allow the process to exit even if the timer is still running.
+        this.timer.unref();
+    }
+    /** Stop sampling and write a summary line. */ stopTest() {
+        if (!this.timer) {
+            return;
+        }
+        // Take a final sample before stopping.
+        this.sample();
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.histogram.disable();
+        this.histogram.reset();
+        this.writeSummary();
+        this.lastELU = undefined;
+        this.testName = undefined;
+        this.testStart = undefined;
+        this.eluSamples = [];
+    }
+    /** Alias for stopTest — call on process exit to flush any remaining data. */ stop() {
+        this.stopTest();
+    }
+    sample() {
+        const newELU = performance.eventLoopUtilization();
+        const delta = performance.eventLoopUtilization(newELU, this.lastELU);
+        this.lastELU = newELU;
+        const elu = delta.utilization;
+        this.eluSamples.push(elu);
+        const p50 = this.histogram.percentile(50) / NANOS_PER_MS;
+        const p99 = this.histogram.percentile(99) / NANOS_PER_MS;
+        const max = this.histogram.max / NANOS_PER_MS;
+        const heapMb = Math.round(process.memoryUsage().heapUsed / (1024 * 1024));
+        const now = new Date();
+        const time = [
+            now.getHours(),
+            now.getMinutes(),
+            now.getSeconds()
+        ].map((n)=>String(n).padStart(2, '0')).join(':');
+        const line = padColumns(time, elu.toFixed(2), `${p50.toFixed(1)}ms`, `${p99.toFixed(1)}ms`, `${max.toFixed(1)}ms`, String(heapMb));
+        appendFileSync(this.filePath, line + '\n');
+        // Reset histogram so next sample only reflects the new interval.
+        this.histogram.reset();
+    }
+    writeSummary() {
+        if (this.eluSamples.length === 0 || this.testStart === undefined) {
+            return;
+        }
+        const mean = this.eluSamples.reduce((a, b)=>a + b, 0) / this.eluSamples.length;
+        const maxElu = Math.max(...this.eluSamples);
+        const sorted = [
+            ...this.eluSamples
+        ].sort((a, b)=>a - b);
+        const p90Elu = sorted[Math.floor(sorted.length * 0.9)] ?? maxElu;
+        const durationS = ((performance.now() - this.testStart) / 1000).toFixed(1);
+        let summary = `--- Summary: mean_elu=${mean.toFixed(2)} max_elu=${maxElu.toFixed(2)} p90_elu=${p90Elu.toFixed(2)} duration=${durationS}s`;
+        if (maxElu > 0.85) {
+            summary += ' WARNING:ELU>0.85';
+        }
+        summary += ' ---\n';
+        appendFileSync(this.filePath, summary);
+    }
+}
+function padColumns(...cols) {
+    const widths = [
+        11,
+        7,
+        12,
+        12,
+        12,
+        8
+    ];
+    return cols.map((col, i)=>col.padEnd(widths[i] ?? 10)).join('');
+}

package/dest/fixtures/fixtures.d.ts

@@ -1,8 +1,89 @@
+import type { AztecNode } from '@aztec/aztec.js/node';
+import type { GasFees } from '@aztec/stdlib/gas';
 export declare const METRICS_PORT = 4318;
+/** Default fee padding applied to predicted min fees in e2e tests. */
+export declare const DEFAULT_MIN_FEE_PADDING = 5;
+/**
+ * Large fee padding for txs that may be mined significantly later than when they were created,
+ * such as cloned txs in throughput/capacity benchmarks, where fees may spike between creation and mining.
+ */
+export declare const LARGE_MIN_FEE_PADDING = 15;
+/**
+ * Fee padding used by tests running under proposer pipelining. Under pipelining the fee-asset
+ * price modifier evolves faster across the build/publish gap, so client-set maxFeesPerGas (sized
+ * for the default 5x padding) was getting bumped past by the time the tx mined a few slots later.
+ * Observed worst case in CI: fee evolved ~20x between PXE snapshot and inclusion, exceeding even
+ * LARGE_MIN_FEE_PADDING (15x).
+ */
+export declare const PIPELINED_FEE_PADDING = 30;
+/**
+ * Setup option preset that opts a test into proposer pipelining. Use with `setup()`:
+ *
+ *     await setup(N, { ...PIPELINING_SETUP_OPTS, ...otherOpts });
+ *
+ * The preset runs the production Sequencer with the always-enforced timetable at real (wall-clock)
+ * timing, yielding exactly 2 blocks per slot. It sets:
+ * - `inboxLag: 2` so the sequencer sources L1->L2 messages from checkpoint N-1 (already sealed),
+ *   avoiding `L1ToL2MessagesNotReadyError` when building for slot N during slot N-1.
+ * - `minTxsPerBlock: 0` so empty checkpoints land even when a tx arrives late in the build window
+ *   (otherwise the chain stalls on alternating slots).
+ * - `aztecSlotDuration: 12` / `ethereumSlotDuration: 4` so the pipelined cycle fits inside the
+ *   default 300s Jest hook budget. Tests that depend on the env-default 72s/12s should override.
+ * - `blockDurationMs: 3000` to cut exactly 2 blocks per slot. With `ethereumSlotDuration < 8` the
+ *   timing model normalizes to `init=0.5`, `assemble=0.5`, `P=0`, `minExec=1`, so
+ *   `maxBlocks = floor((S - init - (assemble + 2P + D)) / D) = floor((12 - 0.5 - (0.5 + 0 + 3)) / 3)
+ *   = floor(8/3) = 2`. (`blockDurationMs: 2000` would give 4 blocks/slot; 3000 also matches the
+ *   production default.)
+ * - `walletMinFeePadding: PIPELINED_FEE_PADDING` (30x) to absorb the wider fee evolution window.
+ */
+export declare const PIPELINING_SETUP_OPTS: {
+    readonly inboxLag: 2;
+    readonly minTxsPerBlock: 0;
+    readonly aztecSlotDuration: 12;
+    readonly ethereumSlotDuration: 4;
+    readonly blockDurationMs: 3000;
+    readonly walletMinFeePadding: 30;
+};
+/**
+ * Setup option preset that opts a test into the deterministic AutomineSequencer path.
+ * Use only for single-sequencer tests that don't exercise block-building or consensus
+ * (e.g. e2e_token, e2e_amm, e2e_authwit). Not compatible with `p2p/*`,
+ * `multi-node/*`, `e2e_block_building`, or any multi-validator suite.
+ *
+ *     await setup(N, { ...AUTOMINE_E2E_OPTS, ...otherOpts });
+ *
+ * The preset:
+ * - Swaps the production Sequencer for an AutomineSequencer that builds one block per
+ *   submitted tx, publishes synchronously to L1, and owns all time control through a
+ *   serial queue (see `sequencer-client/src/sequencer/automine/automine_sequencer.ts`).
+ * - Disables the validator client (the AutomineSequencer needs none).
+ * - Uses `inboxLag: 1` (synchronous) since the AutomineSequencer publishes one block per tx.
+ * - Runs anvil at a 4s interval (`ethereumSlotDuration: 4`); at runtime the AutomineSequencer
+ *   flips anvil into automine so each submitted tx mines its L1 block immediately. Initial L1
+ *   contract deployment (which runs before the sequencer starts) is mined immediately too via the
+ *   global `automineL1Setup` default in `setup()`, instead of stalling on the 4s interval.
+ *
+ * Requires `aztecTargetCommitteeSize: 0`, which is the e2e default at `setup.ts:317`.
+ */
+export declare const AUTOMINE_E2E_OPTS: {
+    readonly useAutomineSequencer: true;
+    readonly inboxLag: 1;
+    readonly minTxsPerBlock: 0;
+    readonly aztecSlotDuration: 12;
+    readonly ethereumSlotDuration: 4;
+    readonly walletMinFeePadding: 30;
+};
+/** Returns worst-case predicted min fees with padding applied, mirroring the BaseWallet pattern. */
+export declare function getPaddedMaxFeesPerGas(node: AztecNode, padding?: number): Promise<GasFees>;
 export declare const shouldCollectMetrics: () => 4318 | undefined;
+/** Returns the boot node UDP port from environment variable or default value. */
+export declare function getBootNodeUdpPort(): number;
+/** Returns the anvil port from environment variable or default value. */
+export declare function getAnvilPort(): number;
 export declare const TEST_PEER_CHECK_INTERVAL_MS = 1000;
-export declare const TEST_MAX_TX_POOL_SIZE: number;
+export declare const TEST_MAX_PENDING_TX_POOL_COUNT = 10000;
 export declare const MNEMONIC = "test test test test test test test test test test test junk";
+export declare const L1_DIRECT_WRITE_ACCOUNT_INDEX = 1;
 export declare const privateKey: Buffer<ArrayBuffer>;
 export declare const privateKey2: Buffer<ArrayBuffer>;
 export declare const U128_UNDERFLOW_ERROR = "Assertion failed: attempt to subtract with overflow";
@@ -12,5 +93,4 @@ export declare const DUPLICATE_NULLIFIER_ERROR: RegExp;
 export declare const NO_L1_TO_L2_MSG_ERROR: RegExp;
 export declare const STATIC_CALL_STATE_MODIFICATION_ERROR: RegExp;
 export declare const STATIC_CONTEXT_ASSERTION_ERROR: RegExp;
-export declare const DEFAULT_BLOB_SINK_PORT = "5052";
-//# sourceMappingURL=fixtures.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZml4dHVyZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maXh0dXJlcy9maXh0dXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN0RCxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVqRCxlQUFPLE1BQU0sWUFBWSxPQUFPLENBQUM7QUFFakMsc0VBQXNFO0FBQ3RFLGVBQU8sTUFBTSx1QkFBdUIsSUFBSSxDQUFDO0FBRXpDOzs7R0FHRztBQUNILGVBQU8sTUFBTSxxQkFBcUIsS0FBSyxDQUFDO0FBRXhDOzs7Ozs7R0FNRztBQUNILGVBQU8sTUFBTSxxQkFBcUIsS0FBSyxDQUFDO0FBRXhDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHO0FBQ0gsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7OztDQU94QixDQUFDO0FBRVg7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBb0JHO0FBQ0gsZUFBTyxNQUFNLGlCQUFpQjs7Ozs7OztDQU9wQixDQUFDO0FBRVgsb0dBQW9HO0FBQ3BHLHdCQUFzQixzQkFBc0IsQ0FBQyxJQUFJLEVBQUUsU0FBUyxFQUFFLE9BQU8sU0FBMEIsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBT2pIO0FBRUQsZUFBTyxNQUFNLG9CQUFvQix3QkFLaEMsQ0FBQztBQUVGLGlGQUFpRjtBQUNqRix3QkFBZ0Isa0JBQWtCLElBQUksTUFBTSxDQUUzQztBQUVELHlFQUF5RTtBQUN6RSx3QkFBZ0IsWUFBWSxJQUFJLE1BQU0sQ0FFckM7QUFFRCxlQUFPLE1BQU0sMkJBQTJCLE9BQU8sQ0FBQztBQUNoRCxlQUFPLE1BQU0sOEJBQThCLFFBQVMsQ0FBQztBQUVyRCxlQUFPLE1BQU0sUUFBUSxnRUFBZ0UsQ0FBQztBQU90RixlQUFPLE1BQU0sNkJBQTZCLElBQUksQ0FBQztBQUUvQyxlQUFPLE1BQU0sVUFBVSxxQkFBeUYsQ0FBQztBQUNqSCxlQUFPLE1BQU0sV0FBVyxxQkFBeUYsQ0FBQztBQUdsSCxlQUFPLE1BQU0sb0JBQW9CLHdEQUF3RCxDQUFDO0FBQzFGLGVBQU8sTUFBTSxtQkFBbUIsbURBQW1ELENBQUM7QUFDcEYsZUFBTyxNQUFNLHFCQUFxQiwrRUFBK0UsQ0FBQztBQUVsSCxlQUFPLE1BQU0seUJBQXlCLFFBQWdDLENBQUM7QUFDdkUsZUFBTyxNQUFNLHFCQUFxQixRQUN3RSxDQUFDO0FBQzNHLGVBQU8sTUFBTSxvQ0FBb0MsUUFBMEMsQ0FBQztBQUM1RixlQUFPLE1BQU0sOEJBQThCLFFBQWtFLENBQUMifQ==