@aztec/end-to-end 0.0.0-test.0 → 0.0.1-commit.001888fc

package/dest/e2e_p2p/reqresp/utils.js

@@ -0,0 +1,190 @@
+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]];
+        for (const tx of batch){
+            t.logger.info(`Tx ${tx.getTxHash().toString()} base64: ${tx.toBuffer().toString('base64')}`);
+        }
+        const txHashes = batch.map((tx)=>tx.getTxHash().toString());
+        t.logger.info(`Sending batch ${batchIndex} to proposer ${getNodePort(proposerIndexes[batchIndex])}: ${txHashes.join(', ')}`);
+        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()
+            }));
+    }));
+    // Log pool state per node after sending
+    for(let i = 0; i < NUM_VALIDATORS; i++){
+        const count = await nodes[i].getPendingTxCount();
+        t.logger.info(`Node ${getNodePort(i)} pool has ${count} pending txs`);
+    }
+    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');
+    // Wait for L1 checkpoint sync, which may lag behind P2P block propagation.
+    const checkpoints = await retryUntil(async ()=>{
+        const cps = await nodes[0].getCheckpoints(CheckpointNumber(1), 50);
+        return cps.length > 0 && cps.some((cp)=>cp.checkpoint.blocks.length >= 2) ? cps : undefined;
+    }, 'waiting for multi-block checkpoint to sync from L1', 30, 1);
+    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
+    };
+}

package/dest/e2e_p2p/shared.d.ts

@@ -1,10 +1,66 @@
 import type { InitialAccountData } from '@aztec/accounts/testing';
 import type { AztecNodeService } from '@aztec/aztec-node';
