@aztec/p2p 0.0.1-commit.9b94fc1 → 0.0.1-commit.c7c42ec

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
@@ -13,7 +14,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
   const minedBlockHeader = BlockHeader.empty({
-    globalVariables: GlobalVariables.empty({ blockNumber: 1, timestamp: 0n }),
+    globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(1), timestamp: 0n }),
   });
 
   beforeEach(() => {
@@ -25,7 +26,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
   });
 
   it('adds txs to the pool as pending', async () => {
-    const tx1 = await mockTx();
+    const tx1 = await mockTx(1);
 
     await pool.addTxs([tx1]);
     const poolTx = await pool.getTxByHash(tx1.getTxHash());
@@ -36,9 +37,9 @@ export function describeTxPool(getTxPool: () => TxPool) {
   });
 
   it('emits txs-added event with new txs', async () => {
-    const tx1 = await mockTx(); // existing and pending
-    const tx2 = await mockTx(); // mined but not known
-    const tx3 = await mockTx(); // brand new
+    const tx1 = await mockTx(1); // existing and pending
+    const tx2 = await mockTx(2); // mined but not known
+    const tx3 = await mockTx(3); // brand new
 
     await pool.addTxs([tx1]);
     await pool.markAsMined([tx2.getTxHash()], minedBlockHeader);
@@ -51,10 +52,11 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
     expect(txsFromEvent).toBeDefined();
     expect(txsFromEvent).toHaveLength(2);
-    expect(txsFromEvent).toEqual(expect.arrayContaining([tx2, tx3]));
+    const eventHashes = txsFromEvent!.map(tx => tx.getTxHash());
+    expect(eventHashes).toEqual(expect.arrayContaining([tx2.getTxHash(), tx3.getTxHash()]));
   });
 
-  it('permanently deletes pending txs and soft-deletes mined txs', async () => {
+  it('removes txs from the pool', async () => {
     const pendingTx = await mockTx(1);
     const minedTx = await mockTx(2);
 
@@ -82,7 +84,8 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2]);
     await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await expect(pool.getTxByHash(tx1.getTxHash())).resolves.toEqual(tx1);
+    const retrievedTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(retrievedTx?.getTxHash()).toEqual(tx1.getTxHash());
     await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
     await expect(pool.getMinedTxHashes()).resolves.toEqual([[tx1.getTxHash(), 1]]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([tx2.getTxHash()]);
@@ -96,7 +99,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2]);
     await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await pool.markMinedAsPending([tx1.getTxHash()]);
+    await pool.markMinedAsPending([tx1.getTxHash()], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
@@ -120,7 +123,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await pool.markMinedAsPending([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], BlockNumber(1));
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]); // tx2 is not in the pool
     await expect(pool.getPendingTxCount()).resolves.toEqual(1);
@@ -135,7 +138,8 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
-    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+    const poolHashes = poolTxs.map(tx => tx.getTxHash());
+    expect(poolHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
     await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
@@ -162,17 +166,19 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const requestedTxs = await pool.getTxsByHash([tx1.getTxHash(), tx3.getTxHash()]);
     expect(requestedTxs).toHaveLength(2);
-    expect(requestedTxs).toEqual(expect.arrayContaining([tx1, tx3]));
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx3.getTxHash()]));
   });
 
   it('returns a large number of transactions by their hash', async () => {
-    const numTxs = 1000;
+    const numTxs = 1_000;
     const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
     const hashes = txs.map(tx => tx.getTxHash());
     await pool.addTxs(txs);
     const requestedTxs = await pool.getTxsByHash(hashes);
     expect(requestedTxs).toHaveLength(numTxs);
-    expect(requestedTxs).toEqual(expect.arrayContaining(txs));
+    const requestedHashes = requestedTxs.map(tx => tx!.getTxHash());
+    expect(requestedHashes).toEqual(expect.arrayContaining(hashes));
   });
 
   it('returns whether or not txs exist', async () => {
@@ -261,7 +267,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
 
       // Clean up deleted mined txs from block 1 and earlier
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify old transactions are permanently deleted
       expect(deletedCount).toBe(2);
@@ -276,7 +282,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
       // Mark as mined in block 2
       const laterBlockHeader = BlockHeader.empty({
-        globalVariables: GlobalVariables.empty({ blockNumber: 2, timestamp: 0n }),
+        globalVariables: GlobalVariables.empty({ blockNumber: BlockNumber(2), timestamp: 0n }),
       });
       await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
 
@@ -284,7 +290,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
       await pool.deleteTxs([txs[0].getTxHash()]);
 
       // Try to clean up with block 1 (before the mined block)
-      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+      const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
 
       // Verify no transactions were cleaned up
       expect(deletedCount).toBe(0);

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,5 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,5 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { NoCommitteeError } from '@aztec/ethereum';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 

package/src/msg_validators/tx_validator/archive_cache.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { ArchiveSource } from '@aztec/p2p';
 import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 

package/src/msg_validators/tx_validator/factory.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 { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
@@ -33,7 +34,7 @@ export interface MessageValidator {
 
 export function createTxMessageValidators(
   timestamp: UInt64,
-  blockNumber: number,
+  blockNumber: BlockNumber,
   worldStateSynchronizer: WorldStateSynchronizer,
   gasFees: GasFees,
   l1ChainId: number,

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,

package/src/msg_validators/tx_validator/test_utils.ts

@@ -1,4 +1,4 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { FunctionSelector } from '@aztec/stdlib/abi';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { HashedValues, type Tx } from '@aztec/stdlib/tx';

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import {
   type AnyTx,
@@ -17,7 +18,7 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // being built.
       timestamp: UInt64;
       // Block number in which the tx is considered to be included.
-      blockNumber: number;
+      blockNumber: BlockNumber;
     },
   ) {}
 

package/src/services/encoding.ts

@@ -1,5 +1,5 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
 import { TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 

package/src/services/libp2p/libp2p_service.ts

@@ -1,7 +1,7 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { randomInt } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { Timer } from '@aztec/foundation/timer';
@@ -131,7 +131,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private protocolVersion = '';
   private topicStrings: Record<TopicType, string> = {} as Record<TopicType, string>;
 
-  private feesCache: { blockNumber: number; gasFees: GasFees } | undefined;
+  private feesCache: { blockNumber: BlockNumber; gasFees: GasFees } | undefined;
 
   /**
    * Callback for when a block is received from a peer.
@@ -153,7 +153,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     private peerDiscoveryService: PeerDiscoveryService,
     private reqresp: ReqRespInterface,
     private peerManager: PeerManagerInterface,
-    protected mempools: MemPools<T>,
+    protected mempools: MemPools,
     private archiver: L2BlockSource & ContractDataSource,
     private epochCache: EpochCacheInterface,
     private proofVerifier: ClientProtocolCircuitVerifier,
@@ -185,7 +185,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
     // Use FishermanAttestationValidator in fisherman mode to validate attestation payloads against proposals
     this.attestationValidator = config.fishermanMode
-      ? new FishermanAttestationValidator(epochCache, mempools.attestationPool!, telemetry)
+      ? new FishermanAttestationValidator(epochCache, mempools.attestationPool, telemetry)
       : new AttestationValidator(epochCache);
     this.blockProposalValidator = new BlockProposalValidator(epochCache, { txsPermitted: !config.disableTransactions });
 
@@ -215,7 +215,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     config: P2PConfig,
     peerId: PeerId,
     deps: {
-      mempools: MemPools<T>;
+      mempools: MemPools;
       l2BlockSource: L2BlockSource & ContractDataSource;
       epochCache: EpochCacheInterface;
       proofVerifier: ClientProtocolCircuitVerifier;
@@ -486,8 +486,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       [ReqRespSubProtocol.BLOCK]: blockHandler.bind(this),
     };
 
-    // Only handle block transactions request if attestation pool is available to the client
-    if (this.mempools.attestationPool && !this.config.disableTransactions) {
+    if (!this.config.disableTransactions) {
       const blockTxsHandler = reqRespBlockTxsHandler(this.mempools.attestationPool, this.mempools.txPool);
       requestResponseHandlers[ReqRespSubProtocol.BLOCK_TXS] = blockTxsHandler.bind(this);
     }
@@ -809,7 +808,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private async processAttestationFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
     const validationFunc: () => Promise<ReceivedMessageValidationResult<BlockAttestation>> = async () => {
       const attestation = BlockAttestation.fromBuffer(payloadData);
-      const pool = this.mempools.attestationPool!;
+      const pool = this.mempools.attestationPool;
       const isValid = await this.validateAttestation(source, attestation);
       const exists = isValid && (await pool.hasAttestation(attestation));
 
@@ -866,7 +865,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       },
     );
 
-    await this.mempools.attestationPool!.addAttestations([attestation]);
+    await this.mempools.attestationPool.addAttestations([attestation]);
   }
 
   private async processBlockFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
@@ -875,10 +874,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       const isValid = await this.validateBlockProposal(source, block);
       const pool = this.mempools.attestationPool;
 
-      // Note that we dont have an attestation pool if we're a prover node, but we still
-      // subscribe to block proposal topics in order to prevent their txs from being cleared.
-      const exists = isValid && (await pool?.hasBlockProposal(block));
-      const canAdd = isValid && (await pool?.canAddProposal(block));
+      const exists = isValid && (await pool.hasBlockProposal(block));
+      const canAdd = isValid && (await pool.canAddProposal(block));
 
       this.logger.trace(`Validate propagated block proposal`, {
         isValid,
@@ -934,14 +931,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       archive: block.archive.toString(),
       source: sender.toString(),
     });
-    const attestationsForPreviousSlot = await this.mempools.attestationPool?.getAttestationsForSlot(previousSlot);
-    if (attestationsForPreviousSlot !== undefined) {
-      this.logger.verbose(`Received ${attestationsForPreviousSlot.length} attestations for slot ${previousSlot}`);
-    }
+    const attestationsForPreviousSlot = await this.mempools.attestationPool.getAttestationsForSlot(previousSlot);
+    this.logger.verbose(`Received ${attestationsForPreviousSlot.length} attestations for slot ${previousSlot}`);
 
     // Attempt to add proposal, then mark the txs in this proposal as non-evictable
     try {
-      await this.mempools.attestationPool?.addBlockProposal(block);
+      await this.mempools.attestationPool.addBlockProposal(block);
     } catch (err: unknown) {
       // Drop proposals if we hit per-slot cap in the attestation pool; rethrow unknown errors
       if (err instanceof ProposalSlotCapExceededError) {
@@ -1047,7 +1042,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       }
 
       // Given proposal (should have locally), ensure returned txs are valid subset and match request indices
-      const proposal = await this.mempools.attestationPool?.getBlockProposal(request.blockHash.toString());
+      const proposal = await this.mempools.attestationPool.getBlockProposal(request.blockHash.toString());
       if (proposal) {
         // Build intersected indices
         const intersectIdx = request.txIndices.getTrueIndices().filter(i => response.txIndices.isSet(i));
@@ -1148,7 +1143,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         return false;
       }
 
-      const local = await this.archiver.getBlock(reqNum);
+      const local = await this.archiver.getBlock(BlockNumber(reqNum));
       if (!local) {
         // We are missing the local block; we cannot verify the hash yet. Reject without penalizing.
         // TODO: Consider extending this validator to accept an expected hash or
@@ -1223,7 +1218,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
       // Double spend validator has a special case handler
       if (name === 'doubleSpendValidator') {
-        const txBlockNumber = currentBlockNumber + 1; // tx is expected to be in the next block
+        const txBlockNumber = BlockNumber(currentBlockNumber + 1); // tx is expected to be in the next block
         severity = await this.handleDoubleSpendFailure(tx, txBlockNumber);
       }
 
@@ -1233,7 +1228,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     return true;
   }
 
-  private async getGasFees(blockNumber: number): Promise<GasFees> {
+  private async getGasFees(blockNumber: BlockNumber): Promise<GasFees> {
     if (blockNumber === this.feesCache?.blockNumber) {
       return this.feesCache.gasFees;
     }
@@ -1274,13 +1269,13 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @returns The message validators.
    */
   private async createMessageValidators(
-    currentBlockNumber: number,
+    currentBlockNumber: BlockNumber,
     nextSlotTimestamp: UInt64,
   ): Promise<Record<string, MessageValidator>[]> {
     const gasFees = await this.getGasFees(currentBlockNumber);
     const allowedInSetup = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
 
-    const blockNumberInWhichTheTxIsConsideredToBeIncluded = currentBlockNumber + 1;
+    const blockNumberInWhichTheTxIsConsideredToBeIncluded = BlockNumber(currentBlockNumber + 1);
 
     return createTxMessageValidators(
       nextSlotTimestamp,
@@ -1342,7 +1337,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
    * @param peerId - The peer ID of the peer that sent the tx.
    * @returns Severity
    */
-  private async handleDoubleSpendFailure(tx: Tx, blockNumber: number): Promise<PeerErrorSeverity> {
+  private async handleDoubleSpendFailure(tx: Tx, blockNumber: BlockNumber): Promise<PeerErrorSeverity> {
     if (blockNumber <= this.config.doubleSpendSeverePeerPenaltyWindow) {
       return PeerErrorSeverity.HighToleranceError;
     }
@@ -1350,7 +1345,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const snapshotValidator = new DoubleSpendTxValidator({
       nullifiersExist: async (nullifiers: Buffer[]) => {
         const merkleTree = this.worldStateSynchronizer.getSnapshot(
-          blockNumber - this.config.doubleSpendSeverePeerPenaltyWindow,
+          BlockNumber(blockNumber - this.config.doubleSpendSeverePeerPenaltyWindow),
         );
         const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
         return indices.map(index => index !== undefined);

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

@@ -1,6 +1,7 @@
 import {
   Attributes,
   type Gauge,
+  type Histogram,
   Metrics,
   type TelemetryClient,
   type Tracer,
@@ -9,6 +10,8 @@ import {
   getTelemetryClient,
 } from '@aztec/telemetry-client';
 
+import type { PeerId } from '@libp2p/interface';
+
 import { type GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/index.js';
 
 export class PeerManagerMetrics {
@@ -16,6 +19,9 @@ export class PeerManagerMetrics {
   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;
 
@@ -46,6 +52,11 @@ export class PeerManagerMetrics {
       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) {
@@ -63,4 +74,15 @@ export class PeerManagerMetrics {
   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, tryRecoverAddress } 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';
@@ -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) {

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';
 

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/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';
@@ -316,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}`));
@@ -329,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}`));