@aztec/p2p 0.0.1-commit.f295ac2 → 0.0.1-commit.fc805bf

package/src/services/reqresp/metrics.ts

@@ -1,7 +1,9 @@
 // Request response metrics
-import { Attributes, Metrics } from '@aztec/telemetry-client';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 import type { TelemetryClient, Tracer, UpDownCounter } from '@aztec/telemetry-client';
 
+import { ReqRespSubProtocol } from './interface.js';
+
 export class ReqRespMetrics {
   public readonly tracer: Tracer;
 
@@ -18,27 +20,50 @@ export class ReqRespMetrics {
     this.tracer = telemetryClient.getTracer(name);
 
     const meter = telemetryClient.getMeter(name);
-    this.sentRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_SENT_REQUESTS);
-    this.receivedRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS);
+    const protocolAttrs = {
+      [Attributes.P2P_REQ_RESP_PROTOCOL]: [
+        ReqRespSubProtocol.PING,
+        ReqRespSubProtocol.STATUS,
+        ReqRespSubProtocol.GOODBYE,
+        ReqRespSubProtocol.TX,
+        ReqRespSubProtocol.BLOCK,
+        ReqRespSubProtocol.AUTH,
+        ReqRespSubProtocol.BLOCK_TXS,
+      ],
+    };
+    this.sentRequests = createUpDownCounterWithDefault(meter, Metrics.P2P_REQ_RESP_SENT_REQUESTS, protocolAttrs);
+    this.receivedRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_RECEIVED_REQUESTS,
+      protocolAttrs,
+    );
 
-    this.failedOutboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS);
+    this.failedOutboundRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_FAILED_OUTBOUND_REQUESTS,
+      protocolAttrs,
+    );
 
-    this.failedInboundRequests = meter.createUpDownCounter(Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS);
+    this.failedInboundRequests = createUpDownCounterWithDefault(
+      meter,
+      Metrics.P2P_REQ_RESP_FAILED_INBOUND_REQUESTS,
+      protocolAttrs,
+    );
   }
 