-import { type Logger, type SentTx } from '@aztec/aztec.js';
-import type { SpamContract } from '@aztec/noir-contracts.js/Spam';
-import type { NodeContext } from '../fixtures/setup_p2p_test.js';
-export declare const submitComplexTxsTo: (logger: Logger, spamContract: SpamContract, numTxs: number, opts?: {
-    callPublic?: boolean;
-}) => Promise<SentTx[]>;
-export declare const createPXEServiceAndSubmitTransactions: (logger: Logger, node: AztecNodeService, numTxs: number, fundedAccount: InitialAccountData) => Promise<NodeContext>;
-//# sourceMappingURL=shared.d.ts.map
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Logger } from '@aztec/aztec.js/log';
+import { TxHash } from '@aztec/aztec.js/tx';
+import type { RollupCheatCodes } from '@aztec/aztec/testing';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { EmpireSlashingProposerContract, RollupContract, TallySlashingProposerContract } from '@aztec/ethereum/contracts';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { SpamContract } from '@aztec/noir-test-contracts.js/Spam';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { SlashFactoryContract } from '@aztec/stdlib/l1-contracts';
+import { type ProvenTx } from '../test-wallet/utils.js';
+export declare const submitComplexTxsTo: (logger: Logger, from: AztecAddress, spamContract: SpamContract, numTxs: number, opts?: {
+    callPublic?: boolean | undefined;
+}) => Promise<TxHash[]>;
+export declare const submitTransactions: (logger: Logger, node: AztecNodeService, numTxs: number, fundedAccount: InitialAccountData) => Promise<TxHash[]>;
+export declare function prepareTransactions(logger: Logger, node: AztecNodeService, numTxs: number, fundedAccount: InitialAccountData): Promise<ProvenTx[]>;
+export declare function awaitProposalExecution(slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract, timeoutSeconds: number, logger: Logger): Promise<bigint>;
+export declare function awaitCommitteeExists({ rollup, logger }: {
+    rollup: RollupContract;
+    logger: Logger;
+}): Promise<readonly `0x${string}`[]>;
+/**
+ * Advance epochs until we find one where the target proposer is selected for at least one slot,
+ * then stop one epoch before it. This leaves time for the caller to start sequencers before
+ * warping to the target epoch, avoiding the race where the target epoch passes before sequencers
+ * are ready.
+ *
+ * Returns the target epoch number so the caller can warp to it after starting sequencers.
+ */
+export declare function advanceToEpochBeforeProposer({ epochCache, cheatCodes, targetProposer, logger, maxAttempts }: {
+    epochCache: EpochCacheInterface;
+    cheatCodes: RollupCheatCodes;
+    targetProposer: EthAddress;
+    logger: Logger;
+    maxAttempts?: number;
+}): Promise<{
+    targetEpoch: EpochNumber;
+}>;
+export declare function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSize, epochDuration, waitUntilOffenseCount, timeoutSeconds }: {
+    nodeAdmin: AztecNodeAdmin;
+    logger: Logger;
+    slashingRoundSize: number;
+    epochDuration: number;
+    waitUntilOffenseCount?: number;
+    timeoutSeconds?: number;
+}): Promise<import("@aztec/slasher").Offense[]>;
+/**
+ * Await the committee to be slashed out of the validator set.
+ * Currently assumes that the committee is the same size as the validator set.
+ */
+export declare function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashFactory, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }: {
+    rollup: RollupContract;
+    cheatCodes: RollupCheatCodes;
+    committee: readonly `0x${string}`[];
+    slashFactory: SlashFactoryContract;
+    slashingProposer: EmpireSlashingProposerContract | TallySlashingProposerContract | undefined;
+    slashingRoundSize: number;
+    aztecSlotDuration: number;
+    aztecEpochDuration: number;
+    logger: Logger;
+    offenseEpoch: number;
+}): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/shared.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,EAAY,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGlE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAIjE,eAAO,MAAM,kBAAkB,WACrB,MAAM,gBACA,YAAY,UAClB,MAAM,SACR;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,sBAwB/B,CAAC;AAGF,eAAO,MAAM,qCAAqC,WACxC,MAAM,QACR,gBAAgB,UACd,MAAM,iBACC,kBAAkB,KAChC,QAAQ,WAAW,CAmBrB,CAAC"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/e2e_p2p/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EACV,8BAA8B,EAC9B,cAAc,EACd,6BAA6B,EAC9B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAc,MAAM,iCAAiC,CAAC;AAE1E,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAIvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAIvE,OAAO,EAAE,KAAK,QAAQ,EAAoB,MAAM,yBAAyB,CAAC;AAG1E,eAAO,MAAM,kBAAkB;;uBAkB9B,CAAC;AAGF,eAAO,MAAM,kBAAkB,kHAe9B,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,kBAAkB,GAChC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAwBrB;AAED,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,8BAA8B,GAAG,6BAA6B,EAChF,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CA0BjB;AAED,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,MAAM,EACP,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC,CAapC;AAED;;;;;;;GAOG;AACH,wBAAsB,4BAA4B,CAAC,EACjD,UAAU,EACV,UAAU,EACV,cAAc,EACd,MAAM,EACN,WAAgB,EACjB,EAAE;IACD,UAAU,EAAE,mBAAmB,CAAC;IAChC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,cAAc,EAAE,UAAU,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,WAAW,CAAA;CAAE,CAAC,CA8BxC;AAED,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,qBAAqB,EACrB,cAAoB,EACrB,EAAE;IACD,SAAS,EAAE,cAAc,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,+CAkBA;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,MAAM,EACN,UAAU,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,MAAM,EACN,YAAY,EACb,EAAE;IACD,MAAM,EAAE,cAAc,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC;IACpC,YAAY,EAAE,oBAAoB,CAAC;IACnC,gBAAgB,EAAE,8BAA8B,GAAG,6BAA6B,GAAG,SAAS,CAAC;IAC7F,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB,iBA6EA"}

package/dest/e2e_p2p/shared.js

@@ -1,39 +1,212 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { TxStatus } from '@aztec/aztec.js';
-import { createPXEService, getPXEServiceConfig as getRpcConfig } from '@aztec/pxe/server';
+import { NO_WAIT, getContractInstanceFromInstantiationParams } from '@aztec/aztec.js/contracts';
+import { Fr } from '@aztec/aztec.js/fields';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { timesAsync, unique } from '@aztec/foundation/collection';
+import { retryUntil } from '@aztec/foundation/retry';
+import { pluralize } from '@aztec/foundation/string';
+import { TestContract, TestContractArtifact } from '@aztec/noir-test-contracts.js/Test';
+import { getPXEConfig, getPXEConfig as getRpcConfig } from '@aztec/pxe/server';
+import { getRoundForOffense } from '@aztec/slasher';
 import { submitTxsTo } from '../shared/submit-transactions.js';
