@aztec/p2p 0.0.1-commit.2ed92850 → 0.0.1-commit.43c09e3f

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

@@ -0,0 +1,297 @@
+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.
+ */ 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();
+    }
+    addTxs(txs, opts) {
+        const newTxs = [];
+        let added = 0;
+        for (const tx of txs){
+            const key = tx.getTxHash().toString();
+            if (!this.txsByHash.has(key)) {
+                newTxs.push(tx);
+                added += 1;
+            }
+            this.txsByHash.set(key, tx);
+        }
+        if (newTxs.length > 0) {
+            this.emit('txs-added', {
+                txs: newTxs,
+                source: opts?.source
+            });
+        }
+        return Promise.resolve(added);
+    }
+    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())));
+    }
+    hasTx(hash) {
+        return Promise.resolve(this.txsByHash.has(hash.toString()));
+    }
+    getArchivedTxByHash(_hash) {
+        return Promise.resolve(undefined);
+    }
+    async markAsMined(_txHashes, _blockHeader) {}
+    async markMinedAsPending(_txHashes, _latestBlock) {}
+    deleteTxs(txHashes, _opts) {
+        for (const txHash of txHashes){
+            this.txsByHash.delete(txHash.toString());
+        }
+        return Promise.resolve();
+    }
+    getAllTxs() {
+        return Promise.resolve([
+            ...this.txsByHash.values()
+        ]);
+    }
+    getAllTxHashes() {
+        return Promise.resolve([
+            ...this.txsByHash.keys()
+        ].map((key)=>TxHash.fromString(key)));
+    }
+    getPendingTxHashes() {
+        return Promise.resolve([
+            ...this.txsByHash.keys()
+        ].map((key)=>TxHash.fromString(key)));
+    }
+    getPendingTxCount() {
+        return Promise.resolve(this.txsByHash.size);
+    }
+    getMinedTxHashes() {
+        return Promise.resolve([]);
+    }
+    getTxStatus(hash) {
+        return Promise.resolve(this.txsByHash.has(hash.toString()) ? 'pending' : undefined);
+    }
+    updateConfig(_config) {}
+    isEmpty() {
+        return Promise.resolve(this.txsByHash.size === 0);
+    }
+    async markTxsAsNonEvictable(_txHashes) {}
+    async clearNonEvictableTxs() {}
+    cleanupDeletedMinedTxs(_blockNumber) {
+        return Promise.resolve(0);
+    }
+}
+/**
+ * In-memory AttestationPool implementation for testing.
+ */ export class InMemoryAttestationPool {
+    proposals = new Map();
+    addBlockProposal(blockProposal) {
+        this.proposals.set(blockProposal.archive.toString(), blockProposal);
+        return Promise.resolve();
+    }
+    getBlockProposal(id) {
+        return Promise.resolve(this.proposals.get(id));
+    }
+    hasBlockProposal(idOrProposal) {
+        const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.archive.toString();
+        return Promise.resolve(this.proposals.has(id));
+    }
+    canAddProposal(_block) {
+        return Promise.resolve(true);
+    }
+    async addCheckpointProposal(_proposal) {}
+    getCheckpointProposal(_id) {
+        return Promise.resolve(undefined);
+    }
+    hasCheckpointProposal(_idOrProposal) {
+        return Promise.resolve(false);
+    }
+    async addCheckpointAttestations(_attestations) {}
+    async deleteCheckpointAttestationsOlderThan(_slot) {}
+    getCheckpointAttestationsForSlot(_slot) {
+        return Promise.resolve([]);
+    }
+    getCheckpointAttestationsForSlotAndProposal(_slot, _proposalId) {
+        return Promise.resolve([]);
+    }
+    hasCheckpointAttestation(_attestation) {
+        return Promise.resolve(false);
+    }
+    canAddCheckpointProposal(_proposal) {
+        return Promise.resolve(true);
+    }
+    canAddCheckpointAttestation(_attestation, _committeeSize) {
+        return Promise.resolve(true);
+    }
+    hasReachedCheckpointProposalCap(_slot) {
+        return Promise.resolve(false);
+    }
+    hasReachedCheckpointAttestationCap(_slot, _proposalId, _committeeSize) {
+        return Promise.resolve(false);
+    }
+    isEmpty() {
+        return Promise.resolve(this.proposals.size === 0);
+    }
+    resetState() {
+        this.proposals.clear();
+    }
+}
+/**
+ * Creates a mock EpochCache for testing.
+ */ export function createMockEpochCache() {
+    return {
+        getCommittee: ()=>Promise.resolve({
+                committee: [],
+                seed: 1n,
+                epoch: EpochNumber.ZERO,
+                isEscapeHatchOpen: false
+            }),
+        getProposerIndexEncoding: ()=>'0x',
+        getEpochAndSlotNow: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                nowMs: 0n
+            }),
+        computeProposerIndex: ()=>0n,
+        getCurrentAndNextSlot: ()=>({
+                currentSlot: SlotNumber.ZERO,
+                nextSlot: SlotNumber.ZERO
+            }),
+        getProposerAttesterAddressInSlot: ()=>Promise.resolve(undefined),
+        getEpochAndSlotInNextL1Slot: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                now: 0n
+            }),
+        isInCommittee: ()=>Promise.resolve(false),
+        getRegisteredValidators: ()=>Promise.resolve([]),
+        filterInCommittee: ()=>Promise.resolve([])
+    };
+}
+/**
+ * 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;
+}
+/**
+ * Display names for collector types (for output/logging only).
+ */ export const COLLECTOR_DISPLAY_NAMES = {
+    'batch-requester': 'batch-requester (new)',
+    'send-batch-request': 'send-batch-request (old)'
+};
+/**
+ * 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,28 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+import { type CollectorType, type DistributionPattern } from '../test-helpers/testbench-utils.js';
+export type { DistributionPattern, CollectorType } from '../test-helpers/testbench-utils.js';
+export { COLLECTOR_DISPLAY_NAMES } from '../test-helpers/testbench-utils.js';
+export interface BenchReqRespCommand {
+    type: 'BENCH_REQRESP';
+    txCount: number;
+    peerCount: number;
+    distribution: DistributionPattern;
+    collectorType: CollectorType;
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUErQ0EsT0FBTyxFQUVMLEtBQUssYUFBYSxFQUNsQixLQUFLLG1CQUFtQixFQU96QixNQUFNLG9DQUFvQyxDQUFDO0FBRzVDLFlBQVksRUFBRSxtQkFBbUIsRUFBRSxhQUFhLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUM3RixPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUU3RSxNQUFNLFdBQVcsbUJBQW1CO0lBQ2xDLElBQUksRUFBRSxlQUFlLENBQUM7SUFDdEIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLFlBQVksRUFBRSxtQkFBbUIsQ0FBQztJQUNsQyxhQUFhLEVBQUUsYUFBYSxDQUFDO0lBQzdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsWUFBWSxFQUFFLE9BQU8sQ0FBQztJQUN0QixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN6QixZQUFZLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDdEIsV0FBVyxFQUFFLE1BQU0sQ0FBQztJQUNwQixJQUFJLEVBQUUsTUFBTSxDQUFDO0NBQ2Q7QUFFRCxNQUFNLFdBQVcsa0JBQWtCO0lBQ2pDLElBQUksRUFBRSxjQUFjLENBQUM7SUFDckIsVUFBVSxFQUFFLE1BQU0sQ0FBQztJQUNuQixZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLE9BQU8sRUFBRSxPQUFPLENBQUM7SUFDakIsS0FBSyxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2hCO0FBRUQsTUFBTSxXQUFXLGlCQUFpQjtJQUNoQyxJQUFJLEVBQUUsYUFBYSxDQUFDO0NBQ3JCIn0=

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":"AA+CA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,mBAAmB,EAOzB,MAAM,oCAAoC,CAAC;AAG5C,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,eAAe,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,mBAAmB,CAAC;IAClC,aAAa,EAAE,aAAa,CAAC;IAC7B,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"}