@aztec/p2p 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/services/peer-manager/metrics.ts

@@ -1,6 +1,7 @@
 import {
   Attributes,
   type Gauge,
+  type Histogram,
   Metrics,
   type TelemetryClient,
   type Tracer,
@@ -9,12 +10,18 @@ import {
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
+import type { PeerId } from '@libp2p/interface';
+
 import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
   private receivedGoodbyes: UpDownCounter;
   private peerCount: Gauge;
+  private lowScoreDisconnects: UpDownCounter;
+  private peerConnectionDuration: Histogram;
+
+  private peerConnectedAt: Map<string, number> = new Map<string, number>();
 
   public readonly tracer: Tracer;
 
@@ -40,6 +47,16 @@ export class PeerManagerMetrics {
       unit: 'peers',
       valueType: ValueType.INT,
     });
+    this.lowScoreDisconnects = meter.createUpDownCounter(Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS, {
+      description: 'Number of peers disconnected due to low score',
+      unit: 'peers',
+      valueType: ValueType.INT,
+    });
+    this.peerConnectionDuration = meter.createHistogram(Metrics.PEER_MANAGER_PEER_CONNECTION_DURATION, {
+      description: 'Time duration between peer connection and disconnection',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
   }
 
   public recordGoodbyeSent(reason: GoodByeReason) {
@@ -53,4 +70,19 @@ export class PeerManagerMetrics {
   public recordPeerCount(count: number) {
     this.peerCount.record(count);
   }
+
+  public recordLowScoreDisconnect(scoreState: 'Banned' | 'Disconnect') {
+    this.lowScoreDisconnects.add(1, { [Attributes.P2P_PEER_SCORE_STATE]: scoreState });
+  }
+
+  public peerConnected(id: PeerId) {
+    this.peerConnectedAt.set(id.toString(), Date.now());
+  }
+
+  public peerDisconnected(id: PeerId) {
+    const connectedAt = this.peerConnectedAt.get(id.toString());
+    if (connectedAt) {
+      this.peerConnectionDuration.record(Date.now() - connectedAt);
+    }
+  }
 }

package/src/services/peer-manager/peer_manager.ts

@@ -1,7 +1,7 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { makeEthSignDigest, recoverAddress } from '@aztec/foundation/crypto';
+import { makeEthSignDigest, tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider } from '@aztec/foundation/timer';
@@ -9,10 +9,10 @@ import type { PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/
 import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import { ENR } from '@chainsafe/enr';
 import type { Connection, PeerId } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 import type { Multiaddr } from '@multiformats/multiaddr';
+import { ENR } from '@nethermindeth/enr';
 import { inspect } from 'util';
 
 import type { P2PConfig } from '../../config.js';
@@ -278,6 +278,7 @@ export class PeerManager implements PeerManagerInterface {
   private handleConnectedPeerEvent(e: CustomEvent<PeerId>) {
     const peerId = e.detail;
     this.logger.verbose(`Connected to peer ${peerId.toString()}`);
+    this.metrics.peerConnected(peerId);
     if (this.config.p2pDisableStatusHandshake) {
       return;
     }
@@ -303,6 +304,7 @@ export class PeerManager implements PeerManagerInterface {
    */
   private handleDisconnectedPeerEvent(e: CustomEvent<PeerId>) {
     const peerId = e.detail;
+    this.metrics.peerDisconnected(peerId);
     this.logger.verbose(`Disconnected from peer ${peerId.toString()}`);
     const validatorAddress = this.authenticatedPeerIdToValidatorAddress.get(peerId.toString());
     if (validatorAddress !== undefined) {
@@ -577,9 +579,11 @@ export class PeerManager implements PeerManagerInterface {
       const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
       switch (score) {
         case PeerScoreState.Banned:
+          this.metrics.recordLowScoreDisconnect('Banned');
           void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.BANNED);
           break;
         case PeerScoreState.Disconnect:
+          this.metrics.recordLowScoreDisconnect('Disconnect');
           void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.LOW_SCORE);
           break;
         case PeerScoreState.Healthy:
@@ -883,7 +887,7 @@ export class PeerManager implements PeerManagerInterface {
       const response = await this.reqresp.sendRequestToPeer(peerId, ReqRespSubProtocol.AUTH, authRequest.toBuffer());
       const { status } = response;
       if (status !== ReqRespStatus.SUCCESS) {
-        this.logger.debug(`Disconnecting peer ${peerId} who failed to respond auth handshake`, {
+        this.logger.verbose(`Disconnecting peer ${peerId} who failed to respond auth handshake`, {
           peerId,
           status: ReqRespStatus[status],
         });
@@ -899,7 +903,7 @@ export class PeerManager implements PeerManagerInterface {
 
       const peerStatusMessage = peerAuthResponse.status;
       if (!ourStatus.validate(peerStatusMessage)) {
-        this.logger.debug(`Disconnecting peer ${peerId} due to failed status handshake as part of auth.`, logData);
+        this.logger.verbose(`Disconnecting peer ${peerId} due to failed status handshake as part of auth.`, logData);
         this.markAuthHandshakeFailed(peerId);
         this.markPeerForDisconnect(peerId);
         return;
@@ -907,16 +911,20 @@ export class PeerManager implements PeerManagerInterface {
 
       const hashToRecover = authRequest.getPayloadToSign();
       const ethSignedHash = makeEthSignDigest(hashToRecover);
-      const sender = recoverAddress(ethSignedHash, peerAuthResponse.signature);
+      const sender = tryRecoverAddress(ethSignedHash, peerAuthResponse.signature);
+      if (!sender) {
+        this.logger.verbose(`Disconnecting peer ${peerId} due to failed auth handshake, invalid signature.`, logData);
+        this.markAuthHandshakeFailed(peerId);
+        this.markPeerForDisconnect(peerId);
+        return;
+      }
+
       const registeredValidators = await this.epochCache.getRegisteredValidators();
       const found = registeredValidators.find(v => v.toString() === sender.toString()) !== undefined;
       if (!found) {
-        this.logger.debug(
+        this.logger.verbose(
           `Disconnecting peer ${peerId} due to failed auth handshake, peer is not a registered validator.`,
-          {
-            peerId,
-            address: sender.toString(),
-          },
+          { ...logData, address: sender.toString() },
         );
         this.markAuthHandshakeFailed(peerId);
         this.markPeerForDisconnect(peerId);
@@ -926,8 +934,9 @@ export class PeerManager implements PeerManagerInterface {
       // Check to see that this validator address isn't already allocated to a different peer
       const peerForAddress = this.authenticatedValidatorAddressToPeerId.get(sender.toString());
       if (peerForAddress !== undefined && peerForAddress.toString() !== peerIdString) {
-        this.logger.debug(
+        this.logger.verbose(
           `Received auth for validator ${sender.toString()} from peer ${peerIdString}, but this validator is already authenticated to peer ${peerForAddress.toString()}`,
+          { ...logData, address: sender.toString() },
         );
         return;
       }
@@ -937,12 +946,13 @@ export class PeerManager implements PeerManagerInterface {
       this.authenticatedValidatorAddressToPeerId.set(sender.toString(), peerId);
       this.logger.info(
         `Successfully completed auth handshake with peer ${peerId}, validator address ${sender.toString()}`,
-        logData,
+        { ...logData, address: sender.toString() },
       );
     } catch (err: any) {
       //TODO: maybe hard ban these peers in the future
-      this.logger.debug(`Disconnecting peer ${peerId} due to error during auth handshake: ${err.message ?? err}`, {
+      this.logger.verbose(`Disconnecting peer ${peerId} due to error during auth handshake: ${err.message}`, {
         peerId,
+        err,
       });
       this.markAuthHandshakeFailed(peerId);
       this.markPeerForDisconnect(peerId);

package/src/services/peer-manager/peer_scoring.ts

@@ -1,6 +1,14 @@
 import { median } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+  getTelemetryClient,
+} from '@aztec/telemetry-client';
 
 import type { PeerId } from '@libp2p/interface';
 
@@ -30,7 +38,9 @@ export class PeerScoring {
   private decayFactor = 0.9;
   peerPenalties: { [key in PeerErrorSeverity]: number };
 
-  constructor(config: P2PConfig) {
+  private peerStateCounter: UpDownCounter;
+
+  constructor(config: P2PConfig, telemetry: TelemetryClient = getTelemetryClient()) {
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
@@ -40,6 +50,13 @@ export class PeerScoring {
       [PeerErrorSeverity.LowToleranceError]:
         orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
     };
+
+    const meter = telemetry.getMeter('PeerScoring');
+
+    this.peerStateCounter = meter.createUpDownCounter(Metrics.P2P_PEER_STATE_COUNT, {
+      description: 'Count of peers by state (Healthy, Disconnect, Banned)',
+      valueType: ValueType.INT,
+    });
   }
 
   public penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity) {
@@ -99,7 +116,33 @@ export class PeerScoring {
     return PeerScoreState.Healthy;
   }
 
-  getStats(): { medianScore: number } {
-    return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
+  getStats(): { medianScore: number; healthyCount: number; disconnectCount: number; bannedCount: number } {
+    const stateCounts = { healthy: 0, disconnect: 0, banned: 0 };
+
+    for (const peerId of this.scores.keys()) {
+      const state = this.getScoreState(peerId);
+      switch (state) {
+        case PeerScoreState.Healthy:
+          stateCounts.healthy++;
+          break;
+        case PeerScoreState.Disconnect:
+          stateCounts.disconnect++;
+          break;
+        case PeerScoreState.Banned:
+          stateCounts.banned++;
+          break;
+      }
+    }
+
+    this.peerStateCounter.add(stateCounts.healthy, { [Attributes.P2P_PEER_SCORE_STATE]: 'Healthy' });
+    this.peerStateCounter.add(stateCounts.disconnect, { [Attributes.P2P_PEER_SCORE_STATE]: 'Disconnect' });
+    this.peerStateCounter.add(stateCounts.banned, { [Attributes.P2P_PEER_SCORE_STATE]: 'Banned' });
+
+    return {
+      medianScore: median(Array.from(this.scores.values())) ?? 0,
+      healthyCount: stateCounts.healthy,
+      disconnectCount: stateCounts.disconnect,
+      bannedCount: stateCounts.banned,
+    };
   }
 }

package/src/services/reqresp/interface.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { L2Block } from '@aztec/stdlib/block';
 import { TxArray, TxHashArray } from '@aztec/stdlib/tx';
 
@@ -122,27 +122,6 @@ export type SubProtocolMap = {
   >;
 };
 
-/**
- * Default handler for unimplemented sub protocols, this SHOULD be overwritten
- * by the service, but is provided as a fallback
- */
-export const defaultHandler = (_msg: any): Promise<Buffer> => {
-  return Promise.resolve(Buffer.from('unimplemented'));
-};
-
-/**
- * Default sub protocol handlers - this SHOULD be overwritten by the service,
- */
-export const DEFAULT_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
-  [ReqRespSubProtocol.PING]: defaultHandler,
-  [ReqRespSubProtocol.STATUS]: defaultHandler,
-  [ReqRespSubProtocol.TX]: defaultHandler,
-  [ReqRespSubProtocol.GOODBYE]: defaultHandler,
-  [ReqRespSubProtocol.BLOCK]: defaultHandler,
-  [ReqRespSubProtocol.AUTH]: defaultHandler,
-  [ReqRespSubProtocol.BLOCK_TXS]: defaultHandler,
-};
-
 /**
  * The Request Response Pair interface defines the methods that each
  * request response pair must implement

package/src/services/reqresp/protocols/auth.ts

@@ -1,7 +1,7 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { Signature } from '@aztec/foundation/eth-signature';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { StatusMessage } from './status.js';

package/src/services/reqresp/protocols/block.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 
 import type { PeerId } from '@libp2p/interface';
@@ -27,7 +28,7 @@ export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubPro
     }
 
     try {
-      const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
+      const foundBlock = await l2BlockSource.getBlock(BlockNumber(Number(blockNumber)));
       return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
     } catch (err: any) {
       throw new ReqRespStatusError(ReqRespStatus.INTERNAL_ERROR, { cause: err });

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { TxArray } from '@aztec/stdlib/tx';
 

package/src/services/reqresp/protocols/status.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import type { Logger } from '@aztec/foundation/log';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
@@ -15,9 +16,9 @@ import type { PeerId } from '@libp2p/interface';
 export class StatusMessage {
   constructor(
     readonly compressedComponentsVersion: string,
-    readonly latestBlockNumber: number,
+    readonly latestBlockNumber: BlockNumber,
     readonly latestBlockHash: string,
-    readonly finalizedBlockNumber: number,
+    readonly finalizedBlockNumber: BlockNumber,
     //TODO: add finalizedBlockHash
     //readonly finalizedBlockHash: string,
   ) {}
@@ -31,9 +32,9 @@ export class StatusMessage {
     const reader = BufferReader.asReader(buffer);
     return new StatusMessage(
       reader.readString(), // compressedComponentsVersion
-      reader.readNumber(), // latestBlockNumber
+      BlockNumber(reader.readNumber()), // latestBlockNumber
       reader.readString(), // latestBlockHash
-      reader.readNumber(), // finalizedBlockNumber
+      BlockNumber(reader.readNumber()), // finalizedBlockNumber
       //TODO: add finalizedBlockHash
       //reader.readString(), // finalizedBlockHash
     );
@@ -63,9 +64,9 @@ export class StatusMessage {
   static fromWorldStateSyncStatus(version: string, syncStatus: WorldStateSyncStatus): StatusMessage {
     return new StatusMessage(
       version,
-      syncStatus.latestBlockNumber,
+      BlockNumber(syncStatus.latestBlockNumber),
       syncStatus.latestBlockHash,
-      syncStatus.finalizedBlockNumber,
+      BlockNumber(syncStatus.finalizedBlockNumber),
       //TODO: add finalizedBlockHash
     );
   }
@@ -73,9 +74,9 @@ export class StatusMessage {
   static random(): StatusMessage {
     return new StatusMessage(
       '1.0.0',
-      Math.floor(Math.random() * 100),
+      BlockNumber(Math.floor(Math.random() * 100)),
       Buffer32.random().toString(),
-      Math.floor(Math.random() * 100),
+      BlockNumber(Math.floor(Math.random() * 100)),
       //TODO: add finalizedBlockHash
     );
   }

package/src/services/reqresp/protocols/tx.ts

@@ -1,5 +1,4 @@
 import { chunk } from '@aztec/foundation/collection';
-import type { P2PClientType } from '@aztec/stdlib/p2p';
 import { TxArray, TxHash, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -16,7 +15,7 @@ import { ReqRespStatus, ReqRespStatusError } from '../status.js';
  * @param mempools - the mempools
  * @returns the Tx request handler
  */
-export function reqRespTxHandler<T extends P2PClientType>(mempools: MemPools<T>): ReqRespSubProtocolHandler {
+export function reqRespTxHandler(mempools: MemPools): ReqRespSubProtocolHandler {
   /**
    * Handler for tx requests
    * @param msg - the tx request message

package/src/services/reqresp/reqresp.ts

@@ -26,7 +26,6 @@ import {
 import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
 import { ConnectionSampler, RandomSampler } from './connection-sampler/connection_sampler.js';
 import {
-  DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
   type ReqRespInterface,
   type ReqRespResponse,
@@ -64,9 +63,8 @@ export class ReqResp implements ReqRespInterface {
   private individualRequestTimeoutMs: number = DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS;
   private dialTimeoutMs: number = DEFAULT_REQRESP_DIAL_TIMEOUT_MS;
 
-  // Warning, if the `start` function is not called as the parent class constructor, then the default sub protocol handlers will be used ( not good )
-  private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
-  private subProtocolValidators: ReqRespSubProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
+  private subProtocolHandlers: Partial<ReqRespSubProtocolHandlers> = {};
+  private subProtocolValidators: Partial<ReqRespSubProtocolValidators> = {};
 
   private connectionSampler: ConnectionSampler;
   private rateLimiter: RequestResponseRateLimiter;
@@ -117,11 +115,12 @@ export class ReqResp implements ReqRespInterface {
    * Start the reqresp service
    */
   async start(subProtocolHandlers: ReqRespSubProtocolHandlers, subProtocolValidators: ReqRespSubProtocolValidators) {
-    this.subProtocolHandlers = subProtocolHandlers;
-    this.subProtocolValidators = subProtocolValidators;
+    Object.assign(this.subProtocolHandlers, subProtocolHandlers);
+    Object.assign(this.subProtocolValidators, subProtocolValidators);
 
     // Register all protocol handlers
-    for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
+    for (const subProtocol of Object.keys(subProtocolHandlers)) {
+      this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
       await this.libp2p.handle(
         subProtocol,
         (data: IncomingStreamData) =>
@@ -140,6 +139,7 @@ export class ReqResp implements ReqRespInterface {
   ): Promise<void> {
     this.subProtocolHandlers[subProtocol] = handler;
     this.subProtocolValidators[subProtocol] = validator;
+    this.logger.debug(`Registering handler for sub protocol ${subProtocol}`);
     await this.libp2p.handle(
       subProtocol,
       (data: IncomingStreamData) =>
@@ -209,7 +209,7 @@ export class ReqResp implements ReqRespInterface {
     maxPeers = Math.max(10, Math.ceil(requests.length / 3)),
     maxRetryAttempts = 3,
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    const responseValidator = this.subProtocolValidators[subProtocol];
+    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());
 
@@ -489,7 +489,7 @@ export class ReqResp implements ReqRespInterface {
       }
 
       const messageData = Buffer.concat(chunks);
-      const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
+      const message: Buffer = this.snappyTransform.inboundTransformData(messageData);
 
       return {
         status: status ?? ReqRespStatus.UNKNOWN,
@@ -594,7 +594,11 @@ export class ReqResp implements ReqRespInterface {
    *
    * */
   private async processStream(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData): Promise<void> {
-    const handler = this.subProtocolHandlers[protocol]!;
+    const handler = this.subProtocolHandlers[protocol];
+    if (!handler) {
+      throw new Error(`No handler defined for reqresp subprotocol ${protocol}`);
+    }
+
     const snappy = this.snappyTransform;
     const SUCCESS = Uint8Array.of(ReqRespStatus.SUCCESS);
 
@@ -614,7 +618,7 @@ export class ReqResp implements ReqRespInterface {
           stream.metadata.written = true; // Mark the stream as written to;
 
           yield SUCCESS;
-          yield snappy.outboundTransformNoTopic(response);
+          yield snappy.outboundTransformData(response);
         }
       },
       stream.sink,

package/src/services/service.ts

@@ -3,8 +3,8 @@ import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
 import type { Tx } from '@aztec/stdlib/tx';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 import type EventEmitter from 'events';
 
 import type { P2PReqRespConfig } from './reqresp/config.js';

package/src/services/tx_collection/config.ts

@@ -1,5 +1,5 @@
 import { type ConfigMappingsType, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
-import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/server';
+import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
 
 export type TxCollectionConfig = {
   /** How long to wait before starting reqresp for fast collection  */

package/src/services/tx_collection/fast_tx_collection.ts

@@ -1,3 +1,4 @@
+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';
@@ -5,7 +6,7 @@ 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';
-import type { BlockInfo } from '@aztec/stdlib/block';
+import type { L2BlockInfo } from '@aztec/stdlib/block';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -54,8 +55,10 @@ export class FastTxCollection {
       return [];
     }
 
-    const blockInfo: BlockInfo =
-      input.type === 'proposal' ? input.blockProposal.toBlockInfo() : input.block.toBlockInfo();
+    const blockInfo: L2BlockInfo =
+      input.type === 'proposal'
+        ? { ...input.blockProposal.toBlockInfo(), blockNumber: input.blockNumber }
+        : { ...input.block.toBlockInfo() };
 
     // This promise is used to await for the collection to finish during the main collectFast method.
     // It gets resolved in `foundTxs` when all txs have been collected, or rejected if the request is aborted or hits the deadline.
@@ -314,7 +317,7 @@ export class FastTxCollection {
    * Stop collecting all txs for blocks less than or requal to the block number specified.
    * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
    */
-  public stopCollectingForBlocksUpTo(blockNumber: number): void {
+  public stopCollectingForBlocksUpTo(blockNumber: BlockNumber): void {
     for (const request of this.requests) {
       if (request.blockInfo.blockNumber <= blockNumber) {
         request.promise.reject(new AbortError(`Stopped collecting txs up to block ${blockNumber}`));
@@ -327,7 +330,7 @@ export class FastTxCollection {
    * Stop collecting all txs for blocks greater than the block number specified.
    * To be called when there is a chain prune and previously mined txs are no longer relevant.
    */
-  public stopCollectingForBlocksAfter(blockNumber: number): void {
+  public stopCollectingForBlocksAfter(blockNumber: BlockNumber): void {
     for (const request of this.requests) {
       if (request.blockInfo.blockNumber > blockNumber) {
         request.promise.reject(new AbortError(`Stopped collecting txs after block ${blockNumber}`));

package/src/services/tx_collection/slow_tx_collection.ts

@@ -1,9 +1,10 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { chunk } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { boundInclusive } from '@aztec/foundation/number';
 import { RunningPromise } from '@aztec/foundation/promise';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -75,7 +76,7 @@ export class SlowTxCollection {
   }
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
-  public startCollecting(block: L2Block, txHashes: TxHash[]) {
+  public startCollecting(block: L2BlockNew, txHashes: TxHash[]) {
     const slot = block.header.getSlot();
     const deadline = this.getDeadlineForSlot(slot);
     if (+deadline < this.dateProvider.now()) {
@@ -202,7 +203,7 @@ export class SlowTxCollection {
    * Stop collecting all txs for blocks less than or requal to the block number specified.
    * To be called when we no longer care about gathering txs up to a certain block, eg when they become proven or finalized.
    */
-  public stopCollectingForBlocksUpTo(blockNumber: number): void {
+  public stopCollectingForBlocksUpTo(blockNumber: BlockNumber): void {
     for (const [txHash, info] of this.missingTxs.entries()) {
       if (info.blockNumber <= blockNumber) {
         this.missingTxs.delete(txHash);
@@ -214,7 +215,7 @@ export class SlowTxCollection {
    * Stop collecting all txs for blocks greater than the block number specified.
    * To be called when there is a chain prune and previously mined txs are no longer relevant.
    */
-  public stopCollectingForBlocksAfter(blockNumber: number): void {
+  public stopCollectingForBlocksAfter(blockNumber: BlockNumber): void {
     for (const [txHash, info] of this.missingTxs.entries()) {
       if (info.blockNumber > blockNumber) {
         this.missingTxs.delete(txHash);
@@ -223,9 +224,9 @@ export class SlowTxCollection {
   }
 
   /** Computes the proof submission deadline for a given slot, a tx mined in this slot is no longer interesting after this deadline */
-  private getDeadlineForSlot(slotNumber: bigint): Date {
+  private getDeadlineForSlot(slotNumber: SlotNumber): Date {
     const epoch = getEpochAtSlot(slotNumber, this.constants);
-    const submissionEndEpoch = epoch + BigInt(this.constants.proofSubmissionEpochs);
+    const submissionEndEpoch = EpochNumber(epoch + this.constants.proofSubmissionEpochs);
     const submissionEndTimestamp = getTimestampRangeForEpoch(submissionEndEpoch, this.constants)[1];
     return new Date(Number(submissionEndTimestamp) * 1000);
   }