@aztec/p2p 0.0.0-test.0

package/src/config.ts

@@ -0,0 +1,371 @@
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  getDefaultConfig,
+  numberConfigHelper,
+  pickConfigMappings,
+} from '@aztec/foundation/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+
+import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqresp/config.js';
+
+/**
+ * P2P client configuration values.
+ */
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
+  /**
+   * A flag dictating whether the P2P subsystem should be enabled.
+   */
+  p2pEnabled: boolean;
+
+  /**
+   * The frequency in which to check for new L2 blocks.
+   */
+  blockCheckIntervalMS: number;
+
+  /**
+   * The number of blocks to fetch in a single batch.
+   */
+  blockRequestBatchSize: number;
+
+  /**
+   * DEBUG: Disable colocation penalty - for testing purposes only
+   */
+  debugDisableColocationPenalty: boolean;
+
+  /**
+   * The frequency in which to check for new peers.
+   */
+  peerCheckIntervalMS: number;
+
+  /**
+   * Size of queue of L2 blocks to store.
+   */
+  l2QueueSize: number;
+
+  /**
+   * The announce address for TCP.
+   */
+  tcpAnnounceAddress?: string;
+
+  /**
+   * The announce address for UDP.
+   */
+  udpAnnounceAddress?: string;
+
+  /**
+   * The listen address for TCP.
+   */
+  tcpListenAddress: string;
+
+  /**
+   * The listen address for UDP.
+   */
+  udpListenAddress: string;
+
+  /**
+   * An optional peer id private key. If blank, will generate a random key.
+   */
+  peerIdPrivateKey?: string;
+
+  /**
+   * A list of bootstrap peers to connect to.
+   */
+  bootstrapNodes: string[];
+
+  /** Whether to execute the version check in the bootstrap node ENR. */
+  bootstrapNodeEnrVersionCheck: boolean;
+
+  /** Whether to consider any configured bootnodes as full peers, e.g. for transaction gossiping */
+  bootstrapNodesAsFullPeers: boolean;
+
+  /**
+   * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
+   */
+  maxPeerCount: number;
+
+  /**
+   * If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.
+   */
+  queryForIp: boolean;
+
+  /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
+  keepProvenTxsInPoolFor: number;
+
+  /** How many slots to keep attestations for. */
+  keepAttestationsInPoolFor: number;
+
+  /**
+   * The interval of the gossipsub heartbeat to perform maintenance tasks.
+   */
+  gossipsubInterval: number;
+
+  /**
+   * The D parameter for the gossipsub protocol.
+   */
+  gossipsubD: number;
+
+  /**
+   * The Dlo parameter for the gossipsub protocol.
+   */
+  gossipsubDlo: number;
+
+  /**
+   * The Dhi parameter for the gossipsub protocol.
+   */
+  gossipsubDhi: number;
+
+  /**
+   * The Dlazy parameter for the gossipsub protocol.
+   */
+  gossipsubDLazy: number;
+
+  /**
+   * Whether to flood publish messages. - For testing purposes only
+   */
+  gossipsubFloodPublish: boolean;
+
+  /**
+   * The number of gossipsub interval message cache windows to keep.
+   */
+  gossipsubMcacheLength: number;
+
+  /**
+   * How many message cache windows to include when gossiping with other pears.
+   */
+  gossipsubMcacheGossip: number;
+
+  /**
+   * The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it.
+   */
+  doubleSpendSeverePeerPenaltyWindow: number;
+
+  /**
+   * The weight of the tx topic for the gossipsub protocol.  This determines how much the score for this specific topic contributes to the overall peer score.
+   */
+  gossipsubTxTopicWeight: number;
+
+  /**
+   * This is the weight applied to the penalty for delivering invalid messages.
+   */
+  gossipsubTxInvalidMessageDeliveriesWeight: number;
+
+  /**
+   * determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.
+   */
+  gossipsubTxInvalidMessageDeliveriesDecay: number;
+
+  /**
+   * The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.
+   */
+  peerPenaltyValues: number[];
+
+  /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
+  archivedTxLimit: number;
+}
+
+export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
+  p2pEnabled: {
+    env: 'P2P_ENABLED',
+    description: 'A flag dictating whether the P2P subsystem should be enabled.',
+    ...booleanConfigHelper(),
+  },
+  blockCheckIntervalMS: {
+    env: 'P2P_BLOCK_CHECK_INTERVAL_MS',
+    description: 'The frequency in which to check for new L2 blocks.',
+    ...numberConfigHelper(100),
+  },
+  debugDisableColocationPenalty: {
+    env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
+    description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
+    ...booleanConfigHelper(false),
+  },
+  peerCheckIntervalMS: {
+    env: 'P2P_PEER_CHECK_INTERVAL_MS',
+    description: 'The frequency in which to check for new peers.',
+    ...numberConfigHelper(30_000),
+  },
+  l2QueueSize: {
+    env: 'P2P_L2_QUEUE_SIZE',
+    description: 'Size of queue of L2 blocks to store.',
+    ...numberConfigHelper(1_000),
+  },
+  tcpListenAddress: {
+    env: 'P2P_TCP_LISTEN_ADDR',
+    defaultValue: '0.0.0.0:40400',
+    description: 'The listen address for TCP. Format: <IP_ADDRESS>:<PORT>.',
+  },
+  udpListenAddress: {
+    env: 'P2P_UDP_LISTEN_ADDR',
+    defaultValue: '0.0.0.0:40400',
+    description: 'The listen address for UDP. Format: <IP_ADDRESS>:<PORT>.',
+  },
+  tcpAnnounceAddress: {
+    env: 'P2P_TCP_ANNOUNCE_ADDR',
+    description:
+      'The announce address for TCP. Format: <IP_ADDRESS>:<PORT>. Leave IP_ADDRESS blank to query for public IP.',
+  },
+  udpAnnounceAddress: {
+    env: 'P2P_UDP_ANNOUNCE_ADDR',
+    description:
+      'The announce address for UDP. Format: <IP_ADDRESS>:<PORT>. Leave IP_ADDRESS blank to query for public IP.',
+  },
+  peerIdPrivateKey: {
+    env: 'PEER_ID_PRIVATE_KEY',
+    description: 'An optional peer id private key. If blank, will generate a random key.',
+  },
+  bootstrapNodes: {
+    env: 'BOOTSTRAP_NODES',
+    parseEnv: (val: string) => val.split(','),
+    description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
+  },
+  bootstrapNodeEnrVersionCheck: {
+    env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
+    description: 'Whether to check the version of the bootstrap node ENR.',
+    ...booleanConfigHelper(),
+  },
+  bootstrapNodesAsFullPeers: {
+    env: 'P2P_BOOTSTRAP_NODES_AS_FULL_PEERS',
+    description: 'Whether to consider our configured bootnodes as full peers',
+    ...booleanConfigHelper(false),
+  },
+  maxPeerCount: {
+    env: 'P2P_MAX_PEERS',
+    description: 'The maximum number of peers to connect to.',
+    ...numberConfigHelper(100),
+  },
+  queryForIp: {
+    env: 'P2P_QUERY_FOR_IP',
+    description:
+      'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
+    ...booleanConfigHelper(),
+  },
+  keepProvenTxsInPoolFor: {
+    env: 'P2P_TX_POOL_KEEP_PROVEN_FOR',
+    description:
+      'How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven)',
+    ...numberConfigHelper(0),
+  },
+  keepAttestationsInPoolFor: {
+    env: 'P2P_ATTESTATION_POOL_KEEP_FOR',
+    description: 'How many slots to keep attestations for.',
+    ...numberConfigHelper(96),
+  },
+  gossipsubInterval: {
+    env: 'P2P_GOSSIPSUB_INTERVAL_MS',
+    description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
+    ...numberConfigHelper(700),
+  },
+  gossipsubD: {
+    env: 'P2P_GOSSIPSUB_D',
+    description: 'The D parameter for the gossipsub protocol.',
+    ...numberConfigHelper(8),
+  },
+  gossipsubDlo: {
+    env: 'P2P_GOSSIPSUB_DLO',
+    description: 'The Dlo parameter for the gossipsub protocol.',
+    ...numberConfigHelper(4),
+  },
+  gossipsubDhi: {
+    env: 'P2P_GOSSIPSUB_DHI',
+    description: 'The Dhi parameter for the gossipsub protocol.',
+    ...numberConfigHelper(12),
+  },
+  gossipsubDLazy: {
+    env: 'P2P_GOSSIPSUB_DLAZY',
+    description: 'The Dlazy parameter for the gossipsub protocol.',
+    ...numberConfigHelper(8),
+  },
+  gossipsubFloodPublish: {
+    env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
+    description: 'Whether to flood publish messages. - For testing purposes only',
+    ...booleanConfigHelper(true),
+  },
+  gossipsubMcacheLength: {
+    env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
+    description: 'The number of gossipsub interval message cache windows to keep.',
+    ...numberConfigHelper(6),
+  },
+  gossipsubMcacheGossip: {
+    env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
+    description: 'How many message cache windows to include when gossiping with other pears.',
+    ...numberConfigHelper(3),
+  },
+  gossipsubTxTopicWeight: {
+    env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
+    description: 'The weight of the tx topic for the gossipsub protocol.',
+    ...numberConfigHelper(1),
+  },
+  gossipsubTxInvalidMessageDeliveriesWeight: {
+    env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_WEIGHT',
+    description: 'The weight of the tx invalid message deliveries for the gossipsub protocol.',
+    ...numberConfigHelper(-20),
+  },
+  gossipsubTxInvalidMessageDeliveriesDecay: {
+    env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_DECAY',
+    description: 'Determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.',
+    ...numberConfigHelper(0.5),
+  },
+  peerPenaltyValues: {
+    env: 'P2P_PEER_PENALTY_VALUES',
+    parseEnv: (val: string) => val.split(',').map(Number),
+    description:
+      'The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.',
+    defaultValue: [2, 10, 50],
+  },
+  doubleSpendSeverePeerPenaltyWindow: {
+    env: 'P2P_DOUBLE_SPEND_SEVERE_PEER_PENALTY_WINDOW',
+    description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
+    ...numberConfigHelper(30),
+  },
+  blockRequestBatchSize: {
+    env: 'P2P_BLOCK_REQUEST_BATCH_SIZE',
+    description: 'The number of blocks to fetch in a single batch.',
+    ...numberConfigHelper(20),
+  },
+  archivedTxLimit: {
+    env: 'P2P_ARCHIVED_TX_LIMIT',
+    description:
+      'The number of transactions that will be archived. If the limit is set to 0 then archiving will be disabled.',
+    ...numberConfigHelper(0),
+  },
+  ...p2pReqRespConfigMappings,
+  ...chainConfigMappings,
+};
+
+/**
+ * Gets the config values for p2p client from environment variables.
+ * @returns The config values for p2p client.
+ */
+export function getP2PConfigFromEnv(): P2PConfig {
+  return getConfigFromMappings<P2PConfig>(p2pConfigMappings);
+}
+
+export function getP2PDefaultConfig(): P2PConfig {
+  return getDefaultConfig<P2PConfig>(p2pConfigMappings);
+}
+
+/**
+ * Required P2P config values for a bootstrap node.
+ */
+export type BootnodeConfig = Pick<P2PConfig, 'udpAnnounceAddress' | 'peerIdPrivateKey' | 'bootstrapNodes'> &
+  Required<Pick<P2PConfig, 'udpListenAddress'>> &
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+  Pick<ChainConfig, 'l1ChainId'>;
+
+const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
+  'udpAnnounceAddress',
+  'peerIdPrivateKey',
+  'udpListenAddress',
+  'dataDirectory',
+  'dataStoreMapSizeKB',
+  'bootstrapNodes',
+  'l1ChainId',
+];
+
+export const bootnodeConfigMappings = pickConfigMappings(
+  { ...p2pConfigMappings, ...dataConfigMappings, ...chainConfigMappings },
+  bootnodeConfigKeys,
+);

