@aztec/p2p 0.0.1-commit.3469e52 → 0.0.1-commit.350e0a4d

package/dest/test-helpers/testbench-utils.js

@@ -0,0 +1,400 @@
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { TxHash } from '@aztec/stdlib/tx';
+import EventEmitter from 'events';
+import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
+/**
+ * In-memory TxPool implementation for testing.
+ * Provides basic tx storage without persistence.
+ * Implements TxPoolV2 interface with stub implementations for testing.
+ */ export class InMemoryTxPool extends EventEmitter {
+    txsByHash = new Map();
+    logger = null;
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    setTxs(txs) {
+        this.txsByHash.clear();
+        return this.appendTxs(txs);
+    }
+    appendTxs(txs) {
+        let added = 0;
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            if (!this.txsByHash.has(key)) {
+                added += 1;
+            }
+            this.txsByHash.set(key, tx);
+        }
+        return added;
+    }
+    clearTxs() {
+        this.txsByHash.clear();
+    }
+    resetState() {
+        this.txsByHash.clear();
+        this.removeAllListeners();
+    }
+    // === Core Operations (TxPoolV2) ===
+    addPendingTxs(txs, opts) {
+        const accepted = [];
+        const newTxs = [];
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            if (!this.txsByHash.has(key)) {
+                newTxs.push(tx);
+                accepted.push(tx.getTxHash());
+            }
+            this.txsByHash.set(key, tx);
+        }
+        if (newTxs.length > 0) {
+            this.emit('txs-added', {
+                txs: newTxs,
+                source: opts?.source
+            });
+        }
+        return Promise.resolve({
+            accepted,
+            ignored: [],
+            rejected: []
+        });
+    }
+    canAddPendingTx(tx) {
+        const key = tx.getTxHash().toString();
+        if (this.txsByHash.has(key)) {
+            return Promise.resolve('ignored');
+        }
+        return Promise.resolve('accepted');
+    }
+    addProtectedTxs(txs, _block, opts) {
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            this.txsByHash.set(key, tx);
+        }
+        if (txs.length > 0) {
+            this.emit('txs-added', {
+                txs,
+                source: opts?.source
+            });
+        }
+        return Promise.resolve();
+    }
+    protectTxs(txHashes, _block) {
+        const notFound = [];
+        for (const txHash of txHashes){
+            if (!this.txsByHash.has(txHash.toString())) {
+                notFound.push(txHash);
+            }
+        }
+        return Promise.resolve(notFound);
+    }
+    addMinedTxs(txs, _block, _opts) {
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            this.txsByHash.set(key, tx);
+        }
+        return Promise.resolve();
+    }
+    // === State Transition Handlers (TxPoolV2) ===
+    handleMinedBlock(_block) {
+        return Promise.resolve();
+    }
+    prepareForSlot(_slotNumber) {
+        return Promise.resolve();
+    }
+    unprotectTxs(_txHashes, _slotNumber) {
+        return Promise.resolve();
+    }
+    handlePrunedBlocks(_latestBlock, _options) {
+        return Promise.resolve();
+    }
+    handleFailedExecution(txHashes) {
+        for (const txHash of txHashes){
+            this.txsByHash.delete(txHash.toString());
+        }
+        return Promise.resolve();
+    }
+    handleFinalizedBlock(_block) {
+        return Promise.resolve();
+    }
+    // === Query Operations (TxPoolV2) ===
+    getTxByHash(hash) {
+        return Promise.resolve(this.txsByHash.get(hash.toString()));
+    }
+    getTxsByHash(hashes) {
+        const result = hashes.map((h)=>this.txsByHash.get(h.toString()));
+        const found = result.filter((tx)=>tx !== undefined).length;
+        this.logger?.debug(`[TxPool] getTxsByHash: requested ${hashes.length}, found ${found}`);
+        return Promise.resolve(result);
+    }
+    hasTxs(hashes) {
+        return Promise.resolve(hashes.map((h)=>this.txsByHash.has(h.toString())));
+    }
+    getArchivedTxByHash(_hash) {
+        return Promise.resolve(undefined);
+    }
+    getPendingTxHashes() {
+        return Promise.resolve([
+            ...this.txsByHash.keys()
+        ].map((key)=>TxHash.fromString(key)));
+    }
+    getEligiblePendingTxHashes() {
+        return this.getPendingTxHashes();
+    }
+    getPendingTxCount() {
+        return Promise.resolve(this.txsByHash.size);
+    }
+    async hasEligiblePendingTxs(minCount) {
+        return await this.getPendingTxCount() >= minCount;
+    }
+    getMinedTxHashes() {
+        return Promise.resolve([]);
+    }
+    getMinedTxCount() {
+        return Promise.resolve(0);
+    }
+    getTxStatus(hash) {
+        return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
+    }
+    isEmpty() {
+        return Promise.resolve(this.txsByHash.size === 0);
+    }
+    getLowestPriorityPending(_limit) {
+        return Promise.resolve([]);
+    }
+    // === Configuration (TxPoolV2) ===
+    updateConfig(_config) {
+        return Promise.resolve();
+    }
+    // === Lifecycle (TxPoolV2) ===
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
+    }
+}
+/**
+ * In-memory AttestationPool mock for testing/benchmarking.
+ * Provides minimal implementation without persistence.
+ */ export class InMemoryAttestationPool {
+    proposals = new Map();
+    checkpoints = new Map();
+    tryAddBlockProposal(blockProposal) {
+        const id = blockProposal.archive.toString();
+        const alreadyExists = this.proposals.has(id);
+        if (alreadyExists) {
+            return Promise.resolve({
+                added: false,
+                alreadyExists: true,
+                count: 1
+            });
+        }
+        this.proposals.set(id, blockProposal);
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
+    }
+    getBlockProposalByArchive(id) {
+        return Promise.resolve(this.proposals.get(id));
+    }
+    tryAddCheckpointProposal(proposal) {
+        const proposals = this.checkpoints.get(proposal.slotNumber) ?? [];
+        proposals.push(proposal);
+        this.checkpoints.set(proposal.slotNumber, proposals);
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
+    }
+    getCheckpointProposal(slot) {
+        return Promise.resolve(this.checkpoints.get(slot)?.[0]);
+    }
+    hasCheckpointProposalForSlot(slot) {
+        return Promise.resolve(this.checkpoints.has(slot));
+    }
+    getProposalsForSlot(slot) {
+        return Promise.resolve({
+            blockProposals: [
+                ...this.proposals.values()
+            ].filter((proposal)=>proposal.slotNumber === slot),
+            checkpointProposals: this.checkpoints.get(slot) ?? []
+        });
+    }
+    async addOwnCheckpointAttestations(_attestations) {}
+    async deleteOlderThan(_slot) {}
+    getCheckpointAttestationsForSlot(_slot) {
+        return Promise.resolve([]);
+    }
+    getCheckpointAttestationsForSlotAndProposal(_slot, _proposalPayloadHash) {
+        return Promise.resolve([]);
+    }
+    tryAddCheckpointAttestation(_attestation) {
+        return Promise.resolve({
+            added: true,
+            alreadyExists: false,
+            count: 1
+        });
+    }
+    hasBlockProposalsForSlot(_slot) {
+        return Promise.resolve(false);
+    }
+    isEmpty() {
+        return Promise.resolve(this.proposals.size === 0 && this.checkpoints.size === 0);
+    }
+    resetState() {
+        this.proposals.clear();
+        this.checkpoints.clear();
+    }
+}
+/**
+ * Creates a mock EpochCache for testing.
+ */ export function createMockEpochCache() {
+    const cache = {
+        getCommittee: ()=>Promise.resolve({
+                committee: [],
+                seed: 1n,
+                epoch: EpochNumber.ZERO,
+                isEscapeHatchOpen: false
+            }),
+        getProposerIndexEncoding: ()=>'0x',
+        getSlotNow: ()=>SlotNumber.ZERO,
+        getTargetSlot: ()=>SlotNumber.ZERO,
+        getEpochNow: ()=>EpochNumber.ZERO,
+        getTargetEpoch: ()=>EpochNumber.ZERO,
+        getEpochAndSlotNow: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                nowMs: 0n
+            }),
+        computeProposerIndex: ()=>0n,
+        getCurrentAndNextSlot: ()=>({
+                currentSlot: SlotNumber.ZERO,
+                nextSlot: SlotNumber.ZERO
+            }),
+        getTargetAndNextSlot: ()=>({
+                targetSlot: SlotNumber.ZERO,
+                nextSlot: SlotNumber.ZERO
+            }),
+        getProposerAttesterAddressInSlot: ()=>Promise.resolve(undefined),
+        getEpochAndSlotInNextL1Slot: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                nowSeconds: 0n
+            }),
+        getTargetEpochAndSlotInNextL1Slot: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                nowSeconds: 0n
+            }),
+        isInCommittee: ()=>Promise.resolve(false),
+        getRegisteredValidators: ()=>Promise.resolve([]),
+        filterInCommittee: ()=>Promise.resolve([]),
+        isEscapeHatchOpen: ()=>Promise.resolve(false),
+        isEscapeHatchOpenAtSlot: ()=>Promise.resolve(false),
+        getL1Constants: ()=>({
+                l1StartBlock: 0n,
+                l1GenesisTime: 0n,
+                epochDuration: 1,
+                slotDuration: 1,
+                ethereumSlotDuration: 1,
+                proofSubmissionEpochs: 1,
+                targetCommitteeSize: 48,
+                rollupManaLimit: Number.MAX_SAFE_INTEGER
+            })
+    };
+    return cache;
+}
+/**
+ * Creates a mock WorldStateSynchronizer for testing.
+ */ export function createMockWorldStateSynchronizer() {
+    return {
+        status: ()=>Promise.resolve({
+                syncSummary: {
+                    latestBlockNumber: 0,
+                    latestBlockHash: '',
+                    finalizedBlockNumber: 0,
+                    treesAreSynched: false,
+                    oldestHistoricBlockNumber: 0
+                }
+            })
+    };
+}
+/**
+ * Unlimited rate limit configuration for benchmarks.
+ */ export const UNLIMITED_RATE_LIMIT_QUOTA = {
+    peerLimit: {
+        quotaTimeMs: 1000,
+        quotaCount: 10_000
+    },
+    globalLimit: {
+        quotaTimeMs: 1000,
+        quotaCount: 100_000
+    }
+};
+/**
+ * Installs unlimited rate limits on a ReqResp instance.
+ * Used in benchmarks to avoid rate limiting affecting results.
+ *
+ * Note: Uses `as any` because rateLimiter is private. This is acceptable
+ * in test code where we need to override internal behavior.
+ */ export function installUnlimitedRateLimitsOnReqResp(reqResp) {
+    const rateLimiter = reqResp.rateLimiter;
+    rateLimiter.getRateLimits = ()=>UNLIMITED_RATE_LIMIT_QUOTA;
+    rateLimiter.allow = ()=>RateLimitStatus.Allowed;
+}
+/**
+ * Benchmark timing constants.
+ */ export const BENCHMARK_CONSTANTS = {
+    /** Time to wait for peers to connect before starting benchmark */ PEER_DISCOVERY_WAIT_MS: 10_000,
+    /** Maximum time to wait for peer connections */ MAX_PEER_WAIT_MS: 60_000,
+    /** Interval between peer connection checks */ PEER_CHECK_INTERVAL_MS: 500,
+    /** Default worker ready timeout */ WORKER_READY_TIMEOUT_MS: 30_000,
+    /** Graceful shutdown timeout before force kill */ GRACEFUL_SHUTDOWN_TIMEOUT_MS: 5_000,
+    /** Overall cleanup timeout */ CLEANUP_TIMEOUT_MS: 10_000,
+    /** Buffer time for internal timeout to ensure we return before outer timeout */ TIMEOUT_BUFFER_MS: 5_000,
+    /** Minimum internal timeout regardless of buffer */ MIN_INTERNAL_TIMEOUT_MS: 1_000,
+    /** Fixed max peers for fair benchmarking */ FIXED_MAX_PEERS: 10,
+    /** Fixed max retry attempts for fair benchmarking */ FIXED_MAX_RETRY_ATTEMPTS: 3,
+    /** LMDB map size for temp stores used in benchmarks (in KB). */ KV_STORE_MAP_SIZE_KB: 256 * 1024
+};
+/**
+ * Filters transactions based on distribution pattern for benchmark responders.
+ *
+ * @param allTxs - All transactions to filter
+ * @param peerIndex - Index of the current peer (0 = aggregator)
+ * @param peerCount - Total number of peers
+ * @param distribution - Distribution pattern to apply
+ * @param pinnedPeerIndex - Index of the pinned peer (for pinned-only distribution)
+ * @returns Filtered transactions for this peer
+ */ export function filterTxsByDistribution(allTxs, peerIndex, peerCount, distribution, pinnedPeerIndex = 1) {
+    if (peerIndex === 0) {
+        return [];
+    }
+    const responderCount = peerCount - 1;
+    switch(distribution){
+        case 'uniform':
+            return allTxs;
+        case 'sparse':
+            {
+                const responderIndex = peerIndex - 1;
+                return allTxs.filter((_, txIndex)=>{
+                    const bucket = txIndex % responderCount;
+                    return bucket === responderIndex || bucket === (responderIndex + 1) % responderCount;
+                });
+            }
+        case 'pinned-only':
+            return peerIndex === pinnedPeerIndex ? allTxs : [];
+    }
+}
+/**
+ * Calculates the internal timeout for collector operations.
+ * Ensures we return before the outer timeout while maintaining a minimum.
+ */ export function calculateInternalTimeout(timeoutMs) {
+    return Math.max(timeoutMs - BENCHMARK_CONSTANTS.TIMEOUT_BUFFER_MS, BENCHMARK_CONSTANTS.MIN_INTERNAL_TIMEOUT_MS);
+}

