@aztec/p2p 0.23.0 → 0.26.1

package/src/client/mocks.ts

@@ -0,0 +1,103 @@
+import { L2Block, L2BlockSource, TxEffect, TxHash, TxReceipt, TxStatus } from '@aztec/circuit-types';
+import { EthAddress } from '@aztec/circuits.js';
+
+/**
+ * A mocked implementation of L2BlockSource to be used in p2p tests.
+ */
+export class MockBlockSource implements L2BlockSource {
+  private l2Blocks: L2Block[] = [];
+  private txEffects: TxEffect[] = [];
+
+  constructor(private numBlocks = 100) {
+    for (let i = 0; i < this.numBlocks; i++) {
+      const block = L2Block.random(i);
+      this.l2Blocks.push(block);
+      this.txEffects.push(...block.getTxs());
+    }
+  }
+
+  /**
+   * Method to fetch the rollup contract address at the base-layer.
+   * @returns The rollup address.
+   */
+  getRollupAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Method to fetch the registry contract address at the base-layer.
+   * @returns The registry address.
+   */
+  getRegistryAddress(): Promise<EthAddress> {
+    return Promise.resolve(EthAddress.random());
+  }
+
+  /**
+   * Gets the number of the latest L2 block processed by the block source implementation.
+   * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
+   */
+  public getBlockNumber() {
+    return Promise.resolve(this.l2Blocks.length - 1);
+  }
+
+  /**
+   * Gets an l2 block.
+   * @param number - The block number to return (inclusive).
+   * @returns The requested L2 block.
+   */
+  public getBlock(number: number) {
+    return Promise.resolve(this.l2Blocks[number]);
+  }
+
+  /**
+   * Gets up to `limit` amount of L2 blocks starting from `from`.
+   * @param from - Number of the first block to return (inclusive).
+   * @param limit - The maximum number of blocks to return.
+   * @returns The requested mocked L2 blocks.
+   */
+  public getBlocks(from: number, limit: number) {
+    return Promise.resolve(this.l2Blocks.slice(from, from + limit));
+  }
+
+  /**
+   * Gets a tx effect.
+   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
+   * @returns The requested tx effect.
+   */
+  public getTxEffect(txHash: TxHash) {
+    const txEffect = this.txEffects.find(tx => tx.txHash.equals(txHash));
+    return Promise.resolve(txEffect);
+  }
+
+  /**
+   * Gets a receipt of a settled tx.
+   * @param txHash - The hash of a tx we try to get the receipt for.
+   * @returns The requested tx receipt (or undefined if not found).
+   */
+  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+    for (const block of this.l2Blocks) {
+      for (const txEffect of block.body.txEffects) {
+        if (txEffect.txHash.equals(txHash)) {
+          return Promise.resolve(new TxReceipt(txHash, TxStatus.MINED, '', block.hash().toBuffer(), block.number));
+        }
+      }
+    }
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * Starts the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the initialization of the l2 block source on completion.
+   */
+  public start(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the block source. In this mock implementation, this is a noop.
+   * @returns A promise that signals the l2 block source is now stopped.
+   */
+  public stop(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/client/p2p_client.ts

@@ -0,0 +1,327 @@
+import { L2Block, L2BlockContext, L2BlockDownloader, L2BlockSource, Tx, TxHash } from '@aztec/circuit-types';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js/constants';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore, AztecSingleton } from '@aztec/kv-store';
+
+import { getP2PConfigEnvVars } from '../config.js';
+import { P2PService } from '../service/service.js';
+import { TxPool } from '../tx_pool/index.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: number;
+}
+
+/**
+ * Interface of a P2P client.
+ **/
+export interface P2P {
+  /**
+   * 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>;
+
+  /**
+   * 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 all transactions in the transaction pool.
+   * @returns An array of Txs.
+   */
+  getTxs(): Promise<Tx[]>;
+
+  /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash  - Hash of tx to return.
+   * @returns A single tx or undefined.
+   */
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+
+  /**
+   * 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(): Promise<boolean>;
+
+  /**
+   * Returns the current status of the p2p client.
+   */
+  getStatus(): Promise<P2PSyncState>;
+}
+
+/**
+ * The P2P client implementation.
+ */
+export class P2PClient implements P2P {
+  /**
+   * L2 Block download that p2p client uses to stay in sync with latest blocks.
+   */
+  private blockDownloader: L2BlockDownloader;
+
+  /**
+   * Property that indicates whether the client is running.
+   */
+  private stopping = false;
+
+  /**
+   * The JS promise that will be running to keep the client's data in sync. Can be interrupted if the client is stopped.
+   */
+  private runningPromise!: Promise<void>;
+
+  private currentState = P2PClientState.IDLE;
+  private syncPromise = Promise.resolve();
+  private latestBlockNumberAtStart = -1;
+  private syncResolve?: () => void = undefined;
+  private synchedBlockNumber: AztecSingleton<number>;
+
+  /**
+   * In-memory P2P client constructor.
+   * @param store - The client's instance of the KV store.
+   * @param l2BlockSource - P2P client's source for fetching existing blocks.
+   * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
+   * @param p2pService - The concrete instance of p2p networking to use.
+   * @param log - A logger.
+   */
+  constructor(
+    store: AztecKVStore,
+    private l2BlockSource: L2BlockSource,
+    private txPool: TxPool,
+    private p2pService: P2PService,
+    private log = createDebugLogger('aztec:p2p'),
+  ) {
+    const { p2pBlockCheckIntervalMS: checkInterval, p2pL2QueueSize } = getP2PConfigEnvVars();
+    this.blockDownloader = new L2BlockDownloader(l2BlockSource, p2pL2QueueSize, checkInterval);
+    this.synchedBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+  }
+
+  /**
+   * Starts the P2P client.
+   * @returns An empty promise signalling the synching process.
+   */
+  public async start() {
+    if (this.currentState === P2PClientState.STOPPED) {
+      throw new Error('P2P client already stopped');
+    }
+    if (this.currentState !== P2PClientState.IDLE) {
+      return this.syncPromise;
+    }
+
+    // get the current latest block number
+    this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+
+    const blockToDownloadFrom = this.getSyncedBlockNum() + 1;
+
+    // if there are blocks to be retrieved, go to a synching state
+    if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
+      this.setCurrentState(P2PClientState.SYNCHING);
+      this.syncPromise = new Promise(resolve => {
+        this.syncResolve = resolve;
+      });
+      this.log(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
+    } else {
+      // if no blocks to be retrieved, go straight to running
+      this.setCurrentState(P2PClientState.RUNNING);
+      this.syncPromise = Promise.resolve();
+      await this.p2pService.start();
+      this.log(`Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`);
+    }
+
+    // publish any txs in TxPool after its doing initial sync
+    this.syncPromise = this.syncPromise.then(() => this.publishStoredTxs());
+
+    // start looking for further blocks
+    const blockProcess = async () => {
+      while (!this.stopping) {
+        const blocks = await this.blockDownloader.getBlocks();
+        await this.handleL2Blocks(blocks);
+      }
+    };
+    this.runningPromise = blockProcess();
+    this.blockDownloader.start(blockToDownloadFrom);
+    this.log(`Started block downloader from block ${blockToDownloadFrom}`);
+
+    return this.syncPromise;
+  }
+
+  /**
+   * Allows consumers to stop the instance of the P2P client.
+   * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+   */
+  public async stop() {
+    this.log('Stopping p2p client...');
+    this.stopping = true;
+    await this.p2pService.stop();
+    this.log('Stopped p2p service');
+    await this.blockDownloader.stop();
+    this.log('Stopped block downloader');
+    await this.runningPromise;
+    this.setCurrentState(P2PClientState.STOPPED);
+    this.log('P2P client stopped...');
+  }
+
+  /**
+   * Returns all transactions in the transaction pool.
+   * @returns An array of Txs.
+   */
+  public getTxs(): Promise<Tx[]> {
+    return Promise.resolve(this.txPool.getAllTxs());
+  }
+
+  /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash - Hash of the transaction to look for in the pool.
+   * @returns A single tx or undefined.
+   */
+  getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    return Promise.resolve(this.txPool.getTxByHash(txHash));
+  }
+
+  /**
+   * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+   * @param tx - The tx to verify.
+   * @returns Empty promise.
+   **/
+  public async sendTx(tx: Tx): Promise<void> {
+    const ready = await this.isReady();
+    if (!ready) {
+      throw new Error('P2P client not ready');
+    }
+    await this.txPool.addTxs([tx]);
+    this.p2pService.propagateTx(tx);
+  }
+
+  /**
+   * Deletes the 'txs' from the pool.
+   * NOT used if we use sendTx as reconcileTxPool will handle this.
+   * @param txHashes - Hashes of the transactions to delete.
+   * @returns Empty promise.
+   **/
+  public async deleteTxs(txHashes: TxHash[]): Promise<void> {
+    const ready = await this.isReady();
+    if (!ready) {
+      throw new Error('P2P client not ready');
+    }
+    await this.txPool.deleteTxs(txHashes);
+  }
+
+  /**
+   * Public function to check if the p2p client is fully synced and ready to receive txs.
+   * @returns True if the P2P client is ready to receive txs.
+   */
+  public isReady() {
+    return Promise.resolve(this.currentState === P2PClientState.RUNNING);
+  }
+
+  /**
+   * Public function to check the latest block number that the P2P client is synced to.
+   * @returns Block number of latest L2 Block we've synced with.
+   */
+  public getSyncedBlockNum() {
+    return this.synchedBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
+  }
+
+  /**
+   * Method to check the status the p2p client.
+   * @returns Information about p2p client status: state & syncedToBlockNum.
+   */
+  public getStatus(): Promise<P2PSyncState> {
+    return Promise.resolve({
+      state: this.currentState,
+      syncedToL2Block: this.getSyncedBlockNum(),
+    } as P2PSyncState);
+  }
+
+  /**
+   * Internal method that uses the provided blocks to check against the client's tx pool.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */
+  private async reconcileTxPool(blocks: L2Block[]): Promise<void> {
+    for (let i = 0; i < blocks.length; i++) {
+      const blockContext = new L2BlockContext(blocks[i]);
+      const txHashes = blockContext.getTxHashes();
+      await this.txPool.deleteTxs(txHashes);
+      this.p2pService.settledTxs(txHashes);
+    }
+  }
+
+  /**
+   * Method for processing new blocks.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */
+  private async handleL2Blocks(blocks: L2Block[]): Promise<void> {
+    if (!blocks.length) {
+      return Promise.resolve();
+    }
+    await this.reconcileTxPool(blocks);
+    const lastBlockNum = blocks[blocks.length - 1].number;
+    await this.synchedBlockNumber.set(lastBlockNum);
+    this.log(`Synched to block ${lastBlockNum}`);
+
+    if (this.currentState === P2PClientState.SYNCHING && lastBlockNum >= this.latestBlockNumberAtStart) {
+      this.setCurrentState(P2PClientState.RUNNING);
+      if (this.syncResolve !== undefined) {
+        this.syncResolve();
+        await this.p2pService.start();
+      }
+    }
+  }
+
+  /**
+   * Method to set the value of the current state.
+   * @param newState - New state value.
+   */
+  private setCurrentState(newState: P2PClientState) {
+    this.currentState = newState;
+    this.log(`Moved to state ${P2PClientState[this.currentState]}`);
+  }
+
+  private async publishStoredTxs() {
+    if (!this.isReady()) {
+      return;
+    }
+
+    const txs = this.txPool.getAllTxs();
+    if (txs.length > 0) {
+      this.log(`Publishing ${txs.length} previously stored txs`);
+      await Promise.all(txs.map(tx => this.p2pService.propagateTx(tx)));
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,113 @@
+/**
+ * P2P client configuration values.
+ */
+export interface P2PConfig {
+  /**
+   * A flag dictating whether the P2P subsystem should be enabled.
+   */
+  p2pEnabled: boolean;
+
+  /**
+   * The frequency in which to check.
+   */
+  p2pBlockCheckIntervalMS: number;
+
+  /**
+   * Size of queue of L2 blocks to store.
+   */
+  p2pL2QueueSize: number;
+
+  /**
+   * The tcp port on which the P2P service should listen for connections.
+   */
+  tcpListenPort: number;
+
+  /**
+   * The tcp IP on which the P2P service should listen for connections.
+   */
+  tcpListenIp: 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[];
+
+  /**
+   * Protocol identifier for transaction gossiping.
+   */
+  transactionProtocol: string;
+
+  /**
+   * Hostname to announce.
+   */
+  announceHostname?: string;
+
+  /**
+   * Port to announce.
+   */
+  announcePort?: number;
+
+  /**
+   * Optional specification to run as a client in the Kademlia routing protocol.
+   */
+  clientKADRouting: boolean;
+
+  /**
+   * Whether to enable NAT from libp2p (ignored for bootstrap node).
+   */
+  enableNat?: boolean;
+
+  /**
+   * The minimum number of peers (a peer count below this will cause the node to look for more peers)
+   */
+  minPeerCount: number;
+
+  /**
+   * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
+   */
+  maxPeerCount: number;
+}
+
+/**
+ * Gets the config values for p2p client from environment variables.
+ * @returns The config values for p2p client.
+ */
+export function getP2PConfigEnvVars(): P2PConfig {
+  const {
+    P2P_ENABLED,
+    P2P_BLOCK_CHECK_INTERVAL_MS,
+    P2P_L2_BLOCK_QUEUE_SIZE,
+    P2P_TCP_LISTEN_PORT,
+    P2P_TCP_LISTEN_IP,
+    PEER_ID_PRIVATE_KEY,
+    BOOTSTRAP_NODES,
+    P2P_ANNOUNCE_HOSTNAME,
+    P2P_ANNOUNCE_PORT,
+    P2P_KAD_CLIENT,
+    P2P_NAT_ENABLED,
+    P2P_MIN_PEERS,
+    P2P_MAX_PEERS,
+  } = process.env;
+  const envVars: P2PConfig = {
+    p2pEnabled: P2P_ENABLED === 'true',
+    p2pBlockCheckIntervalMS: P2P_BLOCK_CHECK_INTERVAL_MS ? +P2P_BLOCK_CHECK_INTERVAL_MS : 100,
+    p2pL2QueueSize: P2P_L2_BLOCK_QUEUE_SIZE ? +P2P_L2_BLOCK_QUEUE_SIZE : 1000,
+    tcpListenPort: P2P_TCP_LISTEN_PORT ? +P2P_TCP_LISTEN_PORT : 40400,
+    tcpListenIp: P2P_TCP_LISTEN_IP ? P2P_TCP_LISTEN_IP : '0.0.0.0',
+    peerIdPrivateKey: PEER_ID_PRIVATE_KEY,
+    bootstrapNodes: BOOTSTRAP_NODES ? BOOTSTRAP_NODES.split(',') : [],
+    transactionProtocol: '',
+    announceHostname: P2P_ANNOUNCE_HOSTNAME,
+    announcePort: P2P_ANNOUNCE_PORT ? +P2P_ANNOUNCE_PORT : undefined,
+    clientKADRouting: P2P_KAD_CLIENT === 'true',
+    enableNat: P2P_NAT_ENABLED === 'true',
+    minPeerCount: P2P_MIN_PEERS ? +P2P_MIN_PEERS : 10,
+    maxPeerCount: P2P_MAX_PEERS ? +P2P_MAX_PEERS : 100,
+  };
+  return envVars;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './client/index.js';
+export * from './config.js';
+export * from './tx_pool/index.js';
+export * from './service/index.js';
+export * from './bootstrap/bootstrap.js';

package/src/service/dummy_service.ts

@@ -0,0 +1,36 @@
+import { Tx, TxHash } from '@aztec/circuit-types';
+
+import { P2PService } from './service.js';
+
+/**
+ * A dummy implementation of the P2P Service.
+ */
+export class DummyP2PService implements P2PService {
+  /**
+   * Starts the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public start() {
+    return Promise.resolve();
+  }
+
+  /**
+   * Stops the dummy implementation.
+   * @returns A resolved promise.
+   */
+  public stop() {
+    return Promise.resolve();
+  }
+
+  /**
+   * Called to have the given transaction propagated through the P2P network.
+   * @param _ - The transaction to be propagated.
+   */
+  public propagateTx(_: Tx) {}
+
+  /**
+   * Called upon receipt of settled transactions.
+   * @param _ - The hashes of the settled transactions.
+   */
+  public settledTxs(_: TxHash[]) {}
+}

package/src/service/index.ts

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './libp2p_service.js';

package/src/service/known_txs.ts

@@ -0,0 +1,56 @@
+import { PeerId } from '@libp2p/interface-peer-id';
+
+/**
+ * Keeps a record of which Peers have 'seen' which transactions.
+ */
+export class KnownTxLookup {
+  private lookup: { [key: string]: { [key: string]: boolean } } = {};
+
+  constructor() {}
+
+  /**
+   * Inform this lookup that a peer has 'seen' a transaction.
+   * @param peerId - The peerId of the peer that has 'seen' the transaction.
+   * @param txHash - The thHash of the 'seen' transaction.
+   */
+  public addPeerForTx(peerId: PeerId, txHash: string) {
+    const peerIdAsString = peerId.toString();
+    const existingLookup = this.lookup[txHash];
+    if (existingLookup === undefined) {
+      const newLookup: { [key: string]: boolean } = {};
+      newLookup[peerIdAsString] = true;
+      this.lookup[txHash] = newLookup;
+      return;
+    }
+    existingLookup[peerIdAsString] = true;
+  }
+
+  /**
+   * Determine if a peer has 'seen' a transaction.
+   * @param peerId - The peerId of the peer.
+   * @param txHash - The thHash of the transaction.
+   * @returns A boolean indicating if the transaction has been 'seen' by the peer.
+   */
+  public hasPeerSeenTx(peerId: PeerId, txHash: string) {
+    const existingLookup = this.lookup[txHash];
+    if (existingLookup === undefined) {
+      return false;
+    }
+    const peerIdAsString = peerId.toString();
+    return !!existingLookup[peerIdAsString];
+  }
+
+  /**
+   * Updates the lookup from the result of settled txs
+   * These txs will be cleared out of the lookup.
+   * It is possible that some txs could still be gossiped for a
+   * short period of time meaning they come back into this lookup
+   * but this should be infrequent and cause no undesirable effects
+   * @param txHashes - The hashes of the newly settled transactions
+   */
+  public handleSettledTxs(txHashes: string[]) {
+    for (const txHash of txHashes) {
+      delete this.lookup[txHash];
+    }
+  }
+}