@aztec/p2p 0.55.0 → 0.56.0

package/src/attestation_pool/mocks.ts

@@ -1,7 +1,7 @@
-import { BlockAttestation, Signature, TxHash } from '@aztec/circuit-types';
+import { BlockAttestation, ConsensusPayload, TxHash } from '@aztec/circuit-types';
 import { makeHeader } from '@aztec/circuits.js/testing';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
-import { serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { type PrivateKeyAccount } from 'viem';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
@@ -28,9 +28,11 @@ export const mockAttestation = async (signer: PrivateKeyAccount, slot: number =
   const archive = Fr.random();
   const txs = [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
 
-  const message: `0x${string}` = `0x${serializeToBuffer([archive, txs]).toString('hex')}`;
+  const payload = new ConsensusPayload(header, archive, txs);
+
+  const message: `0x${string}` = `0x${payload.getPayloadToSign().toString('hex')}`;
   const sigString = await signer.signMessage({ message });
 
   const signature = Signature.from0xString(sigString);
-  return new BlockAttestation(header, archive, txs, signature);
+  return new BlockAttestation(payload, signature);
 };

package/src/client/index.ts

@@ -1,4 +1,4 @@
-import { type L2BlockSource } from '@aztec/circuit-types';
+import type { ClientProtocolCircuitVerifier, L2BlockSource, WorldStateSynchronizer } from '@aztec/circuit-types';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore } from '@aztec/kv-store';
 import { type DataStoreConfig, createStore } from '@aztec/kv-store/utils';
@@ -17,69 +17,87 @@ import { getPublicIp, resolveAddressIfNecessary, splitAddressPort } from '../uti
 export * from './p2p_client.js';
 
 export const createP2PClient = async (
-  config: P2PConfig & DataStoreConfig,
+  _config: P2PConfig & DataStoreConfig,
   attestationsPool: AttestationPool,
   l2BlockSource: L2BlockSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  worldStateSynchronizer: WorldStateSynchronizer,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
   deps: { txPool?: TxPool; store?: AztecKVStore } = {},
 ) => {
+  let config = { ..._config };
   const store = deps.store ?? (await createStore('p2p', config, createDebugLogger('aztec:p2p:lmdb')));
   const txPool = deps.txPool ?? new AztecKVTxPool(store, telemetry);
 
   let p2pService;
 
-  if (config.p2pEnabled) {
-    // If announceTcpAddress or announceUdpAddress are not provided, query for public IP if config allows
-
-    const {
-      tcpAnnounceAddress: configTcpAnnounceAddress,
-      udpAnnounceAddress: configUdpAnnounceAddress,
-      queryForIp,
-    } = config;
-
-    config.tcpAnnounceAddress = configTcpAnnounceAddress
-      ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
-      : undefined;
-    config.udpAnnounceAddress = configUdpAnnounceAddress
-      ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
-      : undefined;
-
-    // create variable for re-use if needed
-    let publicIp;
-
-    // check if no announce IP was provided
-    const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
-    if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
-      if (queryForIp) {
-        publicIp = await getPublicIp();
-        const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
-        config.tcpAnnounceAddress = tcpAnnounceAddress;
-      } else {
-        throw new Error(
-          `Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`,
-        );
-      }
-    }
-
-    const splitUdpAnnounceAddress = splitAddressPort(configUdpAnnounceAddress || '', true);
-    if (splitUdpAnnounceAddress.length == 2 && splitUdpAnnounceAddress[0] === '') {
-      // If announceUdpAddress is not provided, use announceTcpAddress
-      if (!queryForIp && config.tcpAnnounceAddress) {
-        config.udpAnnounceAddress = config.tcpAnnounceAddress;
-      } else if (queryForIp) {
-        const udpPublicIp = publicIp || (await getPublicIp());
-        const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
-        config.udpAnnounceAddress = udpAnnounceAddress;
-      }
-    }
+  if (_config.p2pEnabled) {
+    config = await configureP2PClientAddresses(_config);
 
     // Create peer discovery service
     const peerId = await createLibP2PPeerId(config.peerIdPrivateKey);
     const discoveryService = new DiscV5Service(peerId, config);
 
-    p2pService = await LibP2PService.new(config, discoveryService, peerId, txPool, attestationsPool, store);
+    p2pService = await LibP2PService.new(
+      config,
+      discoveryService,
+      peerId,
+      txPool,
+      attestationsPool,
+      l2BlockSource,
+      proofVerifier,
+      worldStateSynchronizer,
+      store,
+    );
   } else {
     p2pService = new DummyP2PService();
   }
   return new P2PClient(store, l2BlockSource, txPool, attestationsPool, p2pService, config.keepProvenTxsInPoolFor);
 };
+
+async function configureP2PClientAddresses(_config: P2PConfig & DataStoreConfig): Promise<P2PConfig & DataStoreConfig> {
+  const config = { ..._config };
+  const {
+    tcpAnnounceAddress: configTcpAnnounceAddress,
+    udpAnnounceAddress: configUdpAnnounceAddress,
+    queryForIp,
+  } = config;
+
+  config.tcpAnnounceAddress = configTcpAnnounceAddress
+    ? await resolveAddressIfNecessary(configTcpAnnounceAddress)
+    : undefined;
+  config.udpAnnounceAddress = configUdpAnnounceAddress
+    ? await resolveAddressIfNecessary(configUdpAnnounceAddress)
+    : undefined;
+
+  // create variable for re-use if needed
+  let publicIp;
+
+  // check if no announce IP was provided
+  const splitTcpAnnounceAddress = splitAddressPort(configTcpAnnounceAddress || '', true);
+  if (splitTcpAnnounceAddress.length == 2 && splitTcpAnnounceAddress[0] === '') {
+    if (queryForIp) {
+      publicIp = await getPublicIp();
+      const tcpAnnounceAddress = `${publicIp}:${splitTcpAnnounceAddress[1]}`;
+      config.tcpAnnounceAddress = tcpAnnounceAddress;
+    } else {
+      throw new Error(
+        `Invalid announceTcpAddress provided: ${configTcpAnnounceAddress}. Expected format: <addr>:<port>`,
+      );
+    }
+  }
+
+  const splitUdpAnnounceAddress = splitAddressPort(configUdpAnnounceAddress || '', true);
+  if (splitUdpAnnounceAddress.length == 2 && splitUdpAnnounceAddress[0] === '') {
+    // If announceUdpAddress is not provided, use announceTcpAddress
+    if (!queryForIp && config.tcpAnnounceAddress) {
+      config.udpAnnounceAddress = config.tcpAnnounceAddress;
+    } else if (queryForIp) {
+      const udpPublicIp = publicIp || (await getPublicIp());
+      const udpAnnounceAddress = `${udpPublicIp}:${splitUdpAnnounceAddress[1]}`;
+      config.udpAnnounceAddress = udpAnnounceAddress;
+    }
+  }
+
+  return config;
+}

package/src/client/p2p_client.ts

@@ -319,8 +319,6 @@ export class P2PClient implements P2P {
 
     this.log.debug(`Requested ${txHash.toString()} from peer | success = ${!!tx}`);
     if (tx) {
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8485): This check is not sufficient to validate the transaction. We need to validate the entire proof.
-      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8483): alter peer scoring system for a validator that returns an invalid transcation
       await this.txPool.addTxs([tx]);
     }
 