package/src/enr/generate-enr.ts

@@ -0,0 +1,39 @@
+import type { LogFn } from '@aztec/foundation/log';
+import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
+
+import { ENR, SignableENR } from '@chainsafe/enr';
+import type { PeerId } from '@libp2p/interface';
+import { multiaddr } from '@multiformats/multiaddr';
+
+import { AZTEC_ENR_KEY } from '../types/index.js';
+import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { setAztecEnrKey } from '../versioning.js';
+
+export async function createBootnodeENRandPeerId(
+  privateKey: string,
+  udpAnnounceAddress: string,
+  l1ChainId: number,
+): Promise<{ enr: SignableENR; peerId: PeerId }> {
+  const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
+  const enr = SignableENR.createFromPeerId(peerId);
+  const publicAddr = multiaddr(convertToMultiaddr(udpAnnounceAddress, 'udp'));
+  enr.setLocationMultiaddr(publicAddr);
+
+  const config: ChainConfig = {
+    ...emptyChainConfig,
+    l1ChainId,
+  };
+
+  setAztecEnrKey(enr, config);
+  return { enr, peerId };
+}
+
+export async function printENR(enr: string, log: LogFn) {
+  const decoded = ENR.decodeTxt(enr);
+  log(`PeerID: ${await decoded.peerId()}`);
+  log(`IP: ${decoded.ip}`);
+  log(`UDP: ${decoded.udp}`);
+  log(`TCP: ${decoded.tcp}`);
+  const aztec = decoded.kvs.get(AZTEC_ENR_KEY);
+  log(`Aztec version: ${aztec?.toString()}`);
+}

