@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/client/factory.ts

@@ -1,9 +1,12 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb-v2';
+import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
@@ -11,79 +14,167 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 import { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { InMemoryAttestationPool } from '../mem_pools/attestation_pool/memory_attestation_pool.js';
+import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
-import { DiscV5Service } from '../services/discv5/discV5_service.js';
 import { DummyP2PService } from '../services/dummy_service.js';
 import { LibP2PService } from '../services/index.js';
+import { TxCollection } from '../services/tx_collection/tx_collection.js';
+import { type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
-type P2PClientDeps<T extends P2PClientType> = {
+export type P2PClientDeps<T extends P2PClientType> = {
   txPool?: TxPool;
   store?: AztecAsyncKVStore;
   attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
   logger?: Logger;
+  txCollectionNodeSources?: TxSource[];
+  p2pServiceFactory?: (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService<T>>;
 };
 
-export const createP2PClient = async <T extends P2PClientType>(
+export const P2P_STORE_NAME = 'p2p';
+export const P2P_ARCHIVE_STORE_NAME = 'p2p-archive';
+export const P2P_PEER_STORE_NAME = 'p2p-peers';
+export const P2P_ATTESTATION_STORE_NAME = 'p2p-attestation';
+
+export async function createP2PClient<T extends P2PClientType>(
   clientType: T,
-  _config: P2PConfig & DataStoreConfig,
-  l2BlockSource: L2BlockSource,
+  inputConfig: P2PConfig & DataStoreConfig & ChainConfig,
+  archiver: L2BlockSource & ContractDataSource,
   proofVerifier: ClientProtocolCircuitVerifier,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCacheInterface,
+  packageVersion: string,
+  dateProvider: DateProvider = new DateProvider(),
   telemetry: TelemetryClient = getTelemetryClient(),
   deps: P2PClientDeps<T> = {},
-) => {
-  let config = { ..._config };
+) {
+  const config = await configureP2PClientAddresses({
+    ...inputConfig,
+    dataStoreMapSizeKb: inputConfig.p2pStoreMapSizeKb ?? inputConfig.dataStoreMapSizeKb,
+  });
+
   const logger = deps.logger ?? createLogger('p2p');
-  const store = deps.store ?? (await createStore('p2p', 1, config, createLogger('p2p:lmdb-v2')));
-  const archive = await createStore('p2p-archive', 1, config, createLogger('p2p-archive:lmdb-v2'));
+
+  if (config.bootstrapNodes.length === 0) {
+    logger.warn(
+      'No bootstrap nodes have been provided. Set the BOOTSTRAP_NODES environment variable in order to join the P2P network',
+    );
+  }
+
+  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, createLogger('p2p:lmdb-v2')));
+  const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, createLogger('p2p-archive:lmdb-v2'));
+  const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, createLogger('p2p-peer:lmdb-v2'));
+  const attestationStore = await createStore(
+    P2P_ATTESTATION_STORE_NAME,
+    1,
+    config,
+    createLogger('p2p-attestation:lmdb-v2'),
+  );
+  const l1Constants = await archiver.getL1Constants();
 
   const mempools: MemPools<T> = {
-    txPool: deps.txPool ?? new AztecKVTxPool(store, archive, telemetry, config.archivedTxLimit),
+    txPool:
+      deps.txPool ??
+      new AztecKVTxPool(store, archive, worldStateSynchronizer, telemetry, {
+        maxTxPoolSize: config.maxTxPoolSize,
+        archivedTxLimit: config.archivedTxLimit,
+      }),
     attestationPool:
       clientType === P2PClientType.Full
-        ? ((deps.attestationPool ?? new InMemoryAttestationPool(telemetry)) as T extends P2PClientType.Full
+        ? ((deps.attestationPool ?? new KvAttestationPool(attestationStore, telemetry)) as T extends P2PClientType.Full
             ? AttestationPool
             : undefined)
         : undefined,
   };
 
-  let p2pService;
+  const p2pService = await createP2PService<T>(
+    config,
+    clientType,
+    archiver,
+    proofVerifier,
+    worldStateSynchronizer,
+    epochCache,
+    store,
+    peerStore,
+    mempools,
+    deps.p2pServiceFactory,
+    packageVersion,
+    logger.createChild('libp2p_service'),
+    telemetry,
+  );
 
-  if (_config.p2pEnabled) {
-    logger.verbose('P2P is enabled. Using LibP2P service.');
-    config = await configureP2PClientAddresses(_config);
+  const nodeSources = [
+    ...createNodeRpcTxSources(config.txCollectionNodeRpcUrls, config),
+    ...(deps.txCollectionNodeSources ?? []),
+  ];
+  if (nodeSources.length > 0) {
+    logger.info(`Using ${nodeSources.length} node RPC sources for tx collection.`, {
+      nodes: nodeSources.map(n => n.getInfo()),
+    });
+  }
 
-    // Create peer discovery service
-    const peerIdPrivateKey = await getPeerIdPrivateKey(config, store);
-    const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey);
-    const discoveryService = new DiscV5Service(
-      peerId,
-      config,
-      telemetry,
-      createLogger(`${logger.module}:discv5_service`),
-    );
+  const txCollection = new TxCollection(
+    p2pService,
+    nodeSources,
+    l1Constants,
+    mempools.txPool,
+    config,
+    dateProvider,
+    telemetry,
+    logger.createChild('tx-collection'),
+  );
 
-    p2pService = await LibP2PService.new<T>(
-      clientType,
-      config,
-      discoveryService,
-      peerId,
-      mempools,
-      l2BlockSource,
-      epochCache,
-      proofVerifier,
-      worldStateSynchronizer,
-      store,
-      telemetry,
-      createLogger(`${logger.module}:libp2p_service`),
-    );
-  } else {
-    logger.verbose('P2P is disabled. Using dummy P2P service');
-    p2pService = new DummyP2PService();
+  return new P2PClient(
+    clientType,
+    store,
+    archiver,
+    mempools,
+    p2pService,
+    txCollection,
+    config,
+    dateProvider,
+    telemetry,
+  );
+}
+
+async function createP2PService<T extends P2PClientType>(
+  config: P2PConfig & DataStoreConfig,
+  clientType: T,
+  archiver: L2BlockSource & ContractDataSource,
+  proofVerifier: ClientProtocolCircuitVerifier,
+  worldStateSynchronizer: WorldStateSynchronizer,
+  epochCache: EpochCacheInterface,
+  store: AztecAsyncKVStore,
+  peerStore: AztecLMDBStoreV2,
+  mempools: MemPools<T>,
+  p2pServiceFactory: P2PClientDeps<T>['p2pServiceFactory'],
+  packageVersion: string,
+  logger: Logger,
+  telemetry: TelemetryClient,
+) {
+  if (!config.p2pEnabled) {
+    logger.verbose('P2P is disabled. Using dummy P2P service.');
+    return new DummyP2PService();
   }
-  return new P2PClient(clientType, store, l2BlockSource, mempools, p2pService, config, telemetry);
-};
+
+  logger.verbose('P2P is enabled. Using LibP2P service.');
+
+  // Create peer discovery service
+  const peerIdPrivateKey = await getPeerIdPrivateKey(config, store, logger);
+  const peerId = await createLibP2PPeerIdFromPrivateKey(peerIdPrivateKey.getValue());
+
+  const p2pService = await (p2pServiceFactory ?? LibP2PService.new<T>)(clientType, config, peerId, {
+    packageVersion,
+    mempools,
+    l2BlockSource: archiver,
+    epochCache,
+    proofVerifier,
+    worldStateSynchronizer,
+    peerStore,
+    telemetry,
+    logger: logger.createChild(`libp2p_service`),
+  });
+
+  return p2pService;
+}

package/src/client/index.ts

@@ -1,2 +1,3 @@
 export * from './p2p_client.js';
 export * from './factory.js';
+export * from './interface.js';

package/src/client/interface.ts

@@ -0,0 +1,198 @@
+import type { EthAddress, L2BlockId } from '@aztec/stdlib/block';
+import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
+import type { BlockAttestation, BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
+
+import type { P2PConfig } from '../config.js';
+import type { AuthRequest, StatusMessage } from '../services/index.js';
+import type {
+  ReqRespSubProtocol,
+  ReqRespSubProtocolHandler,
+  ReqRespSubProtocolValidators,
+} from '../services/reqresp/interface.js';
+import type { P2PBlockReceivedCallback } from '../services/service.js';
+
+/**
+ * Enum defining the possible states of the p2p client.
+ */
+export enum P2PClientState {
+  IDLE,
+  SYNCHING,
+  RUNNING,
+  STOPPED,
+}
+
+/**
+ * The synchronization status of the P2P client.
+ */
+export interface P2PSyncState {
+  /**
+   * The current state of the p2p client.
+   */
+  state: P2PClientState;
+  /**
+   * The block number that the p2p client is synced to.
+   */
+  syncedToL2Block: L2BlockId;
+}
+
+/**
+ * Interface of a P2P client.
+ **/
+export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> & {
+  /**
+   * Broadcasts a block proposal to other peers.
+   *
+   * @param proposal - the block proposal
+   */
+  broadcastProposal(proposal: BlockProposal): Promise<void>;
+
+  /** Broadcasts block attestations to other peers. */
+  broadcastAttestations(attestations: BlockAttestation[]): Promise<void>;
+
+  /**
+   * Registers a callback from the validator client that determines how to behave when
+   * foreign block proposals are received
+   *
+   * @param handler - A function taking a received block proposal and producing an attestation
+   */
+  // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
+  // ^ This pattern is not my favorite (md)
+  registerBlockProposalHandler(callback: P2PBlockReceivedCallback): void;
+
+  /**
+   * Request a list of transactions from another peer by their tx hashes.
+   * @param txHashes - Hashes of the txs to query.
+   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
+   * @returns A list of transactions or undefined if the transactions are not found.
+   */
+  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<Tx[]>;
+
+  /**
+   * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+   * @param tx - The transaction.
+   **/
+  sendTx(tx: Tx): Promise<void>;
+
+  /**
+   * Adds transactions to the pool. Does not send to peers or validate the tx.
+   * @param txs - The transactions.
+   * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
+   **/
+  addTxsToPool(txs: Tx[]): Promise<number>;
+
+  /**
+   * Deletes 'txs' from the pool, given hashes.
+   * NOT used if we use sendTx as reconcileTxPool will handle this.
+   * @param txHashes - Hashes to check.
+   **/
+  deleteTxs(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash  - Hash of tx to return.
+   * @returns A single tx or undefined.
+   */
+  getTxByHashFromPool(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Returns transactions in the transaction pool by hash.
+   * @param txHashes  - Hashes of txs to return.
+   * @returns An array of txs or undefined.
+   */
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+
+  /**
+   * Checks if transactions exist in the pool
+   * @param txHashes - The hashes of the transactions to check for
+   * @returns True or False for each hash
+   */
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]>;
+
+  /**
+   * Returns transactions in the transaction pool by hash, requesting from the network if not found.
+   * @param txHashes  - Hashes of tx to return.
+   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
+   * @returns An array of tx or undefined.
+   */
+  getTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId | undefined): Promise<(Tx | undefined)[]>;
+
+  /**
+   * Returns an archived transaction from the transaction pool by its hash.
+   * @param txHash  - Hash of tx to return.
+   * @returns A single tx or undefined.
+   */
+  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * Returns whether the given tx hash is flagged as pending, mined, or deleted.
+   * @param txHash - Hash of the tx to query.
+   * @returns Pending, mined, or deleted depending on its status, or undefined if not found.
+   */
+  getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
+
+  /** Returns an iterator over pending txs on the mempool. */
+  iteratePendingTxs(): AsyncIterableIterator<Tx>;
+
+  /** Returns the number of pending txs in the mempool. */
+  getPendingTxCount(): Promise<number>;
+
+  /**
+   * Marks transactions as non-evictable in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictable.
+   */
+  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Starts the p2p client.
+   * @returns A promise signalling the completion of the block sync.
+   */
+  start(): Promise<void>;
+
+  /**
+   * Stops the p2p client.
+   * @returns A promise signalling the completion of the stop process.
+   */
+  stop(): Promise<void>;
+
+  /**
+   * Indicates if the p2p client is ready for transaction submission.
+   * @returns A boolean flag indicating readiness.
+   */
+  isReady(): boolean;
+
+  /**
+   * Returns the current status of the p2p client.
+   */
+  getStatus(): Promise<P2PSyncState>;
+
+  /**
+   * Returns the ENR of this node, if any.
+   */
+  getEnr(): ENR | undefined;
+
+  /** Identifies a p2p client. */
+  isP2PClient(): true;
+
+  updateP2PConfig(config: Partial<P2PConfig>): Promise<void>;
+
+  /** Validates a set of txs. */
+  validate(txs: Tx[]): Promise<void>;
+
+  /** Clears the db. */
+  clear(): Promise<void>;
+
+  addReqRespSubProtocol(
+    subProtocol: ReqRespSubProtocol,
+    handler: ReqRespSubProtocolHandler,
+    validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
+  ): Promise<void>;
+
+  handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
+
+  /** If node running this P2P stack is validator, passes in validator address to P2P layer */
+  registerThisValidatorAddresses(address: EthAddress[]): void;
+};