@aztec/p2p 0.0.1-commit.6d63667d → 0.0.1-commit.86469d5

package/src/services/libp2p/libp2p_service.ts

@@ -60,21 +60,21 @@ import { createLibp2p } from 'libp2p';
 
 import type { P2PConfig } from '../../config.js';
 import { ProposalSlotCapExceededError } from '../../errors/attestation-pool.error.js';
-import type { MemPools } from '../../mem_pools/index.js';
+import type { MemPools } from '../../mem_pools/interface.js';
 import {
   BlockProposalValidator,
   CheckpointAttestationValidator,
   CheckpointProposalValidator,
-  DoubleSpendTxValidator,
   FishermanAttestationValidator,
-  getDefaultAllowedSetupFunctions,
 } from '../../msg_validators/index.js';
 import { MessageSeenValidator } from '../../msg_validators/msg_seen_validator/msg_seen_validator.js';
+import { getDefaultAllowedSetupFunctions } from '../../msg_validators/tx_validator/allowed_public_setup.js';
 import {
   type MessageValidator,
   createTxMessageValidators,
   createTxReqRespValidator,
 } from '../../msg_validators/tx_validator/factory.js';
+import { DoubleSpendTxValidator } from '../../msg_validators/tx_validator/index.js';
 import { GossipSubEvent } from '../../types/index.js';
 import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
 import { getVersions } from '../../versioning.js';
@@ -97,19 +97,19 @@ import {
   type ReqRespSubProtocolValidators,
   type SubProtocolMap,
   ValidationError,
-} from '../reqresp/index.js';
+} from '../reqresp/interface.js';
+import { reqRespBlockTxsHandler } from '../reqresp/protocols/block_txs/block_txs_handler.js';
+import { reqGoodbyeHandler } from '../reqresp/protocols/goodbye.js';
 import {
   AuthRequest,
   BlockTxsRequest,
   BlockTxsResponse,
   StatusMessage,
   pingHandler,
-  reqGoodbyeHandler,
   reqRespBlockHandler,
-  reqRespBlockTxsHandler,
   reqRespStatusHandler,
   reqRespTxHandler,
-} from '../reqresp/index.js';
+} from '../reqresp/protocols/index.js';
 import { ReqResp } from '../reqresp/reqresp.js';
 import type {
   P2PBlockReceivedCallback,
@@ -524,11 +524,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     };
 
     if (!this.config.disableTransactions) {
-      const blockTxsHandler = reqRespBlockTxsHandler(
-        this.mempools.attestationPool,
-        this.archiver,
-        this.mempools.txPool,
-      );
+      const blockTxsHandler = reqRespBlockTxsHandler(this.mempools.attestationPool, this.mempools.txPool);
       requestResponseHandlers[ReqRespSubProtocol.BLOCK_TXS] = blockTxsHandler.bind(this);
     }
 

package/src/services/reqresp/batch-tx-requester/README.md

@@ -1,14 +1,14 @@
 # BatchTxRequester
 
-The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node lacks some of the referenced transactions. It serves two pathways: (1) block proposals, where validators need all transactions to attest, and (2) block proving, where provers need all transactions to generate proofs.
+The `BatchTxRequester` is a specialized P2P service that aggressively fetches missing transactions from peers when a node receives a block proposal but lacks some of the referenced transactions. This is critical for validators who need all transactions to attest to a proposal.
 
 ## Overview
 
-When a validator receives a block proposal or a prover needs to prove a block, they must have all transactions. If some transactions are missing from the local mempool (e.g., due to gossip delays), the `BatchTxRequester` kicks in to fetch them via direct peer-to-peer requests before the deadline.
+When a validator receives a block proposal, they must verify all transactions in the block. If some transactions are missing from the local mempool (e.g., due to gossip delays), the `BatchTxRequester` kicks in to fetch them via direct peer-to-peer requests before the attestation deadline.
 
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
-│                      Block Proposal or Block Received                       │
+│                           Block Proposal Received                           │
 │                     (contains hashes of N transactions)                     │
 └─────────────────────────────────────────────────────────────────────────────┘
                                       │
