@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/services/tx_provider.ts

@@ -0,0 +1,215 @@
+import { compactArray } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import type { BlockInfo, L2Block } from '@aztec/stdlib/block';
+import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import type { PeerId } from '@libp2p/interface';
+
+import type { P2PClient } from '../client/p2p_client.js';
+import type { TxPool } from '../mem_pools/index.js';
+import type { FastCollectionRequestInput, TxCollection } from './tx_collection/tx_collection.js';
+import { TxProviderInstrumentation } from './tx_provider_instrumentation.js';
+
+/**
+ * Gathers and returns txs given a block proposal, block, or their hashes.
+ * Loads available txs from the tx pool, and  relies on a TxCollection service to collect txs from the network and other nodes.
+ */
+export class TxProvider implements ITxProvider {
+  protected instrumentation: TxProviderInstrumentation;
+
+  constructor(
+    private txCollection: TxCollection,
+    private txPool: TxPool,
+    private txValidator: Pick<P2PClient, 'validate'>,
+    private log: Logger = createLogger('p2p:tx-collector'),
+    client: TelemetryClient = getTelemetryClient(),
+  ) {
+    this.instrumentation = new TxProviderInstrumentation(client, 'TxProvider');
+  }
+
+  /** Returns txs from the tx pool given their hashes.*/
+  public async getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    const response = await this.txPool.getTxsByHash(txHashes);
+    if (response.length !== txHashes.length) {
+      throw new Error(`Unexpected response size from tx pool: expected ${txHashes.length} but got ${response.length}`);
+    }
+    const txs: Tx[] = [];
+    const missingTxs: TxHash[] = [];
+
+    for (let i = 0; i < txHashes.length; i++) {
+      const tx = response[i];
+      if (tx === undefined) {
+        missingTxs.push(txHashes[i]);
+      } else {
+        txs.push(tx.setTxHash(txHashes[i]));
+      }
+    }
+
+    return { txs, missingTxs };
+  }
+
+  /** Gathers txs from the tx pool, proposal body, remote rpc nodes, and reqresp. */
+  public getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getOrderedTxsFromAllSources(
+      { type: 'proposal', blockProposal },
+      blockProposal.toBlockInfo(),
+      blockProposal.txHashes,
+      { ...opts, pinnedPeer: opts.pinnedPeer },
+    );
+  }
+
+  /** Gathers txs from the tx pool, remote rpc nodes, and reqresp. */
+  public getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+    return this.getOrderedTxsFromAllSources(
+      { type: 'block', block },
+      block.toBlockInfo(),
+      block.body.txEffects.map(tx => tx.txHash),
+      { ...opts, pinnedPeer: undefined },
+    );
+  }
+
+  private async getOrderedTxsFromAllSources(
+    request: FastCollectionRequestInput,
+    blockInfo: BlockInfo,
+    txHashes: TxHash[],
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ) {
+    const [durationMs, result] = await elapsed(() => this.getTxsFromAllSources(request, blockInfo, txHashes, opts));
+    const { missingTxHashes, txsFromMempool, txsFromNetwork, txsFromProposal } = result;
+
+    const txs = [...(txsFromMempool ?? []), ...(txsFromProposal ?? []), ...(txsFromNetwork ?? [])];
+    const missingTxs = missingTxHashes?.length ?? 0;
+
+    const level = missingTxs === 0 ? 'verbose' : 'warn';
+    this.log[level](`Retrieved ${txs.length} out of ${blockInfo.txCount} txs for ${request.type}`, {
+      ...blockInfo,
+      txsFromProposal: txsFromProposal?.length,
+      txsFromMempool: txsFromMempool?.length,
+      txsFromNetwork: txsFromNetwork?.length,
+      missingTxs,
+      durationMs,
+    });
+
+    const orderedTxs = this.orderTxs(txs, txHashes);
+    if (orderedTxs.length + missingTxs !== txHashes.length) {
+      throw new Error(
+        `Error collecting txs for ${request.type} with ${txHashes.length} txs: found ${orderedTxs.length} and flagged ${missingTxs} as missing`,
+      );
+    }
+
+    return { txs: orderedTxs, missingTxs: (missingTxHashes ?? []).map(TxHash.fromString), durationMs };
+  }
+
+  private orderTxs(txs: Tx[], order: TxHash[]): Tx[] {
+    const txsMap = new Map(txs.map(tx => [tx.txHash.toString(), tx]));
+    return order.map(hash => txsMap.get(hash.toString())!).filter(tx => tx !== undefined);
+  }
+
+  private async getTxsFromAllSources(
+    request: FastCollectionRequestInput,
+    blockInfo: BlockInfo,
+    txHashes: TxHash[],
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ) {
+    const missingTxHashes = new Set(txHashes.map(txHash => txHash.toString()));
+    if (missingTxHashes.size === 0) {
+      this.log.debug(`Received request with no transactions`, blockInfo);
+      return {};
+    }
+
+    // First go to our tx pool and fetch whatever txs we have there
+    // We go to the mempool first since those txs are already validated
+    const txsFromMempool = compactArray(await this.txPool.getTxsByHash(txHashes));
+    txsFromMempool.forEach(tx => missingTxHashes.delete(tx.getTxHash().toString()));
+    this.instrumentation.incTxsFromMempool(txsFromMempool.length);
+    this.log.debug(
+      `Retrieved ${txsFromMempool.length} txs from mempool for block proposal (${missingTxHashes.size} pending)`,
+      { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+    );
+
+    if (missingTxHashes.size === 0) {
+      return { txsFromMempool };
+    }
+
+    // Take txs from the proposal body if there are any
+    // Note that we still have to validate these txs, but we do it in parallel with tx collection
+    const proposal = request.type === 'proposal' ? request.blockProposal : undefined;
+    const txsFromProposal = this.extractFromProposal(proposal, [...missingTxHashes]);
+    if (txsFromProposal.length > 0) {
+      this.instrumentation.incTxsFromProposals(txsFromProposal.length);
+      txsFromProposal.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
+      this.log.debug(`Retrieved ${txsFromProposal.length} txs from proposal body (${missingTxHashes.size} pending)`, {
+        ...blockInfo,
+        missingTxHashes: [...missingTxHashes],
+      });
+    }
+
+    if (missingTxHashes.size === 0) {
+      await this.processProposalTxs(txsFromProposal);
+      return { txsFromMempool, txsFromProposal };
+    }
+
+    // Start tx collection from the network if needed, while we validate the txs taken from the proposal in parallel
+    const [txsFromNetwork] = await Promise.all([
+      this.txCollection.collectFastFor(request, [...missingTxHashes], opts),
+      this.processProposalTxs(txsFromProposal),
+    ] as const);
+
+    if (txsFromNetwork.length > 0) {
+      txsFromNetwork.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
+      this.instrumentation.incTxsFromP2P(txsFromNetwork.length);
+      this.log.debug(
+        `Retrieved ${txsFromNetwork.length} txs from network for block proposal (${missingTxHashes.size} pending)`,
+        { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+      );
+    }
+
+    if (missingTxHashes.size === 0) {
+      return { txsFromNetwork, txsFromMempool, txsFromProposal };
+    }
+
+    // We are still missing txs, make one last attempt to collect them from our pool, in case they showed up somehow else
+    const moreTxsFromPool = compactArray(await this.txPool.getTxsByHash([...missingTxHashes].map(TxHash.fromString)));
+
+    if (moreTxsFromPool.length > 0) {
+      this.instrumentation.incTxsFromMempool(moreTxsFromPool.length);
+      this.log.debug(
+        `Retrieved ${moreTxsFromPool.length} txs from pool retry for block proposal (${missingTxHashes.size} pending)`,
+        { ...blockInfo, missingTxHashes: [...missingTxHashes] },
+      );
+    }
+
+    if (missingTxHashes.size > 0) {
+      this.instrumentation.incMissingTxs(missingTxHashes.size);
+    }
+
+    return {
+      txsFromNetwork,
+      txsFromMempool: [...txsFromMempool, ...moreTxsFromPool],
+      txsFromProposal,
+      missingTxHashes: [...missingTxHashes],
+    };
+  }
+
+  private extractFromProposal(proposal: BlockProposal | undefined, missingTxHashes: string[]): Tx[] {
+    if (!proposal) {
+      return [];
+    }
+    return compactArray(proposal.txs ?? []).filter(tx => missingTxHashes.includes(tx.getTxHash().toString()));
+  }
+
+  private async processProposalTxs(txs: Tx[]): Promise<void> {
+    if (txs.length === 0) {
+      return;
+    }
+    await this.txValidator.validate(txs);
+    await this.txPool.addTxs(txs);
+  }
+}

package/src/services/{tx_collect_instrumentation.ts → tx_provider_instrumentation.ts}

@@ -1,6 +1,6 @@
 import { Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
 
-export class TxCollectorInstrumentation {
+export class TxProviderInstrumentation {
   private txFromProposalCount: UpDownCounter;
   private txFromMempoolCount: UpDownCounter;
   private txFromP2PCount: UpDownCounter;
@@ -9,19 +9,19 @@ export class TxCollectorInstrumentation {
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_PROPOSALS_COUNT, {
+    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT, {
       description: 'The number of txs taken from block proposals',
     });
 
-    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_MEMPOOL_COUNT, {
+    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT, {
       description: 'The number of txs taken from the local mempool',
     });
 
-    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_P2P_COUNT, {
+    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT, {
       description: 'The number of txs taken from the p2p network',
     });
 
-    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_MISSING_TXS_COUNT, {
+    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_MISSING_TXS_COUNT, {
       description: 'The number of txs not found anywhere',
     });
   }

package/src/test-helpers/make-test-p2p-clients.ts

@@ -2,6 +2,7 @@ import { MockL2BlockSource } from '@aztec/archiver/test';
 import type { EpochCache } from '@aztec/epoch-cache';
 import { SecretValue } from '@aztec/foundation/config';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
@@ -105,6 +106,7 @@ export async function makeTestP2PClient(
     mockEpochCache,
     'test-p2p-client',
     undefined,
+    undefined,
     {
       txPool: mockTxPool as unknown as TxPool,
       attestationPool: mockAttestationPool as unknown as AttestationPool,
@@ -147,7 +149,7 @@ export async function makeAndStartTestP2PClients(numberOfPeers: number, testConf
     clients.push(client);
   }
 
-  await Promise.all(clients.map(client => client.isReady()));
+  await retryUntil(() => clients.every(c => c.isReady()), 'p2p clients started', 10, 0.5);
   testConfig.logger?.info(`Created and started ${clients.length} P2P clients at ports ${ports.join(',')}`, {
     ports,
     peerEnrs,
@@ -206,5 +208,5 @@ export async function makeTestP2PClients(numberOfPeers: number, testConfig: Make
 
 export async function startTestP2PClients(clients: P2PClient[]) {
   await Promise.all(clients.map(c => c.start()));
-  await Promise.all(clients.map(c => c.isReady()));
+  await retryUntil(() => clients.every(c => c.isReady()), 'p2p clients started', 10, 0.5);
 }

package/src/test-helpers/mock-pubsub.ts

@@ -110,6 +110,7 @@ export class MockPubSub implements PubSubLibp2p {
 class MockGossipSubService extends TypedEventEmitter<GossipsubEvents> implements GossipSubService {
   private logger = createLogger('p2p:test:mock-gossipsub');
   public subscribedTopics: Set<TopicStr> = new Set();
+  public readonly direct = new Set<string>();
 
   constructor(
     public peerId: PeerId,

package/src/test-helpers/reqresp-nodes.ts

@@ -151,10 +151,12 @@ export async function createTestLibP2PService<T extends P2PClientType>(
     reqresp,
     worldStateSynchronizer,
     protocolVersion,
+    epochCache,
   );
 
   p2pNode.services.pubsub.score.params.appSpecificWeight = 10;
-  p2pNode.services.pubsub.score.params.appSpecificScore = (peerId: string) => peerManager.getPeerScore(peerId);
+  p2pNode.services.pubsub.score.params.appSpecificScore = (peerId: string) =>
+    peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
 
   return new LibP2PService<T>(
     clientType,
@@ -188,6 +190,8 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [ReqRespSubProtocol.TX]: (_msg: any) => Promise.resolve(Buffer.from('tx')),
   [ReqRespSubProtocol.GOODBYE]: (_msg: any) => Promise.resolve(Buffer.from('goodbye')),
   [ReqRespSubProtocol.BLOCK]: (_msg: any) => Promise.resolve(Buffer.from('block')),
+  [ReqRespSubProtocol.AUTH]: (_msg: any) => Promise.resolve(Buffer.from('auth')),
+  [ReqRespSubProtocol.BLOCK_TXS]: (_msg: any) => Promise.resolve(Buffer.from('block_txs')),
 };
 
 // By default, all requests are valid
@@ -198,6 +202,8 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
   [ReqRespSubProtocol.TX]: noopValidator,
   [ReqRespSubProtocol.GOODBYE]: noopValidator,
   [ReqRespSubProtocol.BLOCK]: noopValidator,
+  [ReqRespSubProtocol.AUTH]: noopValidator,
+  [ReqRespSubProtocol.BLOCK_TXS]: noopValidator,
 };
 
 /**

package/src/testbench/p2p_client_testbench_worker.ts

@@ -19,6 +19,7 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 
 import type { Message, PeerId } from '@libp2p/interface';
 import { TopicValidatorResult } from '@libp2p/interface';
+import EventEmitter from 'events';
 
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
@@ -35,7 +36,7 @@ import type { PubSubLibp2p } from '../util.js';
 // Simple mock implementation
 function mockTxPool(): TxPool {
   // Mock all methods
-  return {
+  const pool: Omit<TxPool, keyof EventEmitter> = {
     isEmpty: () => Promise.resolve(false),
     addTxs: () => Promise.resolve(1),
     getTxByHash: () => Promise.resolve(undefined),
@@ -54,6 +55,7 @@ function mockTxPool(): TxPool {
     updateConfig: () => {},
     markTxsAsNonEvictable: () => Promise.resolve(),
   };
+  return Object.assign(new EventEmitter(), pool);
 }
 
 function mockAttestationPool(): AttestationPool {
@@ -66,6 +68,8 @@ function mockAttestationPool(): AttestationPool {
     deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
     getAttestationsForSlot: () => Promise.resolve([]),
     getAttestationsForSlotAndProposal: () => Promise.resolve([]),
+    addBlockProposal: () => Promise.resolve(),
+    getBlockProposal: () => Promise.resolve(undefined),
   };
 }
 
@@ -84,6 +88,8 @@ function mockEpochCache(): EpochCacheInterface {
       }),
     getEpochAndSlotInNextL1Slot: () => ({ epoch: 0n, slot: 0n, ts: 0n, now: 0n }),
     isInCommittee: () => Promise.resolve(false),
+    getRegisteredValidators: () => Promise.resolve([]),
+    filterInCommittee: () => Promise.resolve([]),
   };
 }
 
@@ -154,7 +160,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       const tx = Tx.fromBuffer(p2pMessage.payload);
       this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
 
-      const txHash = await tx.getTxHash();
+      const txHash = tx.getTxHash();
       const txHashString = txHash.toString();
       this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
       await this.mempools.txPool.addTxs([tx]);
@@ -204,6 +210,7 @@ process.on('message', async msg => {
         worldState,
         epochCache,
         'test-p2p-bench-worker',
+        undefined,
         telemetry,
         deps,
       );

package/src/util.ts

@@ -22,7 +22,7 @@ export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' |
   services: {
     pubsub: Pick<
       GossipSub,
-      'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult'
+      'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult' | 'direct'
     > & { score: Pick<GossipSub['score'], 'score'> };
   };
 }

package/dest/services/tx_collect_instrumentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tx_collect_instrumentation.d.ts","sourceRoot":"","sources":["../../src/services/tx_collect_instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAE5F,qBAAa,0BAA0B;IACrC,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,kBAAkB,CAAgB;IAC1C,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,eAAe,CAAgB;gBAE3B,MAAM,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM;IAoBjD,mBAAmB,CAAC,KAAK,EAAE,MAAM;IAIjC,iBAAiB,CAAC,KAAK,EAAE,MAAM;IAI/B,aAAa,CAAC,KAAK,EAAE,MAAM;IAI3B,aAAa,CAAC,KAAK,EAAE,MAAM;CAG5B"}

package/dest/services/tx_collector.d.ts

@@ -1,23 +0,0 @@
-import { type Logger } from '@aztec/foundation/log';
-import type { ITxCollector } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import type { PeerId } from '@libp2p/interface';
-import type { P2PClient } from '../client/p2p_client.js';
-export declare class TxCollector implements ITxCollector {
-    private p2pClient;
-    private log;
-    private instrumentation;
-    constructor(p2pClient: Pick<P2PClient, 'getTxsByHashFromPool' | 'hasTxsInPool' | 'getTxsByHash' | 'validate' | 'requestTxsByHash' | 'addTxsToPool'>, log?: Logger, client?: TelemetryClient);
-    private collectFromProposal;
-    collectForBlockProposal(proposal: BlockProposal, peerWhoSentTheProposal: PeerId | undefined): Promise<{
-        txs: Tx[];
-        missing?: TxHash[];
-    }>;
-    collectTransactions(txHashes: TxHash[], peerWhoSentTheProposal: PeerId | undefined): Promise<{
-        txs: Tx[];
-        missing?: TxHash[];
-    }>;
-}
-//# sourceMappingURL=tx_collector.d.ts.map

package/dest/services/tx_collector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tx_collector.d.ts","sourceRoot":"","sources":["../../src/services/tx_collector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,qBAAa,WAAY,YAAW,YAAY;IAG5C,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,GAAG;IANb,OAAO,CAAC,eAAe,CAA6B;gBAE1C,SAAS,EAAE,IAAI,CACrB,SAAS,EACT,sBAAsB,GAAG,cAAc,GAAG,cAAc,GAAG,UAAU,GAAG,kBAAkB,GAAG,cAAc,CAC5G,EACO,GAAG,GAAE,MAAyC,EACtD,MAAM,GAAE,eAAsC;YAMlC,mBAAmB;IAmD3B,uBAAuB,CAC3B,QAAQ,EAAE,aAAa,EACvB,sBAAsB,EAAE,MAAM,GAAG,SAAS,GACzC,OAAO,CAAC;QAAE,GAAG,EAAE,EAAE,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAmCvC,mBAAmB,CACvB,QAAQ,EAAE,MAAM,EAAE,EAClB,sBAAsB,EAAE,MAAM,GAAG,SAAS,GACzC,OAAO,CAAC;QAAE,GAAG,EAAE,EAAE,EAAE,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAe9C"}

package/dest/services/tx_collector.js

@@ -1,95 +0,0 @@
-import { compactArray } from '@aztec/foundation/collection';
-import { createLogger } from '@aztec/foundation/log';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { TxCollectorInstrumentation } from './tx_collect_instrumentation.js';
-export class TxCollector {
-    p2pClient;
-    log;
-    instrumentation;
-    constructor(p2pClient, log = createLogger('p2p:tx-collector'), client = getTelemetryClient()){
-        this.p2pClient = p2pClient;
-        this.log = log;
-        this.instrumentation = new TxCollectorInstrumentation(client, 'TxCollector');
-    }
-    // Checks the proposal for transactions we don't already have, validates them and adds them to our pool
-    async collectFromProposal(proposal) {
-        // Does this proposal have any transactions?
-        if (!proposal.txs || proposal.txs.length === 0) {
-            return 0;
-        }
-        const proposalHashes = new Set((proposal.payload.txHashes ?? []).map((txHash)=>txHash.toString()));
-        // Get the transactions from the proposal and their hashes
-        // also, we are only interested in txs that are part of the proposal
-        const txsFromProposal = compactArray(await Promise.all(proposal.txs.map((tx)=>tx === undefined ? Promise.resolve(undefined) : tx.getTxHash().then((hash)=>({
-                    txHash: hash,
-                    tx
-                }))))).filter((tx)=>proposalHashes.has(tx.txHash.toString()));
-        // Of the transactions from the proposal, retrieve those that we have in the pool already
-        const txsToValidate = [];
-        const txsWeAlreadyHave = await this.p2pClient.getTxsByHashFromPool(txsFromProposal.map((tx)=>tx.txHash));
-        // Txs we already have will have holes where we did not find them
-        // Where that is the case we need to validate the tx in the proposal
-        for(let i = 0; i < txsWeAlreadyHave.length; i++){
-            if (txsWeAlreadyHave[i] === undefined) {
-                txsToValidate.push(txsFromProposal[i].tx);
-            }
-        }
-        // Now validate all the transactions from the proposal that we don't have
-        // This will throw if any of the transactions are invalid, this is probably correct, if someone sends us a proposal with invalid
-        // transactions we probably shouldn't spend any more effort on it
-        try {
-            await this.p2pClient.validate(txsToValidate);
-        } catch (err) {
-            this.log.error(`Received proposal with invalid transactions, skipping`);
-            throw err;
-        }
-        // Now store these transactions in our pool, provided these are the txs in proposal.payload.txHashes they will be pinned already
-        await this.p2pClient.addTxsToPool(txsToValidate);
-        return txsToValidate.length;
-    }
-    async collectForBlockProposal(proposal, peerWhoSentTheProposal) {
-        if (proposal.payload.txHashes.length === 0) {
-            this.log.verbose(`Received block proposal with no transactions, skipping transaction availability check`);
-            return {
-                txs: []
-            };
-        }
-        const txsInMempool = (await this.p2pClient.hasTxsInPool(proposal.payload.txHashes)).filter(Boolean).length;
-        this.instrumentation.incTxsFromMempool(txsInMempool);
-        // Take txs from the proposal if there are any
-        const txTakenFromProposal = await this.collectFromProposal(proposal);
-        this.instrumentation.incTxsFromProposals(txTakenFromProposal);
-        // Now get the txs we need, either from the pool or the p2p network
-        const txHashes = proposal.payload.txHashes;
-        const { txs, missing } = await this.collectTransactions(txHashes, peerWhoSentTheProposal);
-        this.instrumentation.incMissingTxs(missing?.length ?? 0);
-        const txsFromP2P = txHashes.length - txTakenFromProposal - txsInMempool - (missing?.length ?? 0);
-        this.instrumentation.incTxsFromP2P(txsFromP2P);
-        this.log.info(`Retrieved ${txs.length}/${txHashes.length} txs for block proposal`, {
-            blockNumber: proposal.blockNumber,
-            slotNumber: proposal.slotNumber.toNumber(),
-            totalTxsInProposal: txHashes.length,
-            txsFromProposal: txTakenFromProposal,
-            txsFromMempool: txsInMempool,
-            txsFromP2P,
-            missingTxs: missing?.length ?? 0
-        });
-        return {
-            txs,
-            missing
-        };
-    }
-    async collectTransactions(txHashes, peerWhoSentTheProposal) {
-        // This will request from the network any txs that are missing
-        // NOTE: this could still return missing txs so we need to (1) be careful to handle undefined and (2) keep the txs in the correct order for re-execution
-        const maybeRetrievedTxs = await this.p2pClient.getTxsByHash(txHashes, peerWhoSentTheProposal);
-        // Get the txs that we didn't get from the network, if any. This will be empty if we got them al
-        const missingTxs = compactArray(maybeRetrievedTxs.map((tx, index)=>tx === undefined ? txHashes[index] : undefined));
-        // if we found all txs, this is a noop. If we didn't find all txs then tell the validator to skip attestations because missingTxs.length > 0
-        const retrievedTxs = compactArray(maybeRetrievedTxs);
-        return {
-            txs: retrievedTxs,
-            missing: missingTxs
-        };
-    }
-}

package/src/services/tx_collector.ts

@@ -1,134 +0,0 @@
-import { compactArray } from '@aztec/foundation/collection';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { ITxCollector } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { P2PClient } from '../client/p2p_client.js';
-import { TxCollectorInstrumentation } from './tx_collect_instrumentation.js';
-
-export class TxCollector implements ITxCollector {
-  private instrumentation: TxCollectorInstrumentation;
-  constructor(
-    private p2pClient: Pick<
-      P2PClient,
-      'getTxsByHashFromPool' | 'hasTxsInPool' | 'getTxsByHash' | 'validate' | 'requestTxsByHash' | 'addTxsToPool'
-    >,
-    private log: Logger = createLogger('p2p:tx-collector'),
-    client: TelemetryClient = getTelemetryClient(),
-  ) {
-    this.instrumentation = new TxCollectorInstrumentation(client, 'TxCollector');
-  }
-
-  // Checks the proposal for transactions we don't already have, validates them and adds them to our pool
-  private async collectFromProposal(proposal: BlockProposal): Promise<number> {
-    // Does this proposal have any transactions?
-    if (!proposal.txs || proposal.txs.length === 0) {
-      return 0;
-    }
-
-    const proposalHashes = new Set<string>((proposal.payload.txHashes ?? []).map(txHash => txHash.toString()));
-
-    // Get the transactions from the proposal and their hashes
-    // also, we are only interested in txs that are part of the proposal
-    const txsFromProposal = compactArray(
-      await Promise.all(
-        proposal.txs.map(tx =>
-          tx === undefined
-            ? Promise.resolve(undefined)
-            : tx.getTxHash().then(hash => ({
-                txHash: hash,
-                tx,
-              })),
-        ),
-      ),
-    ).filter(tx => proposalHashes.has(tx.txHash.toString()));
-
-    // Of the transactions from the proposal, retrieve those that we have in the pool already
-    const txsToValidate = [];
-    const txsWeAlreadyHave = await this.p2pClient.getTxsByHashFromPool(txsFromProposal.map(tx => tx.txHash));
-
-    // Txs we already have will have holes where we did not find them
-    // Where that is the case we need to validate the tx in the proposal
-    for (let i = 0; i < txsWeAlreadyHave.length; i++) {
-      if (txsWeAlreadyHave[i] === undefined) {
-        txsToValidate.push(txsFromProposal[i].tx);
-      }
-    }
-
-    // Now validate all the transactions from the proposal that we don't have
-    // This will throw if any of the transactions are invalid, this is probably correct, if someone sends us a proposal with invalid
-    // transactions we probably shouldn't spend any more effort on it
-    try {
-      await this.p2pClient.validate(txsToValidate);
-    } catch (err) {
-      this.log.error(`Received proposal with invalid transactions, skipping`);
-      throw err;
-    }
-
-    // Now store these transactions in our pool, provided these are the txs in proposal.payload.txHashes they will be pinned already
-    await this.p2pClient.addTxsToPool(txsToValidate);
-
-    return txsToValidate.length;
-  }
-
-  async collectForBlockProposal(
-    proposal: BlockProposal,
-    peerWhoSentTheProposal: PeerId | undefined,
-  ): Promise<{ txs: Tx[]; missing?: TxHash[] }> {
-    if (proposal.payload.txHashes.length === 0) {
-      this.log.verbose(`Received block proposal with no transactions, skipping transaction availability check`);
-      return { txs: [] };
-    }
-
-    const txsInMempool = (await this.p2pClient.hasTxsInPool(proposal.payload.txHashes)).filter(Boolean).length;
-    this.instrumentation.incTxsFromMempool(txsInMempool);
-
-    // Take txs from the proposal if there are any
-    const txTakenFromProposal = await this.collectFromProposal(proposal);
-    this.instrumentation.incTxsFromProposals(txTakenFromProposal);
-
-    // Now get the txs we need, either from the pool or the p2p network
-    const txHashes: TxHash[] = proposal.payload.txHashes;
-    const { txs, missing } = await this.collectTransactions(txHashes, peerWhoSentTheProposal);
-
-    this.instrumentation.incMissingTxs(missing?.length ?? 0);
-
-    const txsFromP2P = txHashes.length - txTakenFromProposal - txsInMempool - (missing?.length ?? 0);
-    this.instrumentation.incTxsFromP2P(txsFromP2P);
-
-    this.log.info(`Retrieved ${txs.length}/${txHashes.length} txs for block proposal`, {
-      blockNumber: proposal.blockNumber,
-      slotNumber: proposal.slotNumber.toNumber(),
-      totalTxsInProposal: txHashes.length,
-      txsFromProposal: txTakenFromProposal,
-      txsFromMempool: txsInMempool,
-      txsFromP2P,
-      missingTxs: missing?.length ?? 0,
-    });
-
-    return { txs, missing };
-  }
-
-  async collectTransactions(
-    txHashes: TxHash[],
-    peerWhoSentTheProposal: PeerId | undefined,
-  ): Promise<{ txs: Tx[]; missing?: TxHash[] }> {
-    // This will request from the network any txs that are missing
-    // NOTE: this could still return missing txs so we need to (1) be careful to handle undefined and (2) keep the txs in the correct order for re-execution
-    const maybeRetrievedTxs = await this.p2pClient.getTxsByHash(txHashes, peerWhoSentTheProposal);
-
-    // Get the txs that we didn't get from the network, if any. This will be empty if we got them al
-    const missingTxs = compactArray(
-      maybeRetrievedTxs.map((tx, index) => (tx === undefined ? txHashes[index] : undefined)),
-    );
-
-    // if we found all txs, this is a noop. If we didn't find all txs then tell the validator to skip attestations because missingTxs.length > 0
-    const retrievedTxs = compactArray(maybeRetrievedTxs);
-
-    return { txs: retrievedTxs, missing: missingTxs };
-  }
-}