package/dest/testbench/p2p_client_testbench_worker.d.ts

@@ -1,2 +1,26 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+import { type DistributionPattern } from '../test-helpers/index.js';
+export type { DistributionPattern } from '../test-helpers/testbench-utils.js';
+export interface BenchReqRespCommand {
+    type: 'BENCH_REQRESP';
+    txCount: number;
+    peerCount: number;
+    distribution: DistributionPattern;
+    timeoutMs: number;
+    isAggregator: boolean;
+    peerIndex: number;
+    pinnedPeerIndex?: number;
+    pinnedPeerId?: string;
+    blockNumber: number;
+    seed: number;
+}
+export interface BenchResultMessage {
+    type: 'BENCH_RESULT';
+    durationMs: number;
+    fetchedCount: number;
+    success: boolean;
+    error?: string;
+}
+export interface BenchReadyMessage {
+    type: 'BENCH_READY';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4Q0EsT0FBTyxFQUVMLEtBQUssbUJBQW1CLEVBT3pCLE1BQU0sMEJBQTBCLENBQUM7QUFHbEMsWUFBWSxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0NBQW9DLENBQUM7QUFFOUUsTUFBTSxXQUFXLG1CQUFtQjtJQUNsQyxJQUFJLEVBQUUsZUFBZSxDQUFDO0lBQ3RCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixZQUFZLEVBQUUsbUJBQW1CLENBQUM7SUFDbEMsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixZQUFZLEVBQUUsT0FBTyxDQUFDO0lBQ3RCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsZUFBZSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ3pCLFlBQVksQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN0QixXQUFXLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLElBQUksRUFBRSxNQUFNLENBQUM7Q0FDZDtBQUVELE1BQU0sV0FBVyxrQkFBa0I7SUFDakMsSUFBSSxFQUFFLGNBQWMsQ0FBQztJQUNyQixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFlBQVksRUFBRSxNQUFNLENBQUM7SUFDckIsT0FBTyxFQUFFLE9BQU8sQ0FBQztJQUNqQixLQUFLLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDaEI7QUFFRCxNQUFNLFdBQVcsaUJBQWlCO0lBQ2hDLElBQUksRUFBRSxhQUFhLENBQUM7Q0FDckIifQ==

package/dest/testbench/p2p_client_testbench_worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"p2p_client_testbench_worker.d.ts","sourceRoot":"","sources":["../../src/testbench/p2p_client_testbench_worker.ts"],"names":[],"mappings":""}
+{"version":3,"file":"p2p_client_testbench_worker.d.ts","sourceRoot":"","sources":["../../src/testbench/p2p_client_testbench_worker.ts"],"names":[],"mappings":"AA8CA,OAAO,EAEL,KAAK,mBAAmB,EAOzB,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,mBAAmB,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;CACrB"}