@aztec/end-to-end 0.0.1-commit.fcb71a6 → 0.0.1-commit.ff7989d6c

package/dest/e2e_p2p/p2p_network.d.ts

@@ -11,10 +11,9 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import type { BootstrapNode } from '@aztec/p2p/bootstrap';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import type { TestWallet } from '@aztec/test-wallet/server';
 import { type GetContractReturnType } from 'viem';
-import { type SubsystemsContext } from '../fixtures/snapshot_manager.js';
-import { type SetupOptions } from '../fixtures/utils.js';
+import { type EndToEndContext, type SetupOptions } from '../fixtures/setup.js';
+import type { TestWallet } from '../test-wallet/test_wallet.js';
 export declare const WAIT_FOR_TX_TIMEOUT: number;
 export declare const SHORTENED_BLOCK_TIME_CONFIG_NO_PRUNES: {
     aztecSlotDuration: number;
@@ -28,7 +27,7 @@ export declare class P2PNetworkTest {
     numberOfValidators: number;
     numberOfNodes: number;
     private metricsPort?;
-    private snapshotManager;
+    context: EndToEndContext;
     baseAccountPrivateKey: `0x${string}`;
     baseAccount: {
         address: `0x${string}`;
@@ -255,7 +254,7 @@ export declare class P2PNetworkTest {
     };
     logger: Logger;
     monitor: ChainMonitor;
-    ctx: SubsystemsContext;
+    ctx: EndToEndContext;
     attesterPrivateKeys: `0x${string}`[];
     attesterPublicKeys: string[];
     peerIdPrivateKeys: string[];
@@ -266,6 +265,8 @@ export declare class P2PNetworkTest {
     defaultAccountAddress?: AztecAddress;
     spamContract?: SpamContract;
     bootstrapNode?: BootstrapNode;
+    private setupOptions;
+    private deployL1ContractsArgs;
     constructor(testName: string, bootstrapNodeEnr: string, bootNodePort: number, numberOfValidators: number, initialValidatorConfig: SetupOptions, numberOfNodes?: number, metricsPort?: number | undefined, startProverNode?: boolean);
     static create({ testName, numberOfNodes, numberOfValidators, basePort, metricsPort, initialConfig, startProverNode }: {
         testName: string;
@@ -281,7 +282,7 @@ export declare class P2PNetworkTest {
     getValidators(): {
         validators: Operator[];
     };
-    applyBaseSnapshots(): Promise<void>;
+    applyBaseSetup(): Promise<void>;
     setupAccount(): Promise<void>;
     deploySpamContract(): Promise<void>;
     removeInitialNode(): Promise<void>;
@@ -311,4 +312,4 @@ export declare class P2PNetworkTest {
         slashFactory: SlashFactoryContract;
     }>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/e2e_p2p/p2p_network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"p2p_network.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/p2p_network.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"p2p_network.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/p2p_network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAc,MAAM,2BAA2B,CAAC;AAGrE,OAAO,EACL,KAAK,8BAA8B,EAEnC,cAAc,EACd,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AAI1E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAA4B,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGlF,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAa,UAAU,EAAgB,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAK9D,OAAO,EAAE,KAAK,qBAAqB,EAA2B,MAAM,MAAM,CAAC;AAG3E,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,YAAY,EAMlB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAKhE,eAAO,MAAM,mBAAmB,QAA0C,CAAC;AAE3E,eAAO,MAAM,qCAAqC;;;;CAIjD,CAAC;AAEF,qBAAa,cAAc;aA6BP,QAAQ,EAAE,MAAM;IACzB,gBAAgB,EAAE,MAAM;IACxB,YAAY,EAAE,MAAM;IACpB,kBAAkB,EAAE,MAAM;IAE1B,aAAa;IAEpB,OAAO,CAAC,WAAW,CAAC;IAnCf,OAAO,EAAG,eAAe,CAAC;IAC1B,qBAAqB,EAAE,KAAK,MAAM,EAAE,CAAC;IACrC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAC;IAEZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAG,YAAY,CAAC;IAEvB,GAAG,EAAG,eAAe,CAAC;IACtB,mBAAmB,EAAE,KAAK,MAAM,EAAE,EAAE,CAAM;IAC1C,kBAAkB,EAAE,MAAM,EAAE,CAAM;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,UAAU,EAAE,QAAQ,EAAE,CAAM;IAE5B,gBAAgB,EAAE,kBAAkB,EAAE,CAAM;IAC5C,mBAAmB,EAAE,kBAAkB,EAAE,CAAM;IAG/C,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,qBAAqB,CAAC,EAAE,YAAY,CAAC;IACrC,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,aAAa,CAAC,EAAE,aAAa,CAAC;IAGrC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,qBAAqB,CAAM;IAEnC,YACkB,QAAQ,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EACjC,sBAAsB,EAAE,YAAY,EAC7B,aAAa,SAAI,EAEhB,WAAW,CAAC,oBAAQ,EAC5B,eAAe,CAAC,EAAE,OAAO,EAmD1B;IAED,OAAa,MAAM,CAAC,EAClB,QAAQ,EACR,aAAa,EACb,kBAAkB,EAClB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,eAAe,EAChB,EAAE;QACD,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,YAAY,CAAC;QAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,2BAqBA;IAED,IAAI,aAAa,uBAKhB;IAEK,gBAAgB,kBAWrB;IAED,aAAa;;MAgBZ;IAEK,cAAc,kBAwEnB;IAEK,YAAY,kBAYjB;IAEK,kBAAkB,kBAQvB;IAEK,iBAAiB,kBAUtB;IAEK,WAAW;;;OAEhB;YAEa,YAAY;IAQpB,KAAK,kBA0BV;IAEK,SAAS,CAAC,KAAK,EAAE,gBAAgB,EAAE,iBAWxC;IAED;;;;;;;;;OASG;IACG,0BAA0B,CAC9B,KAAK,EAAE,gBAAgB,EAAE,EACzB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,cAAc,SAAK,EACnB,oBAAoB,SAAM,iBA+C3B;IAEK,QAAQ,kBAIb;IAEK,YAAY,IAAI,OAAO,CAAC;QAC5B,MAAM,EAAE,cAAc,CAAC;QACvB,eAAe,EAAE,qBAAqB,CAAC,OAAO,UAAU,EAAE,UAAU,CAAC,CAAC;QACtE,gBAAgB,EAAE,8BAA8B,GAAG,6BAA6B,GAAG,SAAS,CAAC;QAC7F,YAAY,EAAE,oBAAoB,CAAC;KACpC,CAAC,CAyBD;CACF"}

package/dest/e2e_p2p/p2p_network.js

@@ -4,7 +4,7 @@ import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
 import { GSEContract, RollupContract } from '@aztec/ethereum/contracts';
 import { deployL1Contract } from '@aztec/ethereum/deploy-l1-contract';
 import { MultiAdderArtifact } from '@aztec/ethereum/l1-artifacts';
-import { createL1TxUtilsFromViemWallet } from '@aztec/ethereum/l1-tx-utils';
+import { createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { ChainMonitor } from '@aztec/ethereum/test';
 import { EpochNumber } from '@aztec/foundation/branded-types';
 import { SecretValue } from '@aztec/foundation/config';
@@ -15,14 +15,14 @@ import { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
 import { createBootstrapNodeFromPrivateKey, getBootstrapNodeEnr } from '@aztec/p2p/test-helpers';
 import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import { TopicType } from '@aztec/stdlib/p2p';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 import { getGenesisValues } from '@aztec/world-state/testing';
 import getPort from 'get-port';
 import { getAddress, getContract } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
+import { deployAccounts, getPrivateKeyFromIndex, getSponsoredFPCAddress, setup, teardown } from '../fixtures/setup.js';
 import { ATTESTER_PRIVATE_KEYS_START_INDEX, createValidatorConfig, generatePrivateKeys } from '../fixtures/setup_p2p_test.js';
-import { createSnapshotManager, deployAccounts } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
 const BOOTSTRAP_NODE_PRIVATE_KEY = '080212208f988fc0899e4a73a5aee4d271a5f20670603a756ad8d84f2c94263a6427c591';
@@ -40,7 +40,7 @@ export class P2PNetworkTest {
     numberOfValidators;
     numberOfNodes;
     metricsPort;
-    snapshotManager;
+    context;
     baseAccountPrivateKey;
     baseAccount;
     logger;
@@ -57,6 +57,9 @@ export class P2PNetworkTest {
     defaultAccountAddress;
     spamContract;
     bootstrapNode;
+    // Store setup options for use in setup()
+    setupOptions;
+    deployL1ContractsArgs;
     constructor(testName, bootstrapNodeEnr, bootNodePort, numberOfValidators, initialValidatorConfig, numberOfNodes = 0, // If set enable metrics collection
     metricsPort, startProverNode){
         this.testName = testName;
@@ -78,7 +81,8 @@ export class P2PNetworkTest {
         this.attesterPrivateKeys = generatePrivateKeys(ATTESTER_PRIVATE_KEYS_START_INDEX + numberOfNodes, numberOfValidators);
         this.attesterPublicKeys = this.attesterPrivateKeys.map((privateKey)=>privateKeyToAccount(privateKey).address);
         const zkPassportParams = ZkPassportProofParams.random();
-        this.snapshotManager = createSnapshotManager(`e2e_p2p_network/${testName}`, process.env.E2E_DATA_PATH, {
+        // Store setup options for later use
+        this.setupOptions = {
             ...initialValidatorConfig,
             ethereumSlotDuration: initialValidatorConfig.ethereumSlotDuration ?? l1ContractsConfig.ethereumSlotDuration,
             aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
@@ -89,8 +93,10 @@ export class P2PNetworkTest {
             aztecTargetCommitteeSize: numberOfValidators,
             metricsPort: metricsPort,
             numberOfInitialFundedAccounts: 2,
-            startProverNode
-        }, {
+            startProverNode,
+            walletMinFeePadding: 2.0
+        };
+        this.deployL1ContractsArgs = {
             ...initialValidatorConfig,
             aztecEpochDuration: initialValidatorConfig.aztecEpochDuration ?? l1ContractsConfig.aztecEpochDuration,
             slashingRoundSizeInEpochs: initialValidatorConfig.slashingRoundSizeInEpochs ?? l1ContractsConfig.slashingRoundSizeInEpochs,
@@ -104,7 +110,7 @@ export class P2PNetworkTest {
                 zkPassportDomain: zkPassportParams.domain,
                 zkPassportScope: zkPassportParams.scope
             }
-        });
+        };
     }
     static async create({ testName, numberOfNodes, numberOfValidators, basePort, metricsPort, initialConfig, startProverNode }) {
         const port = basePort || await getPort();
@@ -115,17 +121,16 @@ export class P2PNetworkTest {
     }
     get fundedAccount() {
         if (!this.deployedAccounts[0]) {
-            throw new Error('Call snapshot t.setupAccount to create a funded account.');
+            throw new Error('Call setupAccount to create a funded account.');
         }
         return this.deployedAccounts[0];
     }
     async addBootstrapNode() {
-        await this.snapshotManager.snapshot('add-bootstrap-node', async ({ aztecNodeConfig })=>{
-            const telemetry = await getEndToEndTestTelemetryClient(this.metricsPort);
-            this.bootstrapNode = await createBootstrapNodeFromPrivateKey(BOOTSTRAP_NODE_PRIVATE_KEY, this.bootNodePort, telemetry, aztecNodeConfig);
-            // Overwrite enr with updated info
-            this.bootstrapNodeEnr = this.bootstrapNode.getENR().encodeTxt();
-        });
+        this.logger.info('Adding bootstrap node');
+        const telemetry = await getEndToEndTestTelemetryClient(this.metricsPort);
+        this.bootstrapNode = await createBootstrapNodeFromPrivateKey(BOOTSTRAP_NODE_PRIVATE_KEY, this.bootNodePort, telemetry, this.context.config);
+        // Overwrite enr with updated info
+        this.bootstrapNodeEnr = this.bootstrapNode.getENR().encodeTxt();
     }
     getValidators() {
         const validators = [];
@@ -143,124 +148,127 @@ export class P2PNetworkTest {
             validators
         };
     }
-    async applyBaseSnapshots() {
+    async applyBaseSetup() {
         await this.addBootstrapNode();
-        await this.snapshotManager.snapshot('add-validators', async ({ deployL1ContractsValues, cheatCodes })=>{
-            const rollup = getContract({
-                address: deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
-                abi: RollupAbi,
-                client: deployL1ContractsValues.l1Client
-            });
-            this.logger.info(`Adding ${this.numberOfValidators} validators`);
-            const stakingAsset = getContract({
-                address: deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
-                abi: TestERC20Abi,
-                client: deployL1ContractsValues.l1Client
-            });
-            const { address: multiAdderAddress } = await deployL1Contract(deployL1ContractsValues.l1Client, MultiAdderArtifact.contractAbi, MultiAdderArtifact.contractBytecode, [
-                rollup.address,
-                deployL1ContractsValues.l1Client.account.address
-            ]);
-            const multiAdder = getContract({
-                address: multiAdderAddress.toString(),
-                abi: MultiAdderArtifact.contractAbi,
-                client: deployL1ContractsValues.l1Client
-            });
-            const stakeNeeded = await rollup.read.getActivationThreshold() * BigInt(this.numberOfValidators);
-            await Promise.all([
-                await stakingAsset.write.mint([
-                    multiAdder.address,
-                    stakeNeeded
-                ], {})
-            ].map((txHash)=>deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-                    hash: txHash
-                })));
-            const { validators } = this.getValidators();
-            this.validators = validators;
-            const gseAddress = deployL1ContractsValues.l1ContractAddresses.gseAddress;
-            if (!gseAddress) {
-                throw new Error('GSE contract not deployed');
-            }
-            const gseContract = new GSEContract(deployL1ContractsValues.l1Client, gseAddress.toString());
-            const makeValidatorTuples = async (validator)=>{
-                const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
-                return {
-                    attester: validator.attester.toString(),
-                    withdrawer: validator.withdrawer.toString(),
-                    ...registrationTuple
-                };
+        this.logger.info('Adding validators');
+        const rollup = getContract({
+            address: this.context.deployL1ContractsValues.l1ContractAddresses.rollupAddress.toString(),
+            abi: RollupAbi,
+            client: this.context.deployL1ContractsValues.l1Client
+        });
+        this.logger.info(`Adding ${this.numberOfValidators} validators`);
+        const stakingAsset = getContract({
+            address: this.context.deployL1ContractsValues.l1ContractAddresses.stakingAssetAddress.toString(),
+            abi: TestERC20Abi,
+            client: this.context.deployL1ContractsValues.l1Client
+        });
+        const { address: multiAdderAddress } = await deployL1Contract(this.context.deployL1ContractsValues.l1Client, MultiAdderArtifact.contractAbi, MultiAdderArtifact.contractBytecode, [
+            rollup.address,
+            this.context.deployL1ContractsValues.l1Client.account.address
+        ]);
+        const multiAdder = getContract({
+            address: multiAdderAddress.toString(),
+            abi: MultiAdderArtifact.contractAbi,
+            client: this.context.deployL1ContractsValues.l1Client
+        });
+        const stakeNeeded = await rollup.read.getActivationThreshold() * BigInt(this.numberOfValidators);
+        await Promise.all([
+            await stakingAsset.write.mint([
+                multiAdder.address,
+                stakeNeeded
+            ], {})
+        ].map((txHash)=>this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+                hash: txHash
+            })));
+        const { validators } = this.getValidators();
+        this.validators = validators;
+        const gseAddress = this.context.deployL1ContractsValues.l1ContractAddresses.gseAddress;
+        if (!gseAddress) {
+            throw new Error('GSE contract not deployed');
+        }
+        const gseContract = new GSEContract(this.context.deployL1ContractsValues.l1Client, gseAddress.toString());
+        const makeValidatorTuples = async (validator)=>{
+            const registrationTuple = await gseContract.makeRegistrationTuple(validator.bn254SecretKey.getValue());
+            return {
+                attester: validator.attester.toString(),
+                withdrawer: validator.withdrawer.toString(),
+                ...registrationTuple
             };
-            const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
-            await deployL1ContractsValues.l1Client.waitForTransactionReceipt({
-                hash: await multiAdder.write.addValidators([
-                    validatorTuples
-                ])
-            });
-            await cheatCodes.rollup.advanceToEpoch(EpochNumber.fromBigInt(BigInt(await cheatCodes.rollup.getEpoch()) + await rollup.read.getLagInEpochsForValidatorSet() + 1n));
-            // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-            await this._sendDummyTx(deployL1ContractsValues.l1Client);
+        };
+        const validatorTuples = await Promise.all(validators.map(makeValidatorTuples));
+        await this.context.deployL1ContractsValues.l1Client.waitForTransactionReceipt({
+            hash: await multiAdder.write.addValidators([
+                validatorTuples
+            ])
         });
+        await this.context.cheatCodes.rollup.advanceToEpoch(EpochNumber.fromBigInt(BigInt(await this.context.cheatCodes.rollup.getEpoch()) + await rollup.read.getLagInEpochsForValidatorSet() + 1n));
+        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+        await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
     }
     async setupAccount() {
-        await this.snapshotManager.snapshot('setup-account', deployAccounts(1, this.logger), ({ deployedAccounts }, { wallet })=>{
-            this.deployedAccounts = deployedAccounts;
-            [{ address: this.defaultAccountAddress }] = deployedAccounts;
-            this.wallet = wallet;
-            return Promise.resolve();
+        this.logger.info('Setting up account');
+        const { deployedAccounts } = await deployAccounts(1, this.logger)({
+            wallet: this.context.wallet,
+            initialFundedAccounts: this.context.initialFundedAccounts
         });
+        this.deployedAccounts = deployedAccounts;
+        [{ address: this.defaultAccountAddress }] = deployedAccounts;
+        this.wallet = this.context.wallet;
     }
     async deploySpamContract() {
-        await this.snapshotManager.snapshot('add-spam-contract', async ()=>{
-            if (!this.wallet) {
-                throw new Error('Call snapshot t.setupAccount before deploying account contract');
-            }
-            const spamContract = await SpamContract.deploy(this.wallet).send({
-                from: this.defaultAccountAddress
-            }).deployed();
-            return {
-                contractAddress: spamContract.address
-            };
-        }, ({ contractAddress })=>{
-            if (!this.wallet) {
-                throw new Error('Call snapshot t.setupAccount before deploying account contract');
-            }
-            this.spamContract = SpamContract.at(contractAddress, this.wallet);
-            return Promise.resolve();
+        this.logger.info('Deploying spam contract');
+        if (!this.wallet) {
+            throw new Error('Call setupAccount before deploying spam contract');
+        }
+        const spamContract = await SpamContract.deploy(this.wallet).send({
+            from: this.defaultAccountAddress
         });
+        this.spamContract = spamContract;
     }
     async removeInitialNode() {
-        await this.snapshotManager.snapshot('remove-initial-validator', async ({ deployL1ContractsValues, aztecNode, dateProvider })=>{
-            // Send and await a tx to make sure we mine a block for the warp to correctly progress.
-            const { receipt } = await this._sendDummyTx(deployL1ContractsValues.l1Client);
-            const block = await deployL1ContractsValues.l1Client.getBlock({
-                blockNumber: receipt.blockNumber
-            });
-            dateProvider.setTime(Number(block.timestamp) * 1000);
-            await aztecNode.stop();
+        this.logger.info('Removing initial node');
+        // Send and await a tx to make sure we mine a block for the warp to correctly progress.
+        const { receipt } = await this._sendDummyTx(this.context.deployL1ContractsValues.l1Client);
+        const block = await this.context.deployL1ContractsValues.l1Client.getBlock({
+            blockNumber: receipt.blockNumber
         });
+        this.context.dateProvider.setTime(Number(block.timestamp) * 1000);
+        await this.context.aztecNodeService.stop();
     }
     async sendDummyTx() {
         return await this._sendDummyTx(this.ctx.deployL1ContractsValues.l1Client);
     }
     async _sendDummyTx(l1Client) {
-        const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+        const l1TxUtils = createL1TxUtils(l1Client);
         return await l1TxUtils.sendAndMonitorTransaction({
             to: l1Client.account.address,
             value: 1n
         });
     }
     async setup() {
-        this.ctx = await this.snapshotManager.setup();
+        this.logger.info('Setting up subsystems from fresh');
+        this.context = await setup(0, {
+            ...this.setupOptions,
+            fundSponsoredFPC: true,
+            skipAccountDeployment: true,
+            slasherFlavor: this.setupOptions.slasherFlavor ?? this.deployL1ContractsArgs.slasherFlavor ?? 'none',
+            aztecTargetCommitteeSize: 0,
+            l1ContractsArgs: this.deployL1ContractsArgs
+        }, // Use checkpointed chain tip for PXE to avoid issues with blocks being dropped due to pruned anchor blocks.
+        {
+            syncChainTip: 'checkpointed'
+        });
+        this.ctx = this.context;
         const sponsoredFPCAddress = await getSponsoredFPCAddress();
         const initialFundedAccounts = [
-            ...this.ctx.initialFundedAccounts.map((a)=>a.address),
+            ...this.context.initialFundedAccounts.map((a)=>a.address),
             sponsoredFPCAddress
         ];
         const { prefilledPublicData } = await getGenesisValues(initialFundedAccounts);
         this.prefilledPublicData = prefilledPublicData;
-        const rollupContract = RollupContract.getFromL1ContractsValues(this.ctx.deployL1ContractsValues);
-        this.monitor = new ChainMonitor(rollupContract, this.ctx.dateProvider).start();
-        this.monitor.on('l1-block', ({ timestamp })=>this.ctx.dateProvider.setTime(Number(timestamp) * 1000));
+        const rollupContract = RollupContract.getFromL1ContractsValues(this.context.deployL1ContractsValues);
+        this.monitor = new ChainMonitor(rollupContract, this.context.dateProvider).start();
+        this.monitor.on('l1-block', ({ timestamp })=>this.context.dateProvider.setTime(Number(timestamp) * 1000));
     }
     async stopNodes(nodes) {
         this.logger.info('Stopping nodes');
@@ -293,11 +301,24 @@ export class P2PNetworkTest {
             }, `Node ${index} to connect to at least ${minPeerCount} peers`, timeoutSeconds, checkIntervalSeconds);
         }));
         this.logger.warn('All nodes connected to P2P mesh');
+        // Wait for GossipSub mesh to form for the tx topic.
+        // We only require at least 1 mesh peer per node because GossipSub
+        // stops grafting once it reaches Dlo peers and won't fill the mesh to all available peers.
+        this.logger.warn('Waiting for GossipSub mesh to form for tx topic...');
+        await Promise.all(nodes.map(async (node, index)=>{
+            const p2p = node.getP2P();
+            await retryUntil(async ()=>{
+                const meshPeers = await p2p.getGossipMeshPeerCount(TopicType.tx);
+                this.logger.debug(`Node ${index} has ${meshPeers} gossip mesh peers for tx topic`);
+                return meshPeers >= 1 ? true : undefined;
+            }, `Node ${index} to have gossip mesh peers for tx topic`, timeoutSeconds, checkIntervalSeconds);
+        }));
+        this.logger.warn('All nodes have gossip mesh peers for tx topic');
     }
     async teardown() {
         await this.monitor.stop();
         await tryStop(this.bootstrapNode, this.logger);
-        await this.snapshotManager.teardown();
+        await teardown(this.context);
     }
     async getContracts() {
         if (!this.ctx.deployL1ContractsValues) {
@@ -305,7 +326,7 @@ export class P2PNetworkTest {
         }
         const rollup = new RollupContract(this.ctx.deployL1ContractsValues.l1Client, this.ctx.deployL1ContractsValues.l1ContractAddresses.rollupAddress);
         const slasherContract = getContract({
-            address: getAddress(await rollup.getSlasherAddress()),
+            address: getAddress((await rollup.getSlasherAddress()).toString()),
             abi: SlasherAbi,
             client: this.ctx.deployL1ContractsValues.l1Client
         });

package/dest/e2e_p2p/reqresp/utils.d.ts

@@ -0,0 +1,22 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { P2PNetworkTest } from '../p2p_network.js';
+export declare const NUM_VALIDATORS = 6;
+export declare const NUM_TXS_PER_NODE = 4;
+export declare const BOOT_NODE_UDP_PORT: number;
+export declare const createReqrespDataDir: () => string;
+type ReqrespOptions = {
+    disableStatusHandshake?: boolean;
+};
+export declare function createReqrespTest(options?: ReqrespOptions): Promise<P2PNetworkTest>;
+export declare function cleanupReqrespTest(params: {
+    t: P2PNetworkTest;
+    nodes?: AztecNodeService[];
+    dataDir: string;
+}): Promise<void>;
+export declare function runReqrespTxTest(params: {
+    t: P2PNetworkTest;
+    dataDir: string;
+    disableStatusHandshake?: boolean;
+}): Promise<AztecNodeService[]>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lMmVfcDJwL3JlcXJlc3AvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQWdCMUQsT0FBTyxFQUFFLGNBQWMsRUFBdUIsTUFBTSxtQkFBbUIsQ0FBQztBQUl4RSxlQUFPLE1BQU0sY0FBYyxJQUFJLENBQUM7QUFDaEMsZUFBTyxNQUFNLGdCQUFnQixJQUFJLENBQUM7QUFDbEMsZUFBTyxNQUFNLGtCQUFrQixRQUF1QixDQUFDO0FBRXZELGVBQU8sTUFBTSxvQkFBb0IsY0FBMkQsQ0FBQztBQUU3RixLQUFLLGNBQWMsR0FBRztJQUNwQixzQkFBc0IsQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUNsQyxDQUFDO0FBRUYsd0JBQXNCLGlCQUFpQixDQUFDLE9BQU8sR0FBRSxjQUFtQixHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsQ0EwQjdGO0FBRUQsd0JBQXNCLGtCQUFrQixDQUFDLE1BQU0sRUFBRTtJQUFFLENBQUMsRUFBRSxjQUFjLENBQUM7SUFBQyxLQUFLLENBQUMsRUFBRSxnQkFBZ0IsRUFBRSxDQUFDO0lBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQTtDQUFFLGlCQVNsSDtBQUlELHdCQUFzQixnQkFBZ0IsQ0FBQyxNQUFNLEVBQUU7SUFDN0MsQ0FBQyxFQUFFLGNBQWMsQ0FBQztJQUNsQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLHNCQUFzQixDQUFDLEVBQUUsT0FBTyxDQUFDO0NBQ2xDLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixFQUFFLENBQUMsQ0E4SDlCIn0=

package/dest/e2e_p2p/reqresp/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/e2e_p2p/reqresp/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAgB1D,OAAO,EAAE,cAAc,EAAuB,MAAM,mBAAmB,CAAC;AAIxE,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,kBAAkB,QAAuB,CAAC;AAEvD,eAAO,MAAM,oBAAoB,cAA2D,CAAC;AAE7F,KAAK,cAAc,GAAG;IACpB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,cAAc,CAAC,CA0B7F;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAAE,CAAC,EAAE,cAAc,CAAC;IAAC,KAAK,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,iBASlH;AAID,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,CAAC,EAAE,cAAc,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA8H9B"}

package/dest/e2e_p2p/reqresp/utils.js

@@ -0,0 +1,177 @@
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { Tx } from '@aztec/aztec.js/tx';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+import { expect, jest } from '@jest/globals';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getBootNodeUdpPort, shouldCollectMetrics } from '../../fixtures/fixtures.js';
+import { createNodes } from '../../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest, WAIT_FOR_TX_TIMEOUT } from '../p2p_network.js';
+import { prepareTransactions } from '../shared.js';
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+export const NUM_VALIDATORS = 6;
+export const NUM_TXS_PER_NODE = 4;
+export const BOOT_NODE_UDP_PORT = getBootNodeUdpPort();
+export const createReqrespDataDir = ()=>fs.mkdtempSync(path.join(os.tmpdir(), 'reqresp-'));
+export async function createReqrespTest(options = {}) {
+    const { disableStatusHandshake = false } = options;
+    const t = await P2PNetworkTest.create({
+        testName: 'e2e_p2p_reqresp_tx',
+        numberOfNodes: 0,
+        numberOfValidators: NUM_VALIDATORS,
+        basePort: BOOT_NODE_UDP_PORT,
+        // To collect metrics - run in aztec-packages `docker compose --profile metrics up`
+        metricsPort: shouldCollectMetrics(),
+        initialConfig: {
+            ethereumSlotDuration: 8,
+            aztecSlotDuration: 36,
+            blockDurationMs: 6000,
+            l1PublishingTime: 8,
+            minTxsPerBlock: 1,
+            maxTxsPerBlock: 2,
+            enforceTimeTable: true,
+            aztecProofSubmissionEpochs: 1024,
+            ...disableStatusHandshake ? {
+                p2pDisableStatusHandshake: true
+            } : {},
+            listenAddress: '127.0.0.1',
+            aztecEpochDuration: 64
+        }
+    });
+    await t.setup();
+    await t.applyBaseSetup();
+    return t;
+}
+export async function cleanupReqrespTest(params) {
+    const { t, nodes, dataDir } = params;
+    if (nodes) {
+        await t.stopNodes(nodes);
+    }
+    await t.teardown();
+    for(let i = 0; i < NUM_VALIDATORS; i++){
+        fs.rmSync(`${dataDir}-${i}`, {
+            recursive: true,
+            force: true,
+            maxRetries: 3
+        });
+    }
+}
+const getNodePort = (nodeIndex)=>BOOT_NODE_UDP_PORT + 1 + nodeIndex;
+export async function runReqrespTxTest(params) {
+    const { t, dataDir, disableStatusHandshake = false } = params;
+    if (!t.bootstrapNodeEnr) {
+        throw new Error('Bootstrap node ENR is not available');
+    }
+    t.logger.info('Creating nodes');
+    const aztecNodeConfig = disableStatusHandshake ? {
+        ...t.ctx.aztecNodeConfig,
+        p2pDisableStatusHandshake: true
+    } : t.ctx.aztecNodeConfig;
+    const nodes = await createNodes(aztecNodeConfig, t.ctx.dateProvider, t.bootstrapNodeEnr, NUM_VALIDATORS, BOOT_NODE_UDP_PORT, t.prefilledPublicData, dataDir, shouldCollectMetrics());
+    t.logger.info('Waiting for nodes to connect');
+    await t.waitForP2PMeshConnectivity(nodes, NUM_VALIDATORS);
+    await t.setupAccount();
+    const targetBlockNumber = await t.ctx.aztecNodeService.getBlockNumber();
+    await retryUntil(async ()=>{
+        const blockNumbers = await Promise.all(nodes.map((node)=>node.getBlockNumber()));
+        return blockNumbers.every((blockNumber)=>blockNumber >= targetBlockNumber) ? true : undefined;
+    }, `validators to sync to L2 block ${targetBlockNumber}`, 60, 0.5);
+    t.logger.info('Preparing transactions to send');
+    const txBatches = await timesAsync(2, ()=>prepareTransactions(t.logger, t.ctx.aztecNodeService, NUM_TXS_PER_NODE, t.fundedAccount));
+    t.logger.info('Removing initial node');
+    await t.removeInitialNode();
+    t.logger.info('Starting fresh slot');
+    const [timestamp] = await t.ctx.cheatCodes.rollup.advanceToNextSlot();
+    t.ctx.dateProvider.setTime(Number(timestamp) * 1000);
+    const startSlotTimestamp = BigInt(timestamp);
+    const { proposerIndexes, nodesToTurnOffTxGossip } = await getProposerIndexes(t, startSlotTimestamp);
+    t.logger.info(`Turning off tx gossip for nodes: ${nodesToTurnOffTxGossip.map(getNodePort)}`);
+    t.logger.info(`Sending txs to proposer nodes: ${proposerIndexes.map(getNodePort)}`);
+    // Replace the p2p node implementation of some of the nodes with a spy such that it does not store transactions that are gossiped to it
+    // Original implementation of `handleGossipedTx` will store received transactions in the tx pool.
+    // We chose the first 2 nodes that will be the proposers for the next few slots
+    for (const nodeIndex of nodesToTurnOffTxGossip){
+        const logger = createLogger(`p2p:${getNodePort(nodeIndex)}`);
+        jest.spyOn(nodes[nodeIndex].p2pClient.p2pService, 'handleGossipedTx').mockImplementation((payloadData)=>{
+            const txHash = Tx.fromBuffer(payloadData).getTxHash();
+            logger.info(`Skipping storage of gossiped transaction ${txHash.toString()}`);
+            return Promise.resolve();
+        });
+    }
+    // We send the tx to the proposer nodes directly, ignoring the pxe and node in each context
+    // We cannot just call tx.send since they were created using a pxe wired to the first node which is now stopped
+    t.logger.info('Sending transactions through proposer nodes');
+    const submittedTxs = await Promise.all(txBatches.map(async (batch, batchIndex)=>{
+        const proposerNode = nodes[proposerIndexes[batchIndex]];
+        await Promise.all(batch.map(async (tx)=>{
+            try {
+                await proposerNode.sendTx(tx);
+            } catch (err) {
+                t.logger.error(`Error sending tx: ${err}`);
+                throw err;
+            }
+        }));
+        return batch.map((tx)=>({
+                node: proposerNode,
+                txHash: tx.getTxHash()
+            }));
+    }));
+    t.logger.info('Waiting for all transactions to be mined');
+    await Promise.all(submittedTxs.flatMap((batch, batchIndex)=>batch.map(async (submittedTx, txIndex)=>{
+            t.logger.info(`Waiting for tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} to be mined`);
+            await waitForTx(submittedTx.node, submittedTx.txHash, {
+                timeout: WAIT_FOR_TX_TIMEOUT * 1.5
+            });
+            t.logger.info(`Tx ${batchIndex}-${txIndex} ${submittedTx.txHash.toString()} has been mined`);
+        })));
+    t.logger.info('All transactions mined');
+    // Assert that multiple blocks were built for at least one slot
+    t.logger.info('Verifying multiple blocks for at least one checkpoint');
+    const checkpoints = await nodes[0].getCheckpoints(CheckpointNumber(1), 50);
+    expect(checkpoints.length).toBeGreaterThan(0);
+    let mbpsFound = false;
+    let expectedBlockNumber = checkpoints[0].checkpoint.blocks[0].number;
+    for (const published of checkpoints){
+        const blockCount = published.checkpoint.blocks.length;
+        mbpsFound = mbpsFound || blockCount >= 2;
+        for(let i = 0; i < blockCount; i++){
+            const block = published.checkpoint.blocks[i];
+            expect(block.indexWithinCheckpoint).toBe(i);
+            expect(block.checkpointNumber).toBe(published.checkpoint.number);
+            expect(block.number).toBe(expectedBlockNumber);
+            expectedBlockNumber++;
+        }
+    }
+    expect(mbpsFound).toBe(true);
+    return nodes;
+}
+async function getProposerIndexes(t, startSlotTimestamp) {
+    // Get the nodes for the next set of slots
+    const rollupContract = new RollupContract(t.ctx.deployL1ContractsValues.l1Client, t.ctx.deployL1ContractsValues.l1ContractAddresses.rollupAddress);
+    const attesters = await rollupContract.getAttesters();
+    const startSlot = await rollupContract.getSlotAt(startSlotTimestamp);
+    const proposers = await Promise.all(Array.from({
+        length: 3
+    }, async (_, i)=>{
+        const slot = SlotNumber(startSlot + i);
+        const slotTimestamp = await rollupContract.getTimestampForSlot(slot);
+        return await rollupContract.getProposerAt(slotTimestamp);
+    }));
+    // Get the indexes of the nodes that are responsible for the next two slots
+    const proposerIndexes = proposers.map((proposer)=>attesters.findIndex((a)=>a.equals(proposer)));
+    if (proposerIndexes.some((i)=>i === -1)) {
+        throw new Error(`Proposer index not found for proposer ` + `(proposers=${proposers.map((p)=>p.toString()).join(',')}, indices=${proposerIndexes.join(',')})`);
+    }
+    const nodesToTurnOffTxGossip = Array.from({
+        length: NUM_VALIDATORS
+    }, (_, i)=>i).filter((i)=>!proposerIndexes.includes(i));
+    return {
+        proposerIndexes,
+        nodesToTurnOffTxGossip
+    };
+}