package/src/config.ts

@@ -2,6 +2,7 @@ import {
   type ConfigMappingsType,
   booleanConfigHelper,
   getConfigFromMappings,
+  getDefaultConfig,
   numberConfigHelper,
   pickConfigMappings,
 } from '@aztec/foundation/config';
@@ -89,6 +90,66 @@ export interface P2PConfig extends P2PReqRespConfig {
 
   /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
   keepProvenTxsInPoolFor: 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 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.
+   */
+  severePeerPenaltyBlockLength: 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[];
+
+  /**
+   * The chain id of the L1 chain.
+   */
+  l1ChainId: number;
 }
 
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
@@ -172,6 +233,68 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven)',
     ...numberConfigHelper(0),
   },
+  gossipsubInterval: {
+    env: 'P2P_GOSSIPSUB_INTERVAL_MS',
+    description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
+    ...numberConfigHelper(1_000),
+  },
+  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),
+  },
+  gossipsubMcacheLength: {
+    env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
+    description: 'The number of gossipsub interval message cache windows to keep.',
+    ...numberConfigHelper(5),
+  },
+  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],
+  },
+  severePeerPenaltyBlockLength: {
+    env: 'P2P_SEVERE_PEER_PENALTY_BLOCK_LENGTH',
+    description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
+    ...numberConfigHelper(30),
+  },
+  l1ChainId: {
+    env: 'L1_CHAIN_ID',
+    description: 'The chain id of the L1 chain.',
+    ...numberConfigHelper(31337),
+  },
   ...p2pReqRespConfigMappings,
 };
 
