@aztec/p2p 0.71.0 → 0.73.0

package/src/mocks/index.ts

@@ -6,6 +6,7 @@ import {
   type WorldStateSynchronizer,
 } from '@aztec/circuit-types';
 import { type EpochCache } from '@aztec/epoch-cache';
+import { timesParallel } from '@aztec/foundation/collection';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { openTmpStore } from '@aztec/kv-store/lmdb';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -26,17 +27,15 @@ import { type BootnodeConfig, type P2PConfig } from '../config.js';
 import { type MemPools } from '../mem_pools/interface.js';
 import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { LibP2PService } from '../services/libp2p/libp2p_service.js';
-import { type PeerManager } from '../services/peer_manager.js';
+import { type PeerScoring } from '../services/peer-manager/peer_scoring.js';
 import { type P2PReqRespConfig } from '../services/reqresp/config.js';
-import { pingHandler, statusHandler } from '../services/reqresp/handlers.js';
 import {
-  PING_PROTOCOL,
+  ReqRespSubProtocol,
   type ReqRespSubProtocolHandlers,
   type ReqRespSubProtocolValidators,
-  STATUS_PROTOCOL,
-  TX_REQ_PROTOCOL,
   noopValidator,
 } from '../services/reqresp/interface.js';
+import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
 import { type PubSubLibp2p } from '../util.js';
 