+import { TestWallet } from '../test-wallet/test_wallet.js';
+import { proveInteraction } from '../test-wallet/utils.js';
 // submits a set of transactions to the provided Private eXecution Environment (PXE)
-export const submitComplexTxsTo = async (logger, spamContract, numTxs, opts = {})=>{
+export const submitComplexTxsTo = async (logger, from, spamContract, numTxs, opts = {})=>{
     const txs = [];
     const seed = 1234n;
     const spamCount = 15;
     for(let i = 0; i < numTxs; i++){
-        const tx = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic).send({
-            skipPublicSimulation: true
+        const method = spamContract.methods.spam(seed + BigInt(i * spamCount), spamCount, !!opts.callPublic);
+        const { txHash } = await method.send({
+            from,
+            wait: NO_WAIT
         });
-        const txHash = await tx.getTxHash();
-        logger.info(`Tx sent with hash ${txHash}`);
-        const receipt = await tx.getReceipt();
-        expect(receipt).toEqual(expect.objectContaining({
-            status: TxStatus.PENDING,
-            error: ''
-        }));
-        logger.info(`Receipt received for ${txHash}`);
-        txs.push(tx);
+        logger.info(`Tx sent with hash ${txHash.toString()}`);
+        txs.push(txHash);
     }
     return txs;
 };
-// creates an instance of the PXE and submit a given number of transactions to it.
-export const createPXEServiceAndSubmitTransactions = async (logger, node, numTxs, fundedAccount)=>{
+// creates a wallet and submit a given number of transactions through it.
+export const submitTransactions = async (logger, node, numTxs, fundedAccount)=>{
     const rpcConfig = getRpcConfig();
-    const pxeService = await createPXEService(node, rpcConfig, true);
-    const account = await getSchnorrAccount(pxeService, fundedAccount.secret, fundedAccount.signingKey, fundedAccount.salt);
-    await account.register();
-    const wallet = await account.getWallet();
-    const txs = await submitTxsTo(pxeService, numTxs, wallet, logger);
-    return {
-        txs,
-        pxeService,
-        node
-    };
+    rpcConfig.proverEnabled = false;
+    const wallet = await TestWallet.create(node, {
+        ...getPXEConfig(),
+        proverEnabled: false
+    }, {
+        loggerActorLabel: 'pxe-tx'
+    });
+    const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+    return submitTxsTo(wallet, fundedAccountManager.address, numTxs, logger);
 };
+export async function prepareTransactions(logger, node, numTxs, fundedAccount) {
+    const rpcConfig = getRpcConfig();
+    rpcConfig.proverEnabled = false;
+    const wallet = await TestWallet.create(node, {
+        ...getPXEConfig(),
+        proverEnabled: false
+    }, {
+        loggerActorLabel: 'pxe-tx'
+    });
+    const fundedAccountManager = await wallet.createSchnorrAccount(fundedAccount.secret, fundedAccount.salt);
+    const testContractInstance = await getContractInstanceFromInstantiationParams(TestContractArtifact, {
+        salt: Fr.random()
+    });
+    await wallet.registerContract(testContractInstance, TestContractArtifact);
+    const contract = TestContract.at(testContractInstance.address, wallet);
+    return timesAsync(numTxs, async ()=>{
+        const tx = await proveInteraction(wallet, contract.methods.emit_nullifier(Fr.random()), {
+            from: fundedAccountManager.address
+        });
+        logger.info(`Tx prepared with hash ${tx.getTxHash()}`);
+        return tx;
+    });
+}
+export function awaitProposalExecution(slashingProposer, timeoutSeconds, logger) {
+    return new Promise((resolve, reject)=>{
+        const timeout = setTimeout(()=>{
+            logger.warn(`Timed out waiting for proposal execution`);
+            reject(new Error(`Timeout waiting for proposal execution after ${timeoutSeconds}s`));
+        }, timeoutSeconds * 1000);
+        if (slashingProposer.type === 'empire') {
+            const unwatch = slashingProposer.listenToPayloadSubmitted((args)=>{
+                logger.warn(`Proposal ${args.payload} from round ${args.round} executed`);
+                clearTimeout(timeout);
+                unwatch();
+                resolve(args.round);
+            });
+        } else if (slashingProposer.type === 'tally') {
+            const unwatch = slashingProposer.listenToRoundExecuted((args)=>{
+                logger.warn(`Slash from round ${args.round} executed`);
+                clearTimeout(timeout);
+                unwatch();
+                resolve(args.round);
+            });
+        } else {
+            clearTimeout(timeout);
+            reject(new Error(`Unknown slashing proposer type: ${slashingProposer.type}`));
+        }
+    });
+}
+export async function awaitCommitteeExists({ rollup, logger }) {
+    logger.info(`Waiting for committee to be set`);
+    let committee;
+    await retryUntil(async ()=>{
+        committee = await rollup.getCurrentEpochCommittee();
+        return committee && committee.length > 0;
+    }, 'non-empty committee', 60);
+    logger.warn(`Committee has been formed`, {
+        committee: committee.map((c)=>c.toString())
+    });
+    return committee.map((c)=>c.toString());
+}
+/**
+ * Advance epochs until we find one where the target proposer is selected for at least one slot,
+ * then stop one epoch before it. This leaves time for the caller to start sequencers before
+ * warping to the target epoch, avoiding the race where the target epoch passes before sequencers
+ * are ready.
+ *
+ * Returns the target epoch number so the caller can warp to it after starting sequencers.
+ */ export async function advanceToEpochBeforeProposer({ epochCache, cheatCodes, targetProposer, logger, maxAttempts = 20 }) {
+    const { epochDuration } = await cheatCodes.getConfig();
+    for(let attempt = 0; attempt < maxAttempts; attempt++){
+        const currentEpoch = await cheatCodes.getEpoch();
+        // Check the NEXT epoch's slots so we stay one epoch before the target,
+        // giving the caller time to start sequencers before the target epoch arrives.
+        const nextEpoch = Number(currentEpoch) + 1;
+        const startSlot = nextEpoch * Number(epochDuration);
+        const endSlot = startSlot + Number(epochDuration);
+        logger.info(`Checking next epoch ${nextEpoch} (slots ${startSlot}-${endSlot - 1}) for proposer ${targetProposer} (current epoch: ${currentEpoch})`);
+        for(let s = startSlot; s < endSlot; s++){
+            const proposer = await epochCache.getProposerAttesterAddressInSlot(SlotNumber(s));
+            if (proposer && proposer.equals(targetProposer)) {
+                logger.warn(`Found target proposer ${targetProposer} in slot ${s} of epoch ${nextEpoch}. Staying at epoch ${currentEpoch} to allow sequencer startup.`);
+                return {
+                    targetEpoch: EpochNumber(nextEpoch)
+                };
+            }
+        }
+        logger.info(`Target proposer not found in epoch ${nextEpoch}, advancing to next epoch`);
+        await cheatCodes.advanceToNextEpoch();
+    }
+    throw new Error(`Target proposer ${targetProposer} not found in any slot after ${maxAttempts} epoch attempts`);
+}
+export async function awaitOffenseDetected({ logger, nodeAdmin, slashingRoundSize, epochDuration, waitUntilOffenseCount, timeoutSeconds = 120 }) {
+    const targetOffenseCount = waitUntilOffenseCount ?? 1;
+    logger.warn(`Waiting for ${pluralize('offense', targetOffenseCount)} to be detected`);
+    const offenses = await retryUntil(async ()=>{
+        const offenses = await nodeAdmin.getSlashOffenses('all');
+        if (offenses.length >= targetOffenseCount) {
+            return offenses;
+        }
+    }, 'non-empty offenses', timeoutSeconds);
+    logger.info(`Hit ${offenses.length} offenses on rounds ${unique(offenses.map((o)=>getRoundForOffense(o, {
+            slashingRoundSize,
+            epochDuration
+        })))}`, {
+        offenses
+    });
+    return offenses;
+}
+/**
+ * Await the committee to be slashed out of the validator set.
+ * Currently assumes that the committee is the same size as the validator set.
+ */ export async function awaitCommitteeKicked({ rollup, cheatCodes, committee, slashFactory, slashingProposer, slashingRoundSize, aztecSlotDuration, aztecEpochDuration, logger, offenseEpoch }) {
+    if (!slashingProposer) {
+        throw new Error('No slashing proposer configured. Cannot test slashing.');
+    }
+    await cheatCodes.debugRollup();
+    if (slashingProposer.type === 'empire') {
+        // Await for the slash payload to be created if empire (no payload is created on tally until execution time)
+        const targetEpoch = EpochNumber(await cheatCodes.getEpoch() + await rollup.getLagInEpochsForValidatorSet() + 1);
+        logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+        await cheatCodes.advanceToEpoch(targetEpoch);
+        const slashPayloadEvents = await retryUntil(async ()=>{
+            const events = await slashFactory.getSlashPayloadCreatedEvents();
+            return events.length > 0 ? events : undefined;
+        }, 'slash payload created', 120, 1);
+        expect(slashPayloadEvents.length).toBe(1);
+        // The uniqueness check is needed since a validator may be slashed more than once on the same round (eg because they let two epochs be pruned)
+        expect(unique(slashPayloadEvents[0].slashes.map((slash)=>slash.validator.toString()))).toHaveLength(committee.length);
+    } else {
+        // Use the slash offset to ensure we are in the right epoch for tally
+        const slashOffsetInRounds = await slashingProposer.getSlashOffsetInRounds();
+        const slashingRoundSizeInEpochs = slashingRoundSize / aztecEpochDuration;
+        const slashingOffsetInEpochs = Number(slashOffsetInRounds) * slashingRoundSizeInEpochs;
+        const firstEpochInOffenseRound = offenseEpoch - offenseEpoch % slashingRoundSizeInEpochs;
+        const targetEpoch = firstEpochInOffenseRound + slashingOffsetInEpochs;
+        logger.info(`Advancing to epoch ${targetEpoch} so we start slashing`);
+        await cheatCodes.advanceToEpoch(EpochNumber(targetEpoch), {
+            offset: -aztecSlotDuration / 2
+        });
+    }
+    const attestersPre = await rollup.getAttesters();
+    expect(attestersPre.length).toBe(committee.length);
+    for (const attester of attestersPre){
+        const attesterInfo = await rollup.getAttesterView(attester);
+        expect(attesterInfo.status).toEqual(1); // Validating
+    }
+    const timeout = slashingRoundSize * 2 * aztecSlotDuration + 30;
+    logger.info(`Waiting for slash to be executed (timeout ${timeout}s)`);
+    await awaitProposalExecution(slashingProposer, timeout, logger);
+    // The attesters should still form the committee but they should be reduced to the "living" status
+    await cheatCodes.debugRollup();
+    const committeePostSlashing = await rollup.getCurrentEpochCommittee();
+    expect(committeePostSlashing?.length).toBe(attestersPre.length);
+    const attestersPostSlashing = await rollup.getAttesters();
+    expect(attestersPostSlashing.length).toBe(0);
+    for (const attester of attestersPre){
+        const attesterInfo = await rollup.getAttesterView(attester);
+        expect(attesterInfo.status).toEqual(2); // Living
+    }
+    logger.info(`Advancing to check current committee`);
+    await cheatCodes.debugRollup();
+    await cheatCodes.advanceToEpoch(EpochNumber(await cheatCodes.getEpoch() + await rollup.getLagInEpochsForValidatorSet() + 1));
+    await cheatCodes.debugRollup();
+    const committeeNextEpoch = await rollup.getCurrentEpochCommittee();
+    // The committee should be undefined, since the validator set is empty
+    // and the tests currently using this helper always set a target committee size.
+    expect(committeeNextEpoch).toBeUndefined();
+    const attestersNextEpoch = await rollup.getAttesters();
+    expect(attestersNextEpoch.length).toBe(0);
+}

package/dest/e2e_storage_proof/fixtures/storage_proof_fetcher.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZV9wcm9vZl9mZXRjaGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZTJlX3N0b3JhZ2VfcHJvb2YvZml4dHVyZXMvc3RvcmFnZV9wcm9vZl9mZXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dest/e2e_storage_proof/fixtures/storage_proof_fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage_proof_fetcher.d.ts","sourceRoot":"","sources":["../../../src/e2e_storage_proof/fixtures/storage_proof_fetcher.ts"],"names":[],"mappings":""}