@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.001888fc

package/src/services/reqresp/status.ts

@@ -5,17 +5,22 @@ export enum ReqRespStatus {
   SUCCESS = 0,
   RATE_LIMIT_EXCEEDED = 1,
   BADLY_FORMED_REQUEST = 2,
+  INTERNAL_ERROR = 3,
+  NOT_FOUND = 4,
+  FAILURE = 126,
   UNKNOWN = 127,
 }
 
+export type UnsuccessfulReqRespStatus = Exclude<ReqRespStatus, ReqRespStatus.SUCCESS>;
+
 export class ReqRespStatusError extends Error {
   /**
    * The status code
    */
-  status: ReqRespStatus;
+  readonly status: UnsuccessfulReqRespStatus;
 
-  constructor(status: ReqRespStatus) {
-    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`);
+  constructor(status: UnsuccessfulReqRespStatus, cause?: { cause?: Error }) {
+    super(`ReqResp Error: ${prettyPrintReqRespStatus(status)}`, cause);
     this.status = status;
   }
 }
@@ -53,6 +58,10 @@ export function prettyPrintReqRespStatus(status: ReqRespStatus) {
       return 'RATE_LIMIT_EXCEEDED';
     case ReqRespStatus.BADLY_FORMED_REQUEST:
       return 'BADLY_FORMED_REQUEST';
+    case ReqRespStatus.FAILURE:
+      return 'FAILURE';
+    case ReqRespStatus.INTERNAL_ERROR:
+      return 'INTERNAL_ERROR';
     case ReqRespStatus.UNKNOWN:
       return 'UNKNOWN';
   }

package/src/services/service.ts

@@ -1,17 +1,81 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { BlockAttestation, BlockProposal, Gossipable } from '@aztec/stdlib/p2p';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposalCore,
+  Gossipable,
+  TopicType,
+} 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 { ReqRespSubProtocol, SubProtocolMap } from './reqresp/interface.js';
+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 {
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolValidators,
+  SubProtocolMap,
+} from './reqresp/interface.js';
+import type { AuthRequest, AuthResponse } from './reqresp/protocols/auth.js';
 
 export enum PeerDiscoveryState {
   RUNNING = 'running',
   STOPPED = 'stopped',
 }
 
+/**
+ * Callback for when a block proposal is received.
+ * Validators validate but DO NOT attest to individual blocks - attestations are only for checkpoints.
+ * @returns true if the proposal is valid, false otherwise
+ */
+export type P2PBlockReceivedCallback = (block: BlockProposal, sender: PeerId) => Promise<boolean>;
+
+/**
+ * Callback for when a checkpoint proposal is received.
+ * The checkpoint proposal is passed as CheckpointProposalCore (without lastBlock) since
+ * the lastBlock is extracted and stored separately as a BlockProposal, and the block
+ * callback is invoked and awaited before this checkpoint callback.
+ */
+export type P2PCheckpointReceivedCallback = (
+  checkpoint: CheckpointProposalCore,
+  sender: PeerId,
+) => Promise<CheckpointAttestation[] | undefined>;
+
+export type AuthReceivedCallback = (peerId: PeerId, authRequest: AuthRequest) => Promise<AuthResponse | undefined>;
+
+/** Minimal info passed to the duplicate proposal callback. */
+export type DuplicateProposalInfo = {
+  slot: SlotNumber;
+  proposer: EthAddress;
+  type: 'checkpoint' | 'block';
+};
+
+/**
+ * Callback for when a duplicate proposal is detected (equivocation).
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateProposalCallback = (info: DuplicateProposalInfo) => void;
+
+/** Minimal info passed to the duplicate attestation callback. */
+export type DuplicateAttestationInfo = {
+  slot: SlotNumber;
+  attester: EthAddress;
+};
+
+/**
+ * Callback for when a duplicate attestation is detected (equivocation).
+ * A validator signing attestations for different proposals at the same slot.
+ * Invoked on the first duplicate (when count goes from 1 to 2).
+ */
+export type P2PDuplicateAttestationCallback = (info: DuplicateAttestationInfo) => void;
+
 /**
  * The interface for a P2P service implementation.
  */
@@ -32,19 +96,7 @@ export interface P2PService {
    * Called to have the given transaction propagated through the P2P network.
    * @param message - The message to be propagated.
    */
-  propagate<T extends Gossipable>(message: T): void;
-
-  /**
-   * Request information from peers via the request response protocol.
-   *
-   * @param protocol - The request response protocol to use
-   * @param request - The request type, corresponding to the protocol
-   * @returns The response type, corresponding to the protocol
-   */
-  sendRequest<Protocol extends ReqRespSubProtocol>(
-    protocol: Protocol,
-    request: InstanceType<SubProtocolMap[Protocol]['request']>,
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
+  propagate<T extends Gossipable>(message: T): Promise<void>;
 
   /**
    * Send a batch of requests to peers, and return the responses
@@ -56,14 +108,54 @@ export interface P2PService {
   sendBatchRequest<Protocol extends ReqRespSubProtocol>(
     protocol: Protocol,
     requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+    pinnedPeerId?: PeerId,
+    timeoutMs?: number,
+    maxPeers?: number,
+    maxRetryAttempts?: number,
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]>;
 
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
-  registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
+  registerBlockReceivedCallback(callback: P2PBlockReceivedCallback): void;
+
+  registerCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback): void;
+
+  /**
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   */
+  registerDuplicateProposalCallback(callback: P2PDuplicateProposalCallback): void;
+
+  /**
+   * Registers a callback invoked when a duplicate attestation is detected (equivocation).
+   * A validator signing attestations for different proposals at the same slot.
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   */
+  registerDuplicateAttestationCallback(callback: P2PDuplicateAttestationCallback): void;
 
   getEnr(): ENR | undefined;
 
   getPeers(includePending?: boolean): PeerInfo[];
+
+  /** Returns the number of peers in the GossipSub mesh for a given topic type. */
+  getGossipMeshPeerCount(topicType: TopicType): number;
+
+  validateTxsReceivedInBlockProposal(txs: Tx[]): Promise<void>;
+
+  addReqRespSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void>;
+
+  handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
+
+  updateConfig(config: Partial<P2PReqRespConfig>): void;
+
+  /** 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;
 }
 
 /**
@@ -81,10 +173,10 @@ export interface PeerDiscoveryService extends EventEmitter {
   stop(): Promise<void>;
 
   /**
-   * Gets all peers.
-   * @returns An array of peer ENRs.
+   * Gets all KadValues.
+   * @returns An array of ENRs.
    */
-  getAllPeers(): ENR[];
+  getKadValues(): ENR[];
 
   /**
    * Runs findRandomNode query.
@@ -108,5 +200,5 @@ export interface PeerDiscoveryService extends EventEmitter {
 
   getEnr(): ENR | undefined;
 
-  bootstrapNodes: string[];
+  bootstrapNodeEnrs: ENR[];
 }

package/src/services/tx_collection/config.ts

@@ -0,0 +1,166 @@
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  enumConfigHelper,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { MAX_RPC_TXS_LEN } from '@aztec/stdlib/interfaces/api-limit';
+
+export type MissingTxsCollectorType = 'new' | 'old';
+
+export type TxCollectionConfig = {
+  /** How long to wait before starting reqresp for fast collection  */
+  txCollectionFastNodesTimeoutBeforeReqRespMs: number;
+  /** How often to collect from configured nodes */
+  txCollectionSlowNodesIntervalMs: number;
+  /** How ofter to collect from peers */
+  txCollectionSlowReqRespIntervalMs: number;
+  /** How long to wait for a reqresp response during slow collection */
+  txCollectionSlowReqRespTimeoutMs: number;
+  /** How often to reconcile found txs with the tx pool */
+  txCollectionReconcileIntervalMs: number;
+  /** Whether to disable the slow collection loop if we are dealing with any immediate requests */
+  txCollectionDisableSlowDuringFastRequests: boolean;
+  /** How many ms to wait between retried request to a node via RPC during fast collection */
+  txCollectionFastNodeIntervalMs: number;
+  /** A comma-separated list of Aztec node RPC URLs to use for tx collection */
+  txCollectionNodeRpcUrls: string[];
+  /** Maximum number of parallel requests to make to a node during fast collection */
+  txCollectionFastMaxParallelRequestsPerNode: number;
+  /** Maximum number of transactions to request from a node in a single batch */
+  txCollectionNodeRpcMaxBatchSize: number;
+  /** Which collector implementation to use for missing txs collection */
+  txCollectionMissingTxsCollectorType: MissingTxsCollectorType;
+  /** A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection */
+  txCollectionFileStoreUrls: string[];
+  /** Delay in ms before file store collection starts after slow collection is triggered */
+  txCollectionFileStoreSlowDelayMs: number;
+  /** Delay in ms before file store collection starts after fast collection is triggered */
+  txCollectionFileStoreFastDelayMs: number;
+  /** Number of concurrent workers for fast file store collection */
+  txCollectionFileStoreFastWorkerCount: number;
+  /** Number of concurrent workers for slow file store collection */
+  txCollectionFileStoreSlowWorkerCount: number;
+  /** Base backoff time in ms for fast file store collection retries */
+  txCollectionFileStoreFastBackoffBaseMs: number;
+  /** Base backoff time in ms for slow file store collection retries */
+  txCollectionFileStoreSlowBackoffBaseMs: number;
+  /** Max backoff time in ms for fast file store collection retries */
+  txCollectionFileStoreFastBackoffMaxMs: number;
+  /** Max backoff time in ms for slow file store collection retries */
+  txCollectionFileStoreSlowBackoffMaxMs: number;
+};
+
+export const txCollectionConfigMappings: ConfigMappingsType<TxCollectionConfig> = {
+  txCollectionFastNodesTimeoutBeforeReqRespMs: {
+    env: 'TX_COLLECTION_FAST_NODES_TIMEOUT_BEFORE_REQ_RESP_MS',
+    description: 'How long to wait before starting reqresp for fast collection',
+    ...numberConfigHelper(200),
+  },
+  txCollectionSlowNodesIntervalMs: {
+    env: 'TX_COLLECTION_SLOW_NODES_INTERVAL_MS',
+    description: 'How often to collect from configured nodes in the slow collection loop',
+    ...numberConfigHelper(12_000),
+  },
+  txCollectionSlowReqRespIntervalMs: {
+    env: 'TX_COLLECTION_SLOW_REQ_RESP_INTERVAL_MS',
+    description: 'How often to collect from peers via reqresp in the slow collection loop',
+    ...numberConfigHelper(12_000),
+  },
+  txCollectionSlowReqRespTimeoutMs: {
+    env: 'TX_COLLECTION_SLOW_REQ_RESP_TIMEOUT_MS',
+    description: 'How long to wait for a reqresp response during slow collection',
+    ...numberConfigHelper(20_000),
+  },
+  txCollectionReconcileIntervalMs: {
+    env: 'TX_COLLECTION_RECONCILE_INTERVAL_MS',
+    description: 'How often to reconcile found txs from the tx pool',
+    ...numberConfigHelper(60_000),
+  },
+  txCollectionDisableSlowDuringFastRequests: {
+    env: 'TX_COLLECTION_DISABLE_SLOW_DURING_FAST_REQUESTS',
+    description: 'Whether to disable the slow collection loop if we are dealing with any immediate requests',
+    ...booleanConfigHelper(true),
+  },
+  txCollectionFastNodeIntervalMs: {
+    env: 'TX_COLLECTION_FAST_NODE_INTERVAL_MS',
+    description: 'How many ms to wait between retried request to a node via RPC during fast collection',
+    ...numberConfigHelper(500),
+  },
+  txCollectionNodeRpcUrls: {
+    env: 'TX_COLLECTION_NODE_RPC_URLS',
+    fallback: ['PROVER_COORDINATION_NODE_URLS'],
+    description: 'A comma-separated list of Aztec node RPC URLs to use for tx collection',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(url => url.trim().replace(/\/$/, ''))
+        .filter(url => url.length > 0),
+    defaultValue: [],
+  },
+  txCollectionFastMaxParallelRequestsPerNode: {
+    env: 'TX_COLLECTION_FAST_MAX_PARALLEL_REQUESTS_PER_NODE',
+    description: 'Maximum number of parallel requests to make to a node during fast collection',
+    ...numberConfigHelper(4),
+  },
+  txCollectionNodeRpcMaxBatchSize: {
+    env: 'TX_COLLECTION_NODE_RPC_MAX_BATCH_SIZE',
+    description: 'Maximum number of transactions to request from a node in a single batch',
+    ...numberConfigHelper(MAX_RPC_TXS_LEN),
+  },
+  txCollectionMissingTxsCollectorType: {
+    env: 'TX_COLLECTION_MISSING_TXS_COLLECTOR_TYPE',
+    description: 'Which collector implementation to use for missing txs collection (new or old)',
+    ...enumConfigHelper(['new', 'old'] as const, 'new'),
+  },
+  txCollectionFileStoreUrls: {
+    env: 'TX_COLLECTION_FILE_STORE_URLS',
+    description: 'A comma-separated list of file store URLs (s3://, gs://, file://, http://) for tx collection',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(url => url.trim())
+        .filter(url => url.length > 0),
+    defaultValue: [],
+  },
+  txCollectionFileStoreSlowDelayMs: {
+    env: 'TX_COLLECTION_FILE_STORE_SLOW_DELAY_MS',
+    description: 'Delay before file store collection starts after slow collection',
+    ...numberConfigHelper(24_000),
+  },
+  txCollectionFileStoreFastDelayMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_DELAY_MS',
+    description: 'Delay before file store collection starts after fast collection',
+    ...numberConfigHelper(2_000),
+  },
+  txCollectionFileStoreFastWorkerCount: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_WORKER_COUNT',
+    description: 'Number of concurrent workers for fast file store collection',
+    ...numberConfigHelper(5),
+  },
+  txCollectionFileStoreSlowWorkerCount: {
+    env: 'TX_COLLECTION_FILE_STORE_SLOW_WORKER_COUNT',
+    description: 'Number of concurrent workers for slow file store collection',
+    ...numberConfigHelper(2),
+  },
+  txCollectionFileStoreFastBackoffBaseMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_BASE_MS',
+    description: 'Base backoff time in ms for fast file store collection retries',
+    ...numberConfigHelper(1_000),
+  },
+  txCollectionFileStoreSlowBackoffBaseMs: {
+    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_BASE_MS',
+    description: 'Base backoff time in ms for slow file store collection retries',
+    ...numberConfigHelper(5_000),
+  },
+  txCollectionFileStoreFastBackoffMaxMs: {
+    env: 'TX_COLLECTION_FILE_STORE_FAST_BACKOFF_MAX_MS',
+    description: 'Max backoff time in ms for fast file store collection retries',
+    ...numberConfigHelper(5_000),
+  },
+  txCollectionFileStoreSlowBackoffMaxMs: {
+    env: 'TX_COLLECTION_FILE_STORE_SLOW_BACKOFF_MAX_MS',
+    description: 'Max backoff time in ms for slow file store collection retries',
+    ...numberConfigHelper(30_000),
+  },
+};