@@ -151,25 +150,29 @@ export type ReqRespNode = {
 
 // Mock sub protocol handlers
 export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
-  [PING_PROTOCOL]: pingHandler,
-  [STATUS_PROTOCOL]: statusHandler,
-  [TX_REQ_PROTOCOL]: (_msg: any) => Promise.resolve(Buffer.from('tx')),
+  [ReqRespSubProtocol.PING]: pingHandler,
+  [ReqRespSubProtocol.STATUS]: statusHandler,
+  [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')),
 };
 
 // By default, all requests are valid
 // If you want to test an invalid response, you can override the validator
 export const MOCK_SUB_PROTOCOL_VALIDATORS: ReqRespSubProtocolValidators = {
-  [PING_PROTOCOL]: noopValidator,
-  [STATUS_PROTOCOL]: noopValidator,
-  [TX_REQ_PROTOCOL]: noopValidator,
+  [ReqRespSubProtocol.PING]: noopValidator,
+  [ReqRespSubProtocol.STATUS]: noopValidator,
+  [ReqRespSubProtocol.TX]: noopValidator,
+  [ReqRespSubProtocol.GOODBYE]: noopValidator,
+  [ReqRespSubProtocol.BLOCK]: noopValidator,
 };
 
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export const createNodes = async (peerManager: PeerManager, numberOfNodes: number): Promise<ReqRespNode[]> => {
-  return await Promise.all(Array.from({ length: numberOfNodes }, () => createReqResp(peerManager)));
+export const createNodes = (peerScoring: PeerScoring, numberOfNodes: number): Promise<ReqRespNode[]> => {
+  return timesParallel(numberOfNodes, () => createReqResp(peerScoring));
 };
 
 export const startNodes = async (
@@ -183,22 +186,18 @@ export const startNodes = async (
 };
 
 export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
-  const stopPromises = [];
-  for (const node of nodes) {
-    stopPromises.push(node.req.stop());
-    stopPromises.push(node.p2p.stop());
-  }
+  const stopPromises = nodes.flatMap(node => [node.req.stop(), node.p2p.stop()]);
   await Promise.all(stopPromises);
 };
 
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerManager: PeerManager): Promise<ReqRespNode> => {
+export const createReqResp = async (peerScoring: PeerScoring): Promise<ReqRespNode> => {
   const p2p = await createLibp2pNode();
   const config: P2PReqRespConfig = {
     overallRequestTimeoutMs: 4000,
     individualRequestTimeoutMs: 2000,
   };
-  const req = new ReqResp(config, p2p, peerManager);
+  const req = new ReqResp(config, p2p, peerScoring);
   return {
     p2p,
     req,

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -16,7 +16,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
       return PeerErrorSeverity.HighToleranceError;
     }
 
-    const attester = message.getSender();
+    const attester = await message.getSender();
     if (!(await this.epochCache.isInCommittee(attester))) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -19,7 +19,7 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
     }
 
     // Check that the block proposal is from the current or next proposer
-    const proposer = block.getSender();
+    const proposer = await block.getSender();
     if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -15,9 +15,9 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([tx.data.constants.historicalHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.historicalHeader.hash()]);
     if (index === undefined) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for referencing an unknown block header`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
       return { result: 'invalid', reason: ['Block header not found'] };
     }
     return { result: 'valid' };

package/src/msg_validators/tx_validator/data_validator.ts

@@ -5,10 +5,10 @@ export class DataTxValidator implements TxValidator<Tx> {
   #log = createLogger('p2p:tx_validator:tx_data');
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
-    return Promise.resolve(this.#hasCorrectExecutionRequests(tx));
+    return this.#hasCorrectExecutionRequests(tx);
   }
 
-  #hasCorrectExecutionRequests(tx: Tx): TxValidationResult {
+  async #hasCorrectExecutionRequests(tx: Tx): Promise<TxValidationResult> {
     const callRequests = [
       ...tx.data.getRevertiblePublicCallRequests(),
       ...tx.data.getNonRevertiblePublicCallRequests(),
@@ -21,13 +21,16 @@ export class DataTxValidator implements TxValidator<Tx> {
       );
       return { result: 'invalid', reason: ['Wrong number of execution requests for public calls'] };
     }
-
-    const invalidExecutionRequestIndex = tx.enqueuedPublicFunctionCalls.findIndex(
-      (execRequest, i) => !execRequest.isForCallRequest(callRequests[i]),
-    );
+    const invalidExecutionRequestIndex = (
+      await Promise.all(
+        tx.enqueuedPublicFunctionCalls.map(
+          async (execRequest, i) => !(await execRequest.isForCallRequest(callRequests[i])),
+        ),
+      )
+    ).findIndex(Boolean);
     if (invalidExecutionRequestIndex !== -1) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(
+        `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect execution requests for public call at index ${invalidExecutionRequestIndex}.`,
       );
@@ -37,9 +40,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     const teardownCallRequest = tx.data.getTeardownPublicCallRequest();
     const isInvalidTeardownExecutionRequest =
       (!teardownCallRequest && !tx.publicTeardownFunctionCall.isEmpty()) ||
-      (teardownCallRequest && !tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest));
+      (teardownCallRequest && !(await tx.publicTeardownFunctionCall.isForCallRequest(teardownCallRequest)));
     if (isInvalidTeardownExecutionRequest) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} because of incorrect teardown execution requests.`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} because of incorrect teardown execution requests.`);
       return { result: 'invalid', reason: ['Incorrect teardown execution request'] };
     }
 

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -19,12 +19,12 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers);
     if (uniqueNullifiers.size !== nullifiers.length) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for emitting duplicate nullifiers`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: ['Duplicate nullifier in tx'] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
-      this.#log.warn(`Rejecting tx ${Tx.getHash(tx)} for repeating a nullifier`);
+      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for repeating a nullifier`);
       return { result: 'invalid', reason: ['Existing nullifier'] };
     }
 

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -7,21 +7,21 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
 
   constructor(private chainId: Fr, private blockNumber: Fr) {}
 
-  validateTx(tx: T): Promise<TxValidationResult> {
+  async validateTx(tx: T): Promise<TxValidationResult> {
     const errors = [];
-    if (!this.#hasCorrectChainId(tx)) {
+    if (!(await this.#hasCorrectChainId(tx))) {
       errors.push('Incorrect chain id');
     }
-    if (!this.#isValidForBlockNumber(tx)) {
+    if (!(await this.#isValidForBlockNumber(tx))) {
       errors.push('Invalid block number');
     }
-    return Promise.resolve(errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' });
+    return errors.length > 0 ? { result: 'invalid', reason: errors } : { result: 'valid' };
   }
 
-  #hasCorrectChainId(tx: T): boolean {
+  async #hasCorrectChainId(tx: T): Promise<boolean> {
     if (!tx.data.constants.txContext.chainId.equals(this.chainId)) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(
+        `Rejecting tx ${await Tx.getHash(
           tx,
         )} because of incorrect chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.chainId.toNumber()}`,
       );
@@ -31,12 +31,12 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     }
   }
 
-  #isValidForBlockNumber(tx: T): boolean {
+  async #isValidForBlockNumber(tx: T): Promise<boolean> {
     const maxBlockNumber = tx.data.rollupValidationRequests.maxBlockNumber;
 
     if (maxBlockNumber.isSome && maxBlockNumber.value < this.blockNumber) {
       this.#log.warn(
-        `Rejecting tx ${Tx.getHash(tx)} for low max block number. Tx max block number: ${
+        `Rejecting tx ${await Tx.getHash(tx)} for low max block number. Tx max block number: ${
           maxBlockNumber.value
         }, current block number: ${this.blockNumber}.`,
       );