package/src/enr/index.ts

@@ -0,0 +1 @@
+export * from './generate-enr.js';

package/src/errors/reqresp.error.ts

@@ -0,0 +1,35 @@
+/** Individual request timeout error
+ *
+ * This error will be thrown when a request to a specific peer times out.
+ * @category Errors
+ */
+export class IndividualReqRespTimeoutError extends Error {
+  constructor() {
+    super(`Request to peer timed out`);
+  }
+}
+
+/** Collective request timeout error
+ *
+ * This error will be thrown when a req resp request times out regardless of the peer.
+ * @category Errors
+ */
+export class CollectiveReqRespTimeoutError extends Error {
+  constructor() {
+    super(`Request to all peers timed out`);
+  }
+}
+
+/** Invalid response error
+ *
+ * This error will be thrown when a response is received that is not valid.
+ *
+ * This error does not need to be punished as message validators will handle punishing invalid
+ * requests
+ * @category Errors
+ */
+export class InvalidResponseError extends Error {
+  constructor() {
+    super(`Invalid response received`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './bootstrap/bootstrap.js';
+export * from './client/index.js';
+export * from './config.js';
+export * from './mem_pools/attestation_pool/index.js';
+export * from './mem_pools/tx_pool/index.js';
+export * from './msg_validators/index.js';
+export * from './services/index.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -0,0 +1,62 @@
+import type { BlockAttestation } from '@aztec/stdlib/p2p';
+
+/**
+ * An Attestation Pool contains attestations collected by a validator
+ *
+ * Attestations that are observed via the p2p network are stored for requests
+ * from the validator to produce a block, or to serve to other peers.
+ */
+export interface AttestationPool {
+  /**
+   * AddAttestation
+   *
+   * @param attestations - Attestations to add into the pool
+   */
+  addAttestations(attestations: BlockAttestation[]): Promise<void>;
+
+  /**
+   * DeleteAttestation
+   *
+   * @param attestations - Attestations to remove from the pool
+   */
+  deleteAttestations(attestations: BlockAttestation[]): Promise<void>;
+
+  /**
+   * Delete Attestations with a slot number smaller than the given slot
+   *
+   * Removes all attestations associated with a slot
+   *
+   * @param slot - The oldest slot to keep.
+   */
+  deleteAttestationsOlderThan(slot: bigint): Promise<void>;
+
+  /**
+   * Delete Attestations for slot
+   *
+   * Removes all attestations associated with a slot
+   *
+   * @param slot - The slot to delete.
+   */
+  deleteAttestationsForSlot(slot: bigint): Promise<void>;
+
+  /**
+   * Delete Attestations for slot and proposal
+   *
+   * Removes all attestations associated with a slot and proposal
+   *
+   * @param slot - The slot to delete.
+   * @param proposalId - The proposal to delete.
+   */
+  deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void>;
+
+  /**
+   * Get Attestations for slot
+   *
+   * Retrieve all of the attestations observed pertaining to a given slot
+   *
+   * @param slot - The slot to query
+   * @param proposalId - The proposal to query
+   * @return BlockAttestations
+   */
+  getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+}