@@ -230,8 +230,8 @@ Request to peer fails
 ```typescript
 const requester = new BatchTxRequester(
   missingTxHashes,      // TxHash[] - what we need
-  blockTxsSource,       // BlockTxsSource - the proposal or block we need txs for
-  pinnedPeer,           // PeerId | undefined - peer expected to have the txs
+  blockProposal,        // BlockProposal - the proposal we're attesting to
+  pinnedPeer,           // PeerId | undefined - who sent us the proposal
   timeoutMs,            // number - how long to try
   p2pService,           // BatchTxRequesterLibP2PService
 );
@@ -268,14 +268,14 @@ const txs = await BatchTxRequester.collectAllTxs(requester.run());
 ┌───────────────────────────────────┐   ┌─────────────────────────────────────┐
 │        FastTxCollection           │   │         SlowTxCollection            │
 │                                   │   │                                     │
-│  Time-critical: proposals/proving │   │  Background: unproven blocks        │
+│  Time-critical: attestations      │   │  Background: unproven blocks        │
 │                                   │   │                                     │
 │  1. Try RPC nodes first (fast)    │   │  Periodic polling of RPC nodes      │
 │  2. Fall back to BatchTxRequester │   │  and peers for missing txs          │
 │                                   │   │                                     │
 └───────────────────┬───────────────┘   └─────────────────────────────────────┘
                     │
-                    │ For 'proposal' and 'block' requests
+                    │ For 'proposal' requests
                     ▼
 ┌─────────────────────────────────────────────────────────────────────────────┐
 │                           BatchTxRequester                                  │

package/src/services/reqresp/batch-tx-requester/batch_tx_requester.ts

@@ -4,14 +4,14 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { FifoMemoryQueue, type ISemaphore, Semaphore } from '@aztec/foundation/queue';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, executeTimeout } from '@aztec/foundation/timer';
-import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type BlockProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Tx, TxArray, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
 import { ReqRespSubProtocol } from '.././interface.js';
-import { BlockTxsRequest, BlockTxsResponse, type BlockTxsSource } from '.././protocols/index.js';
+import { BlockTxsRequest, BlockTxsResponse } from '.././protocols/index.js';
 import { ReqRespStatus } from '.././status.js';
 import {
   DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD,
@@ -42,7 +42,7 @@ import { BatchRequestTxValidator, type IBatchRequestTxValidator } from './tx_val
  *    - Is the peer which was unable to send us successful response N times in a row
  * */
 export class BatchTxRequester {
-  private readonly blockTxsSource: BlockTxsSource;
+  private readonly blockProposal: BlockProposal;
   private readonly pinnedPeer: PeerId | undefined;
   private readonly timeoutMs: number;
   private readonly p2pService: BatchTxRequesterLibP2PService;
@@ -61,7 +61,7 @@ export class BatchTxRequester {
 
   constructor(
     missingTxs: TxHash[],
-    blockTxsSource: BlockTxsSource,
+    blockProposal: BlockProposal,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
     p2pService: BatchTxRequesterLibP2PService,
@@ -69,7 +69,7 @@ export class BatchTxRequester {
     dateProvider?: DateProvider,
     opts?: BatchTxRequesterOptions,
   ) {
-    this.blockTxsSource = blockTxsSource;
+    this.blockProposal = blockProposal;
     this.pinnedPeer = pinnedPeer;
     this.timeoutMs = timeoutMs;
     this.p2pService = p2pService;
@@ -205,7 +205,7 @@ export class BatchTxRequester {
         return;
       }
 
-      const request = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
+      const request = BlockTxsRequest.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
       if (!request) {
         return;
       }
@@ -249,8 +249,8 @@ export class BatchTxRequester {
       // If peer is dumb peer, we don't know yet if they received full blockProposal
       // there is solid chance that peer didn't receive proposal yet, thus we must send full hashes
       const includeFullHashesInRequestNotJustIndices = true;
-      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(
-        this.blockTxsSource,
+      const blockRequest = BlockTxsRequest.fromBlockProposalAndMissingTxs(
+        this.blockProposal,
         txs,
         includeFullHashesInRequestNotJustIndices,
       );
@@ -342,7 +342,7 @@ export class BatchTxRequester {
 
     const makeRequest = (pid: PeerId) => {
       const txs = this.txsMetadata.getTxsToRequestFromThePeer(pid);
-      const blockRequest = BlockTxsRequest.fromTxsSourceAndMissingTxs(this.blockTxsSource, txs);
+      const blockRequest = BlockTxsRequest.fromBlockProposalAndMissingTxs(this.blockProposal, txs);
       if (!blockRequest) {
         return undefined;
       }
@@ -605,7 +605,7 @@ export class BatchTxRequester {
   }
 
   private isBlockResponseValid(response: BlockTxsResponse): boolean {
-    const archiveRootsMatch = this.blockTxsSource.archive.toString() === response.archiveRoot.toString();
+    const archiveRootsMatch = this.blockProposal.archive.toString() === response.archiveRoot.toString();
     const peerHasSomeTxsFromProposal = !response.txIndices.isEmpty();
     return archiveRootsMatch && peerHasSomeTxsFromProposal;
   }
@@ -624,7 +624,7 @@ export class BatchTxRequester {
   private extractHashesPeerHasFromResponse(response: BlockTxsResponse): Array<TxHash> {
     const hashes: TxHash[] = [];
     const indicesOfHashesPeerHas = new Set(response.txIndices.getTrueIndices());
-    this.blockTxsSource.txHashes.forEach((hash, idx) => {
+    this.blockProposal.txHashes.forEach((hash, idx) => {
       if (indicesOfHashesPeerHas.has(idx)) {
         hashes.push(hash);
       }

package/src/services/reqresp/protocols/block_txs/block_txs_handler.ts

@@ -1,10 +1,10 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import type { L2BlockSource } from '@aztec/stdlib/block';
 import { TxArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
-import type { AttestationPool, TxPool } from '../../../../mem_pools/index.js';
+import type { AttestationPool } from '../../../../mem_pools/attestation_pool/attestation_pool.js';
+import type { TxPool } from '../../../../mem_pools/index.js';
 import type { ReqRespSubProtocolHandler } from '../../interface.js';
 import { ReqRespStatus, ReqRespStatusError } from '../../status.js';
 import { BitVector } from './bitvector.js';
@@ -13,15 +13,10 @@ import { BlockTxsRequest, BlockTxsResponse } from './block_txs_reqresp.js';
 /**
  * Handler for block txs requests
  * @param attestationPool - the attestation pool to check for block proposals
- * @param archiver - the archiver to look up blocks by archive root
- * @param txPool - the tx pool to fetch transactions from
+ * @param mempools - the mempools containing the tx pool
  * @returns the BlockTxs request handler
  */
-export function reqRespBlockTxsHandler(
-  attestationPool: AttestationPool,
-  archiver: L2BlockSource,
-  txPool: TxPool,
-): ReqRespSubProtocolHandler {
+export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool: TxPool): ReqRespSubProtocolHandler {
   /**
    * Handler for block txs requests
    * @param msg - the block txs request message
@@ -35,37 +30,34 @@ export function reqRespBlockTxsHandler(
     } catch (err: any) {
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
     }
-    // First try attestation pool, then fall back to archiver
-    let txHashes = (await attestationPool.getBlockProposal(request.archiveRoot.toString()))?.txHashes;
-    if (!txHashes) {
-      txHashes = (await archiver.getL2BlockByArchive(request.archiveRoot))?.body.txEffects.map(effect => effect.txHash);
-    }
+
+    const blockProposal = await attestationPool.getBlockProposal(request.archiveRoot.toString());
 
     let requestedTxsHashes;
     if (request.txHashes.length > 0) {
       requestedTxsHashes = request.txHashes;
     }
 
-    // This is scenario in which we don't have this block the peer is requesting from us
+    // This is scenario in which we don't have this block proposal the peer is requesting from us
     // But peer has sent requested tx hashes, so we can send them the transactions
-    if (!txHashes && requestedTxsHashes !== undefined) {
+    if (!blockProposal && requestedTxsHashes !== undefined) {
       const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter(tx => !!tx);
       const response = new BlockTxsResponse(Fr.zero(), new TxArray(...responseTxs), BitVector.init(0, []));
       return response.toBuffer();
     }
 
-    // If we don't have this block and peer has not sent requested tx hashes
-    if (!txHashes) {
+    // If don't have this block proposal and peer has not sent requested tx hashes
+    if (!blockProposal) {
       throw new ReqRespStatusError(ReqRespStatus.NOT_FOUND);
     }
 
-    const txsAvailableInPool = await txPool.hasTxs(txHashes);
-    // Map txs in the pool to their indices in the block
+    const txsAvailableInPool = await txPool.hasTxs(blockProposal.txHashes);
+    //Map txs in the pool to their indices in the block proposal
     const availableIndices = txsAvailableInPool.map((hasTx, idx) => (hasTx ? idx : -1)).filter(idx => idx !== -1);
-    const responseBitVector = BitVector.init(txHashes.length, availableIndices);
+    const responseBitVector = BitVector.init(blockProposal.txHashes.length, availableIndices);
 
     const requestedIndices = new Set(request.txIndices.getTrueIndices());
-    requestedTxsHashes = txHashes.filter((_, idx) => requestedIndices.has(idx));
+    requestedTxsHashes = blockProposal.txHashes.filter((_, idx) => requestedIndices.has(idx));
 
     const responseTxs = (await txPool.getTxsByHash(requestedTxsHashes)).filter(tx => !!tx);
     const response = new BlockTxsResponse(request.archiveRoot, new TxArray(...responseTxs), responseBitVector);

package/src/services/reqresp/protocols/block_txs/block_txs_reqresp.ts

@@ -1,15 +1,10 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { TxArray, type TxHash, TxHashArray } from '@aztec/stdlib/tx';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import { BitVector } from './bitvector.js';
 
-/** Minimal interface for a block source that provides tx hashes and an archive root. */
-export interface BlockTxsSource {
-  txHashes: TxHash[];
-  archive: Fr;
-}
-
 /**
  * Request message for requesting specific transactions from a block
  */
@@ -27,17 +22,16 @@ export class BlockTxsRequest {
   ) {}
 
   /**
-   * Creates new BlockTxsRequest given a block txs source and missing tx hashes.
+   * Creates new BlockTxsRequest given proposal and missing tx hashes
    *
-   * @param blockTxsSource - The block or proposal for which we are making the request
-   * @param missingTxHashes - Tx hashes from the source we are missing
-   * @param includeFullTxHashes - Whether to include full list of missing tx hashes in the request or just Bitvector indices
+   * @param: blockProposal - The block proposal for which we are making request
+   * @param: missingTxHashes - Tx hashes from the proposal we are missing
+   * @param: includeFullTxHashes - Whether to include full list of missing tx hashes in the request or just Bitvector indices
    *
-   * @returns undefined if there were no missingTxHashes matching the source hashes, otherwise
-   * returns new BlockTxsRequest
-   */
-  static fromTxsSourceAndMissingTxs(
-    blockTxsSource: BlockTxsSource,
+   * @returns undefined if there were no missingTxHashes matching BlockProposal hashes, otherwise
+   * returns new BlockTxsRequest*/
+  static fromBlockProposalAndMissingTxs(
+    blockProposal: BlockProposal,
     missingTxHashes: TxHash[],
     includeFullTxHashes = false,
   ): BlockTxsRequest | undefined {
@@ -47,19 +41,19 @@ export class BlockTxsRequest {
 
     const missingHashesSet = new Set(missingTxHashes.map(t => t.toString()));
 
-    // We cannot request txs that are not part of the block
-    if (!missingHashesSet.isSubsetOf(new Set(blockTxsSource.txHashes.map(t => t.toString())))) {
+    // We cannot request txs that are not part of the block proposal
+    if (!missingHashesSet.isSubsetOf(new Set(blockProposal.txHashes.map(t => t.toString())))) {
       return undefined;
     }
 
-    const missingIndices = blockTxsSource.txHashes
+    const missingIndices = blockProposal.txHashes
       .map((hash, idx) => (missingHashesSet.has(hash.toString()) ? idx : -1))
       .filter(i => i != -1);
 
-    const requestBitVector = BitVector.init(blockTxsSource.txHashes.length, missingIndices);
+    const requestBitVector = BitVector.init(blockProposal.txHashes.length, missingIndices);
     const hashes = includeFullTxHashes ? new TxHashArray(...missingTxHashes) : new TxHashArray();
 
-    return new BlockTxsRequest(blockTxsSource.archive, hashes, requestBitVector);
+    return new BlockTxsRequest(blockProposal.archive, hashes, requestBitVector);
   }
 
   /**

package/src/services/tx_collection/config.ts

@@ -6,7 +6,7 @@ import {
 } from '@aztec/foundation/config';
 import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
-export type MissingTxsCollectorType = 'new' | 'old';
+export type ProposalTxCollectorType = 'new' | 'old';
 
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */
@@ -29,8 +29,8 @@ export type TxCollectionConfig = {
   txCollectionFastMaxParallelRequestsPerNode: number;
   /** Maximum number of transactions to request from a node in a single batch */
   txCollectionNodeRpcMaxBatchSize: number;
-  /** Which collector implementation to use for missing txs collection */
-  txCollectionMissingTxsCollectorType: MissingTxsCollectorType;
+  /** Which collector implementation to use for proposal tx collection */
+  txCollectionProposalTxCollectorType: ProposalTxCollectorType;
 };
 
 export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
@@ -90,9 +90,9 @@ export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig>
     description: 'Maximum number of transactions to request from a node in a single batch',
     ...numberConfigHelper(MAX_RPC_TXS_LEN),
   },
-  txCollectionMissingTxsCollectorType: {
-    env: 'TX_COLLECTION_MISSING_TXS_COLLECTOR_TYPE',
-    description: 'Which collector implementation to use for missing txs collection (new or old)',
+  txCollectionProposalTxCollectorType: {
+    env: 'TX_COLLECTION_PROPOSAL_TX_COLLECTOR_TYPE',
+    description: 'Which collector implementation to use for proposal tx collection (new or old)',
     ...enumConfigHelper(['new', 'old'] as const, 'new'),
   },
 };

package/src/services/tx_collection/fast_tx_collection.ts

@@ -2,6 +2,7 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { times } from '@aztec/foundation/collection';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { boundInclusive } from '@aztec/foundation/number';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider, elapsed } from '@aztec/foundation/timer';
@@ -13,10 +14,12 @@ import type { PeerId } from '@libp2p/interface';
 
 import type { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/config.js';
 import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
 import type { TxCollectionConfig } from './config.js';
 import {
   BatchTxRequesterCollector,
-  type MissingTxsCollector,
+  type ProposalTxCollector,
   SendBatchRequestCollector,
 } from './proposal_tx_collector.js';
 import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
@@ -26,22 +29,22 @@ import type { TxSource } from './tx_source.js';
 export class FastTxCollection {
   // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
   protected requests: Set<FastCollectionRequest> = new Set();
-  private missingTxsCollector: MissingTxsCollector;
+  private proposalTxCollector: ProposalTxCollector;
 
   constructor(
-    p2pService: BatchTxRequesterLibP2PService,
+    private p2pService: BatchTxRequesterLibP2PService,
     private nodes: TxSource[],
     private txCollectionSink: TxCollectionSink,
     private config: TxCollectionConfig,
     private dateProvider: DateProvider = new DateProvider(),
     private log: Logger = createLogger('p2p:tx_collection_service'),
-    missingTxsCollector?: MissingTxsCollector,
+    proposalTxCollector?: ProposalTxCollector,
   ) {
     const batchTxRequesterConfig = this.config as Partial<BatchTxRequesterConfig>;
-    const missingTxsCollectorType = this.config.txCollectionMissingTxsCollectorType;
-    this.missingTxsCollector =
-      missingTxsCollector ??
-      (missingTxsCollectorType === 'old'
+    const proposalCollectorType = this.config.txCollectionProposalTxCollectorType;
+    this.proposalTxCollector =
+      proposalTxCollector ??
+      (proposalCollectorType === 'old'
         ? new SendBatchRequestCollector(p2pService)
         : new BatchTxRequesterCollector(p2pService, log, dateProvider, undefined, batchTxRequesterConfig));
   }
@@ -255,6 +258,8 @@ export class FastTxCollection {
   private async collectFastViaReqResp(request: FastCollectionRequest, opts: { pinnedPeer?: PeerId }) {
     const timeoutMs = +request.deadline - this.dateProvider.now();
     const pinnedPeer = opts.pinnedPeer;
+    const maxPeers = boundInclusive(Math.ceil(request.missingTxHashes.size / 2), 8, 32);
+    const maxRetryAttempts = 5;
     const blockInfo = request.blockInfo;
     const slotNumber = blockInfo.slotNumber;
     if (timeoutMs < 100) {
@@ -274,13 +279,18 @@ export class FastTxCollection {
       await this.txCollectionSink.collect(
         async txHashes => {
           if (request.type === 'proposal') {
-            return await this.missingTxsCollector.collectTxs(txHashes, request.blockProposal, pinnedPeer, timeoutMs);
+            return await this.proposalTxCollector.collectTxs(txHashes, request.blockProposal, pinnedPeer, timeoutMs);
           } else if (request.type === 'block') {
-            const blockTxsSource = {
-              txHashes: request.block.body.txEffects.map(e => e.txHash),
-              archive: request.block.archive.root,
-            };
-            return await this.missingTxsCollector.collectTxs(txHashes, blockTxsSource, pinnedPeer, timeoutMs);
+            const txs = await this.p2pService.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
+              ReqRespSubProtocol.TX,
+              chunkTxHashesRequest(txHashes),
+              pinnedPeer,
+              timeoutMs,
+              maxPeers,
+              maxRetryAttempts,
+            );
+
+            return txs.flat();
           } else {
             throw new Error(`Unknown request type: ${(request as any).type}`);
           }

package/src/services/tx_collection/index.ts

@@ -1,7 +1,7 @@
 export { TxCollection, type FastCollectionRequestInput } from './tx_collection.js';
 export { type TxSource, createNodeRpcTxSources, NodeRpcTxSource } from './tx_source.js';
 export {
-  type MissingTxsCollector,
+  type ProposalTxCollector,
   BatchTxRequesterCollector,
   SendBatchRequestCollector,
 } from './proposal_tx_collector.js';

package/src/services/tx_collection/proposal_tx_collector.ts

@@ -1,5 +1,6 @@
 import type { Logger } from '@aztec/foundation/log';
 import type { DateProvider } from '@aztec/foundation/timer';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -8,24 +9,25 @@ import { BatchTxRequester } from '../reqresp/batch-tx-requester/batch_tx_request
 import type { BatchTxRequesterConfig } from '../reqresp/batch-tx-requester/config.js';
 import type { BatchTxRequesterLibP2PService } from '../reqresp/batch-tx-requester/interface.js';
 import type { IBatchRequestTxValidator } from '../reqresp/batch-tx-requester/tx_validator.js';
-import { type BlockTxsSource, ReqRespSubProtocol, chunkTxHashesRequest } from '../reqresp/index.js';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { chunkTxHashesRequest } from '../reqresp/protocols/tx.js';
 
 /**
- * Strategy interface for collecting missing transactions for a block or proposal.
+ * Strategy interface for collecting transactions for block proposals.
  * Allows swapping between different tx collection implementations for benchmarking.
  */
-export interface MissingTxsCollector {
+export interface ProposalTxCollector {
   /**
-   * Collect missing transactions for a block or proposal.
+   * Collect transactions for a block proposal.
    * @param txHashes - The transaction hashes to collect
-   * @param blockTxsSource - The block or proposal containing the transactions
-   * @param pinnedPeer - Optional peer expected to have the transactions
+   * @param blockProposal - The block proposal containing the transactions
+   * @param pinnedPeer - Optional peer that sent the proposal (expected to have all txs)
    * @param timeoutMs - Timeout in milliseconds
    * @returns The collected transactions
    */
   collectTxs(
     txHashes: TxHash[],
-    blockTxsSource: BlockTxsSource,
+    blockProposal: BlockProposal,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
   ): Promise<Tx[]>;
@@ -35,7 +37,7 @@ export interface MissingTxsCollector {
  * Collects transactions using the BatchTxRequester implementation.
  * This uses a smart/dumb peer strategy with parallel workers.
  */
-export class BatchTxRequesterCollector implements MissingTxsCollector {
+export class BatchTxRequesterCollector implements ProposalTxCollector {
   constructor(
     private p2pService: BatchTxRequesterLibP2PService,
     private log: Logger,
@@ -46,7 +48,7 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
 
   async collectTxs(
     txHashes: TxHash[],
-    blockTxsSource: BlockTxsSource,
+    blockProposal: BlockProposal,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
   ): Promise<Tx[]> {
@@ -59,7 +61,7 @@ export class BatchTxRequesterCollector implements MissingTxsCollector {
 
     const batchRequester = new BatchTxRequester(
       txHashes,
-      blockTxsSource,
+      blockProposal,
       pinnedPeer,
       timeoutMs,
       this.p2pService,
@@ -85,7 +87,7 @@ const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
  * Collects transactions using the sendBatchRequest implementation from ReqResp.
  * This is the original implementation that balances requests across peers.
  */
-export class SendBatchRequestCollector implements MissingTxsCollector {
+export class SendBatchRequestCollector implements ProposalTxCollector {
   constructor(
     private p2pService: BatchTxRequesterLibP2PService,
     private maxPeers: number = DEFAULT_MAX_PEERS,
@@ -94,7 +96,7 @@ export class SendBatchRequestCollector implements MissingTxsCollector {
 
   async collectTxs(
     txHashes: TxHash[],
-    _blockTxsSource: BlockTxsSource,
+    _blockProposal: BlockProposal,
     pinnedPeer: PeerId | undefined,
     timeoutMs: number,
   ): Promise<Tx[]> {

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts

@@ -1,2 +0,0 @@
-export { TxArchive } from './tx_archive.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9hcmNoaXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dest/mem_pools/tx_pool_v2/archive/index.js

@@ -1 +0,0 @@
-export { TxArchive } from './tx_archive.js';

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts

@@ -1,43 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
-/**
- * Manages archived transactions with FIFO eviction.
- * Archived transactions have their proofs stripped to save space.
- */
-export declare class TxArchive {
-    #private;
-    constructor(store: AztecAsyncKVStore, limit: number, log?: Logger);
-    /**
-     * Updates the maximum number of archived transactions.
-     */
-    updateLimit(limit: number): void;
-    /**
-     * Gets the current archive limit.
-     */
-    getLimit(): number;
-    /**
-     * Checks if archiving is enabled.
-     */
-    isEnabled(): boolean;
-    /**
-     * Archives transactions, stripping their proofs.
-     * Evicts oldest transactions if the limit is exceeded.
-     */
-    archiveTxs(txs: Tx[]): Promise<void>;
-    /**
-     * Retrieves an archived transaction by its hash.
-     */
-    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-    /**
-     * Gets the current count of archived transactions.
-     */
-    getCount(): Promise<number>;
-    /**
-     * Strips the proof from a transaction for archival.
-     */
-    private stripProof;
-    private getHeadIndex;
-    private getTailIndex;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfYXJjaGl2ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2FyY2hpdmUvdHhfYXJjaGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFFeEUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qzs7O0dBR0c7QUFDSCxxQkFBYSxTQUFTOztJQU9wQixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxFQUFFLE1BQU0sRUFNaEU7SUFFRDs7T0FFRztJQUNILFdBQVcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FFL0I7SUFFRDs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQ7O09BRUc7SUFDSCxTQUFTLElBQUksT0FBTyxDQUVuQjtJQUVEOzs7T0FHRztJQUNHLFVBQVUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1DekM7SUFFRDs7T0FFRztJQUNHLFdBQVcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLENBR3pEO0lBRUQ7O09BRUc7SUFDRyxRQUFRLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUloQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLFVBQVU7WUFJSixZQUFZO1lBS1osWUFBWTtDQUkzQiJ9

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tx_archive.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/tx_archive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AAExE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,SAAS;;IAOpB,YAAY,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAMhE;IAED;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/B;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,SAAS,IAAI,OAAO,CAEnB;IAED;;;OAGG;IACG,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCzC;IAED;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAGzD;IAED;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAIhC;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;YAIJ,YAAY;YAKZ,YAAY;CAI3B"}