package/src/services/data_store.ts

@@ -1,5 +1,5 @@
 import { filter, map, sort, take } from '@aztec/foundation/iterable';
-import type { AztecKVStore, AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 import { type Batch, type Datastore, Key, type KeyQuery, type Pair, type Query } from 'interface-datastore';
 import type { AwaitIterable } from 'interface-store';
@@ -25,31 +25,31 @@ class KeyNotFoundError extends Error {
 
 export class AztecDatastore implements Datastore {
   #memoryDatastore: Map<string, MemoryItem>;
-  #dbDatastore: AztecMap<string, Uint8Array>;
+  #dbDatastore: AztecAsyncMap<string, Uint8Array>;
 
   #batchOps: BatchOp[] = [];
 
   private maxMemoryItems: number;
 
-  constructor(db: AztecKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+  constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
     this.#memoryDatastore = new Map();
     this.#dbDatastore = db.openMap('p2p_datastore');
 
     this.maxMemoryItems = maxMemoryItems;
   }
 
-  has(key: Key): boolean {
-    return this.#memoryDatastore.has(key.toString()) || this.#dbDatastore.has(key.toString());
+  async has(key: Key): Promise<boolean> {
+    return this.#memoryDatastore.has(key.toString()) || (await this.#dbDatastore.hasAsync(key.toString()));
   }
 
-  get(key: Key): Uint8Array {
+  async get(key: Key): Promise<Uint8Array> {
     const keyStr = key.toString();
     const memoryItem = this.#memoryDatastore.get(keyStr);
     if (memoryItem) {
       memoryItem.lastAccessedMs = Date.now();
       return memoryItem.data;
     }
-    const dbItem = this.#dbDatastore.get(keyStr);
+    const dbItem = await this.#dbDatastore.getAsync(keyStr);
 
     if (!dbItem) {
       throw new KeyNotFoundError(`Key not found`);
@@ -73,7 +73,7 @@ export class AztecDatastore implements Datastore {
     for await (const key of source) {
       yield {
         key,
-        value: this.get(key),
+        value: await this.get(key),
       };
     }
   }
@@ -202,7 +202,7 @@ export class AztecDatastore implements Datastore {
       };
     }
 
-    for (const [key, value] of this.#dbDatastore.entries()) {
+    for await (const [key, value] of this.#dbDatastore.entriesAsync()) {
       if (!this.#memoryDatastore.has(key)) {
         yield {
           key: new Key(key),

package/src/services/dummy_service.ts

@@ -61,6 +61,19 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve(undefined);
   }
 
+  /**
+   * Sends a batch request to a peer.
+   * @param _protocol - The protocol to send the request on.
+   * @param _requests - The requests to send.
+   * @returns The responses from the peer, otherwise undefined.
+   */
+  public sendBatchRequest<Protocol extends ReqRespSubProtocol>(
+    _protocol: Protocol,
+    _requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]> {
+    return Promise.resolve([]);
+  }
+
   /**
    * Returns the ENR of the peer.
    * @returns The ENR of the peer, otherwise undefined.