-  public recordRequestSent(protocol: string) {
+  public recordRequestSent(protocol: ReqRespSubProtocol) {
     this.sentRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordRequestReceived(protocol: string) {
+  public recordRequestReceived(protocol: ReqRespSubProtocol) {
     this.receivedRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordRequestError(protocol: string) {
+  public recordRequestError(protocol: ReqRespSubProtocol) {
     this.failedOutboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 
-  public recordResponseError(protocol: string) {
+  public recordResponseError(protocol: ReqRespSubProtocol) {
     this.failedInboundRequests.add(1, { [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol });
   }
 }

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

@@ -64,6 +64,13 @@ export class BitVector {
     return Array.from({ length: this.length }, (_, i) => i).filter(i => this.isSet(i));
   }
 
+  /**
+   * Returns true if no indices are set to true
+   * */
+  isEmpty(): boolean {
+    return this.getTrueIndices().length === 0;
+  }
+
   /**
    * Serializes the BitVector object into a Buffer
    *

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

@@ -1,3 +1,4 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { TxArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -30,8 +31,22 @@ export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool:
       throw new ReqRespStatusError(ReqRespStatus.BADLY_FORMED_REQUEST, { cause: err });
     }
 
-    const blockProposal = await attestationPool.getBlockProposal(request.blockHash.toString());
+    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 proposal the peer is requesting from us
+    // But peer has sent requested tx hashes, so we can send them the transactions
+    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 don't have this block proposal and peer has not sent requested tx hashes
     if (!blockProposal) {
       throw new ReqRespStatusError(ReqRespStatus.NOT_FOUND);
     }
@@ -42,11 +57,10 @@ export function reqRespBlockTxsHandler(attestationPool: AttestationPool, txPool:
     const responseBitVector = BitVector.init(blockProposal.txHashes.length, availableIndices);
 
     const requestedIndices = new Set(request.txIndices.getTrueIndices());
-    const requestedTxsHashes = blockProposal.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.blockHash, new TxArray(...responseTxs), responseBitVector);
+    const response = new BlockTxsResponse(request.archiveRoot, new TxArray(...responseTxs), responseBitVector);
 
     return response.toBuffer();
   };

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

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { TxArray } from '@aztec/stdlib/tx';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import { BitVector } from './bitvector.js';
 
@@ -9,12 +10,52 @@ import { BitVector } from './bitvector.js';
  */
 export class BlockTxsRequest {
   constructor(
-    readonly blockHash: Fr, // 32 byte hash of the proposed block header
+    // Archive root after the proposed block is applied (proposal identifier)
+    readonly archiveRoot: Fr,
+    // Hashes of txs we are requesting
+    readonly txHashes: TxHashArray,
     // BitVector indicating which txs from the proposal we are requesting
     // 1 means we want the tx, 0 means we don't
+    // If we know peer has the Block Proposal then we can use this BitVector
+    // Otherwise we can use this optimization
     readonly txIndices: BitVector,
   ) {}
 
+  /**
+   * Creates new BlockTxsRequest given proposal and missing tx hashes
+   *
+   * @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 BlockProposal hashes, otherwise
+   * returns new BlockTxsRequest*/
+  static fromBlockProposalAndMissingTxs(
+    blockProposal: BlockProposal,
+    missingTxHashes: TxHash[],
+    includeFullTxHashes = false,
+  ): BlockTxsRequest | undefined {
+    if (missingTxHashes.length === 0) {
+      return undefined; // No missing txs to request
+    }
+
+    const missingHashesSet = new Set(missingTxHashes.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 = blockProposal.txHashes
+      .map((hash, idx) => (missingHashesSet.has(hash.toString()) ? idx : -1))
+      .filter(i => i != -1);
+
+    const requestBitVector = BitVector.init(blockProposal.txHashes.length, missingIndices);
+    const hashes = includeFullTxHashes ? new TxHashArray(...missingTxHashes) : new TxHashArray();
+
+    return new BlockTxsRequest(blockProposal.archive, hashes, requestBitVector);
+  }
+
   /**
    * Deserializes the BlockTxRequest object from a Buffer
    * @param buffer - Buffer or BufferReader object to deserialize
@@ -22,10 +63,11 @@ export class BlockTxsRequest {
    */
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsRequest {
     const reader = BufferReader.asReader(buffer);
-    const blockHash = Fr.fromBuffer(reader);
+    const archiveRoot = Fr.fromBuffer(reader);
+    const txHashes = TxHashArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
 
-    return new BlockTxsRequest(blockHash, txIndices);
+    return new BlockTxsRequest(archiveRoot, txHashes, txIndices);
   }
 
   /**
@@ -33,7 +75,7 @@ export class BlockTxsRequest {
    * @returns Buffer representation of the BlockTxRequest object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockHash, this.txIndices.toBuffer()]);
+    return serializeToBuffer([this.archiveRoot, this.txHashes.toBuffer(), this.txIndices.toBuffer()]);
   }
 }
 
@@ -42,7 +84,7 @@ export class BlockTxsRequest {
  */
 export class BlockTxsResponse {
   constructor(
-    readonly blockHash: Fr,
+    readonly archiveRoot: Fr,
     readonly txs: TxArray, // List of transactions we requested and peer has
     // BitVector indicating which txs from the proposal are available at the peer
     // 1 means the tx is available, 0 means it is not
@@ -56,11 +98,11 @@ export class BlockTxsResponse {
    */
   static fromBuffer(buffer: Buffer | BufferReader): BlockTxsResponse {
     const reader = BufferReader.asReader(buffer);
-    const blockHash = Fr.fromBuffer(reader);
+    const archiveRoot = Fr.fromBuffer(reader);
     const txs = TxArray.fromBuffer(reader);
     const txIndices = BitVector.fromBuffer(reader);
 
-    return new BlockTxsResponse(blockHash, txs, txIndices);
+    return new BlockTxsResponse(archiveRoot, txs, txIndices);
   }
 
   /**
@@ -70,7 +112,7 @@ export class BlockTxsResponse {
    * @returns Buffer representation of the BlockTxResponse object
    */
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockHash, this.txs.toBuffer(), this.txIndices.toBuffer()]);
+    return serializeToBuffer([this.archiveRoot, this.txs.toBuffer(), this.txIndices.toBuffer()]);
   }
 
   static empty(): BlockTxsResponse {

package/src/services/reqresp/reqresp.ts

@@ -111,6 +111,13 @@ export class ReqResp implements ReqRespInterface {
     return this.metrics.tracer;
   }
 
+  /**
+   * Get the connection sampler instance
+   */
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return this.connectionSampler;
+  }
+
   /**
    * Start the reqresp service
    */
@@ -212,6 +219,14 @@ export class ReqResp implements ReqRespInterface {
     const responseValidator = this.subProtocolValidators[subProtocol] ?? DEFAULT_SUB_PROTOCOL_VALIDATORS[subProtocol];
     const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
     const requestBuffers = requests.map(req => req.toBuffer());
+    const isEmptyResponse = (value: unknown): boolean => {
+      // Some responses serialize to a non-empty buffer even when they contain no items (e.g., empty TxArray).
+      if (!value || typeof value !== 'object') {
+        return false;
+      }
+      const length = (value as { length?: number }).length;
+      return typeof length === 'number' && length === 0;
+    };
 
     const requestFunction = async (signal: AbortSignal) => {
       // Track which requests still need to be processed
@@ -252,7 +267,9 @@ export class ReqResp implements ReqRespInterface {
         for (const requestIndex of pendingRequestIndices) {
           const peer = batchSampler.getPeerForRequest(requestIndex);
           if (!peer) {
-            break;
+            // No peer available for this specific index (all peers exhausted for it)
+            // Skip this index for now - it stays in pendingRequestIndices for retry
+            continue;
           }
           const peerAsString = peer.toString();
           if (!requestBatches.has(peerAsString)) {
@@ -271,6 +288,12 @@ export class ReqResp implements ReqRespInterface {
           });
         }
 
+        // If no requests could be assigned (all peers exhausted for all indices), exit early
+        if (requestBatches.size === 0) {
+          this.logger.warn('No peers available for any pending request indices, stopping batch request');
+          break;
+        }
+
         // Make parallel requests for each peer's batch
         // A batch entry will look something like this:
         // PeerId0: [0, 1, 2, 3]
@@ -282,38 +305,61 @@ export class ReqResp implements ReqRespInterface {
         const batchResults = await Promise.all(
           Array.from(requestBatches.entries()).map(async ([peerAsString, { peerId: peer, indices }]) => {
             try {
+              const markIndexFailed = (index: number) => batchSampler.markPeerFailedForIndex(peer, index);
               // Requests all going to the same peer are sent synchronously
               const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
                 [];
+              let shouldReplacePeer = false;
+              const handleFailure = (status: ReqRespStatus, index: number) => {
+                this.logger.warn(
+                  `Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(status)}`,
+                );
+                markIndexFailed(index);
+                return status === ReqRespStatus.RATE_LIMIT_EXCEEDED;
+              };
+
               for (const index of indices) {
-                this.logger.trace(`Sending request ${index} to peer ${peerAsString}`);
+                this.logger.info(`Sending request ${index} to peer ${peerAsString}`);
                 const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
 
                 // Check the status of the response buffer
                 if (response.status !== ReqRespStatus.SUCCESS) {
-                  this.logger.debug(
-                    `Request to peer ${peerAsString} failed with status ${prettyPrintReqRespStatus(response.status)}`,
-                  );
-
-                  // If we hit a rate limit or some failure, we remove the peer and return the results,
-                  // they will be split among remaining peers and the new sampled peer
-                  batchSampler.removePeerAndReplace(peer);
-                  return { peer, results: peerResults };
+                  shouldReplacePeer = handleFailure(response.status, index);
+                  if (shouldReplacePeer) {
+                    break;
+                  }
+                  continue;
                 }
 
-                if (response && response.data.length > 0) {
-                  const object = responseFromBuffer(subProtocol, response.data);
-                  const isValid = await responseValidator(requests[index], object, peer);
+                if (response.data.length === 0) {
+                  markIndexFailed(index);
+                  continue;
+                }
 
-                  if (isValid) {
-                    peerResults.push({ index, response: object });
-                  }
+                const object = responseFromBuffer(subProtocol, response.data);
+                if (isEmptyResponse(object)) {
+                  markIndexFailed(index);
+                  continue;
+                }
+
+                const isValid = await responseValidator(requests[index], object, peer);
+                if (!isValid) {
+                  markIndexFailed(index);
+                  continue;
                 }
+
+                peerResults.push({ index, response: object });
+              }
+
+              // If peer had a hard failure (rate limit), replace it for future iterations
+              if (shouldReplacePeer) {
+                this.logger.warn(`Peer ${peerAsString} hit a hard failure, removing from sampler`);
+                batchSampler.removePeerAndReplace(peer);
               }
 
               return { peer, results: peerResults };
             } catch (error) {
-              this.logger.debug(`Failed batch request to peer ${peerAsString}:`, error);
+              this.logger.warn(`Failed batch request to peer ${peerAsString}:`, error);
               batchSampler.removePeerAndReplace(peer);
               return { peer, results: [] };
             }
@@ -334,7 +380,7 @@ export class ReqResp implements ReqRespInterface {
       }
 
       if (retryAttempts >= maxRetryAttempts) {
-        this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+        this.logger.warn(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
       }
 
       return responses;
@@ -347,7 +393,7 @@ export class ReqResp implements ReqRespInterface {
         () => new CollectiveReqRespTimeoutError(),
       );
     } catch (e: any) {
-      this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+      this.logger.warn(`${e.message} | subProtocol: ${subProtocol}`);
       return [];
     }
   }
@@ -409,6 +455,7 @@ export class ReqResp implements ReqRespInterface {
       );
       return resp;
     } catch (e: any) {
+      this.logger.warn(`SUBPROTOCOL: ${subProtocol}\n`, e);
       // On error we immediately abort the stream, this is preferred way,
       // because it signals to the sender that error happened, whereas
       // closing the stream only closes our side and is much slower

package/src/services/service.ts

@@ -7,6 +7,7 @@ import type { PeerId } from '@libp2p/interface';
 import type { ENR } from '@nethermindeth/enr';
 import type EventEmitter from 'events';
 
+import type { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from './reqresp/config.js';
 import type { StatusMessage } from './reqresp/index.js';
 import type {
@@ -103,6 +104,9 @@ export interface P2PService {
 
   /** If node running this P2P stack is validator, passes in validator address to P2P layer */
   registerThisValidatorAddresses(address: EthAddress[]): void;
+
+  /** Get BatchTxRequester service dependencies */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService;
 }
 
 /**

package/src/services/tx_collection/config.ts

@@ -1,6 +1,13 @@
-import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  enumConfigHelper,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
 import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
+export type ProposalTxCollectorType = 'new' | 'old';
+
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */
   txCollectionFastNodesTimeoutBeforeReqRespMs: number;
@@ -22,6 +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 proposal tx collection */
+  txCollectionProposalTxCollectorType: ProposalTxCollectorType;
 };
 
 export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
@@ -81,4 +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),
   },
+  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

@@ -12,9 +12,16 @@ import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 
-import { type ReqRespInterface, ReqRespSubProtocol } from '../reqresp/interface.js';
+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 ProposalTxCollector,
+  SendBatchRequestCollector,
+} from './proposal_tx_collector.js';
 import type { FastCollectionRequest, FastCollectionRequestInput } from './tx_collection.js';
 import type { TxCollectionSink } from './tx_collection_sink.js';
 import type { TxSource } from './tx_source.js';
@@ -22,15 +29,25 @@ 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 proposalTxCollector: ProposalTxCollector;
 
   constructor(
-    private reqResp: Pick<ReqRespInterface, 'sendBatchRequest'>,
+    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'),
-  ) {}
+    proposalTxCollector?: ProposalTxCollector,
+  ) {
+    const batchTxRequesterConfig = this.config as Partial<BatchTxRequesterConfig>;
+    const proposalCollectorType = this.config.txCollectionProposalTxCollectorType;
+    this.proposalTxCollector =
+      proposalTxCollector ??
+      (proposalCollectorType === 'old'
+        ? new SendBatchRequestCollector(p2pService)
+        : new BatchTxRequesterCollector(p2pService, log, dateProvider, undefined, batchTxRequesterConfig));
+  }
 
   public async stop() {
     this.requests.forEach(request => request.promise.reject(new AbortError(`Stopped collection service`)));
@@ -261,16 +278,22 @@ export class FastTxCollection {
     try {
       await this.txCollectionSink.collect(
         async txHashes => {
-          const txs = await this.reqResp.sendBatchRequest<ReqRespSubProtocol.TX>(
-            ReqRespSubProtocol.TX,
-            chunkTxHashesRequest(txHashes),
-            pinnedPeer,
-            timeoutMs,
-            maxPeers,
-            maxRetryAttempts,
-          );
-
-          return txs.flat();
+          if (request.type === 'proposal') {
+            return await this.proposalTxCollector.collectTxs(txHashes, request.blockProposal, pinnedPeer, timeoutMs);
+          } else if (request.type === 'block') {
+            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}`);
+          }
         },
         Array.from(request.missingTxHashes).map(txHash => TxHash.fromString(txHash)),
         { description: `reqresp for slot ${slotNumber}`, method: 'fast-req-resp', ...opts, ...request.blockInfo },

package/src/services/tx_collection/index.ts

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

package/src/services/tx_collection/instrumentation.ts

@@ -1,4 +1,11 @@
-import { Attributes, type Histogram, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  createUpDownCounterWithDefault,
+} from '@aztec/telemetry-client';
 
 import type { CollectionMethod } from './tx_collection.js';
 
@@ -10,7 +17,9 @@ export class TxCollectionInstrumentation {
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.txsCollected = meter.createUpDownCounter(Metrics.TX_COLLECTOR_COUNT);
+    this.txsCollected = createUpDownCounterWithDefault(meter, Metrics.TX_COLLECTOR_COUNT, {
+      [Attributes.TX_COLLECTION_METHOD]: ['fast-req-resp', 'fast-node-rpc', 'slow-req-resp', 'slow-node-rpc'],
+    });
 
     this.collectionDurationPerTx = meter.createHistogram(Metrics.TX_COLLECTOR_DURATION_PER_TX);