@@ -183,6 +306,10 @@ export function getP2PConfigEnvVars(): P2PConfig {
   return getConfigFromMappings<P2PConfig>(p2pConfigMappings);
 }
 
+export function getP2PDefaultConfig(): P2PConfig {
+  return getDefaultConfig<P2PConfig>(p2pConfigMappings);
+}
+
 /**
  * Required P2P config values for a bootstrap node.
  */

package/src/index.ts

@@ -4,3 +4,4 @@ export * from './tx_pool/index.js';
 export * from './attestation_pool/index.js';
 export * from './service/index.js';
 export * from './bootstrap/bootstrap.js';
+export * from './tx_validator/index.js';

package/src/mocks/index.ts

@@ -1,16 +1,21 @@
+import { type ClientProtocolCircuitVerifier, type Tx } from '@aztec/circuit-types';
+
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { tcp } from '@libp2p/tcp';
 import { type Libp2p, type Libp2pOptions, createLibp2p } from 'libp2p';
 
+import { type PeerManager } from '../service/peer_manager.js';
 import { type P2PReqRespConfig } from '../service/reqresp/config.js';
 import { pingHandler, statusHandler } from '../service/reqresp/handlers.js';
 import {
   PING_PROTOCOL,
   type ReqRespSubProtocolHandlers,
+  type ReqRespSubProtocolValidators,
   STATUS_PROTOCOL,
   TX_REQ_PROTOCOL,
+  noopValidator,
 } from '../service/reqresp/interface.js';
 import { ReqResp } from '../service/reqresp/reqresp.js';
 
@@ -56,18 +61,29 @@ export const MOCK_SUB_PROTOCOL_HANDLERS: ReqRespSubProtocolHandlers = {
   [TX_REQ_PROTOCOL]: (_msg: any) => Promise.resolve(Uint8Array.from(Buffer.from('tx'))),
 };
 
+// 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,
+};
+
 /**
  * @param numberOfNodes - the number of nodes to create
  * @returns An array of the created nodes
  */
-export const createNodes = async (numberOfNodes: number): Promise<ReqRespNode[]> => {
-  return await Promise.all(Array.from({ length: numberOfNodes }, () => createReqResp()));
+export const createNodes = async (peerManager: PeerManager, numberOfNodes: number): Promise<ReqRespNode[]> => {
+  return await Promise.all(Array.from({ length: numberOfNodes }, () => createReqResp(peerManager)));
 };
 
-// TODO: think about where else this can go
-export const startNodes = async (nodes: ReqRespNode[], subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS) => {
+export const startNodes = async (
+  nodes: ReqRespNode[],
+  subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS,
+  subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS,
+) => {
   for (const node of nodes) {
-    await node.req.start(subProtocolHandlers);
+    await node.req.start(subProtocolHandlers, subProtocolValidators);
   }
 };
 
@@ -79,13 +95,13 @@ export const stopNodes = async (nodes: ReqRespNode[]): Promise<void> => {
 };
 
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (): Promise<ReqRespNode> => {
+export const createReqResp = async (peerManager: PeerManager): Promise<ReqRespNode> => {
   const p2p = await createLibp2pNode();
   const config: P2PReqRespConfig = {
     overallRequestTimeoutMs: 4000,
     individualRequestTimeoutMs: 2000,
   };
-  const req = new ReqResp(config, p2p);
+  const req = new ReqResp(config, p2p, peerManager);
   return {
     p2p,
     req,
@@ -104,3 +120,15 @@ export const connectToPeers = async (nodes: ReqRespNode[]): Promise<void> => {
     }
   }
 };
+
+// Mock circuit verifier for testing - reimplementation from bb to avoid dependency
+export class AlwaysTrueCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+}
+export class AlwaysFalseCircuitVerifier implements ClientProtocolCircuitVerifier {
+  verifyProof(_tx: Tx): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+}