@aztec/p2p 0.0.0-test.0

package/src/mem_pools/instrumentation.ts

@@ -0,0 +1,126 @@
+import type { Gossipable } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  type Histogram,
+  LmdbMetrics,
+  type LmdbStatsCallback,
+  Metrics,
+  type MetricsType,
+  type TelemetryClient,
+  type UpDownCounter,
+} from '@aztec/telemetry-client';
+
+export enum PoolName {
+  TX_POOL = 'TxPool',
+  ATTESTATION_POOL = 'AttestationPool',
+}
+
+type MetricsLabels = {
+  objectInMempool: MetricsType;
+  objectSize: MetricsType;
+};
+
+/**
+ * Get the metrics labels for a given pool name.
+ * They must all have different names, as if duplicates appear, it will brick
+ * the metrics instance
+ */
+function getMetricsLabels(name: PoolName): MetricsLabels {
+  if (name === PoolName.TX_POOL) {
+    return {
+      objectInMempool: Metrics.MEMPOOL_TX_COUNT,
+      objectSize: Metrics.MEMPOOL_TX_SIZE,
+    };
+  } else if (name === PoolName.ATTESTATION_POOL) {
+    return {
+      objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
+      objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
+    };
+  }
+
+  throw new Error('Invalid pool type');
+}
+
+/**
+ * Instrumentation class for the Pools (TxPool, AttestationPool, etc).
+ */
+export class PoolInstrumentation<PoolObject extends Gossipable> {
+  /** The number of txs in the mempool */
+  private objectsInMempool: UpDownCounter;
+  /** Tracks tx size */
+  private objectSize: Histogram;
+
+  private dbMetrics: LmdbMetrics;
+
+  private defaultAttributes;
+
+  constructor(telemetry: TelemetryClient, name: PoolName, dbStats?: LmdbStatsCallback) {
+    const meter = telemetry.getMeter(name);
+    this.defaultAttributes = { [Attributes.POOL_NAME]: name };
+
+    const metricsLabels = getMetricsLabels(name);
+
+    this.objectsInMempool = meter.createUpDownCounter(metricsLabels.objectInMempool, {
+      description: 'The current number of transactions in the mempool',
+    });
+
+    this.objectSize = meter.createHistogram(metricsLabels.objectSize, {
+      unit: 'By',
+      description: 'The size of transactions in the mempool',
+    });
+
+    this.dbMetrics = new LmdbMetrics(
+      meter,
+      {
+        [Attributes.DB_DATA_TYPE]: 'tx-pool',
+      },
+      dbStats,
+    );
+  }
+
+  public recordSize(poolObject: PoolObject) {
+    this.objectSize.record(poolObject.getSize());
+  }
+
+  /**
+   * Updates the metrics with the new objects.
+   * @param txs - The objects to record
+   */
+  public recordAddedObjects(count = 1, status?: string) {
+    if (count < 0) {
+      throw new Error('Count must be positive');
+    }
+    if (count === 0) {
+      return;
+    }
+    const attributes = status
+      ? {
+          ...this.defaultAttributes,
+          [Attributes.STATUS]: status,
+        }
+      : this.defaultAttributes;
+
+    this.objectsInMempool.add(count, attributes);
+  }
+
+  /**
+   * Updates the metrics by removing objects from the mempool.
+   * @param count - The number of objects to remove from the mempool
+   */
+  public recordRemovedObjects(count = 1, status?: string) {
+    if (count < 0) {
+      throw new Error('Count must be positive');
+    }
+    if (count === 0) {
+      return;
+    }
+
+    const attributes = status
+      ? {
+          ...this.defaultAttributes,
+          [Attributes.STATUS]: status,
+        }
+      : this.defaultAttributes;
+    this.objectsInMempool.add(-1 * count, attributes);
+  }
+}

package/src/mem_pools/interface.ts

@@ -0,0 +1,12 @@
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+
+import type { AttestationPool } from './attestation_pool/attestation_pool.js';
+import type { TxPool } from './tx_pool/tx_pool.js';
+
+/**
+ * A interface the combines all mempools
+ */
+export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
+  txPool: TxPool;
+  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+};

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -0,0 +1,309 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { getPendingTxPriority } from './priority.js';
+import type { TxPool } from './tx_pool.js';
+
+/**
+ * KV implementation of the Transaction Pool.
+ */
+export class AztecKVTxPool implements TxPool {
+  #store: AztecAsyncKVStore;
+
+  /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */
+  #txs: AztecAsyncMap<string, Buffer>;
+
+  /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
+  #minedTxHashToBlock: AztecAsyncMap<string, number>;
+
+  /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
+  #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
+
+  /** KV store for archived txs. */
+  #archive: AztecAsyncKVStore;
+
+  /** Archived txs map for future lookup. */
+  #archivedTxs: AztecAsyncMap<string, Buffer>;
+
+  /** Indexes of the archived txs by insertion order. */
+  #archivedTxIndices: AztecAsyncMap<number, string>;
+
+  /** Number of txs to archive. */
+  #archivedTxLimit: number;
+
+  #log: Logger;
+
+  #metrics: PoolInstrumentation<Tx>;
+
+  /**
+   * Class constructor for KV TxPool. Initiates our transaction pool as an AztecMap.
+   * @param store - A KV store for live txs in the pool.
+   * @param archive - A KV store for archived txs.
+   * @param telemetry - A telemetry client.
+   * @param archivedTxLimit - The number of txs to archive.
+   * @param log - A logger.
+   */
+  constructor(
+    store: AztecAsyncKVStore,
+    archive: AztecAsyncKVStore,
+    telemetry: TelemetryClient = getTelemetryClient(),
+    archivedTxLimit: number = 0,
+    log = createLogger('p2p:tx_pool'),
+  ) {
+    this.#txs = store.openMap('txs');
+    this.#minedTxHashToBlock = store.openMap('txHashToBlockMined');
+    this.#pendingTxPriorityToHash = store.openMultiMap('pendingTxFeeToHash');
+
+    this.#archivedTxs = archive.openMap('archivedTxs');
+    this.#archivedTxIndices = archive.openMap('archivedTxIndices');
+    this.#archivedTxLimit = archivedTxLimit;
+
+    this.#store = store;
+    this.#archive = archive;
+    this.#log = log;
+    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
+  }
+
+  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    let deletedPending = 0;
+    return this.#store.transactionAsync(async () => {
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        await this.#minedTxHashToBlock.set(key, blockNumber);
+
+        const tx = await this.getTxByHash(hash);
+        if (tx) {
+          deletedPending++;
+          const fee = getPendingTxPriority(tx);
+          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
+        }
+      }
+      this.#metrics.recordAddedObjects(txHashes.length, 'mined');
+      this.#metrics.recordRemovedObjects(deletedPending, 'pending');
+    });
+  }
+
+  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    let markedAsPending = 0;
+    return this.#store.transactionAsync(async () => {
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        await this.#minedTxHashToBlock.delete(key);
+
+        const tx = await this.getTxByHash(hash);
+        if (tx) {
+          await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+          markedAsPending++;
+        }
+      }
+
+      this.#metrics.recordAddedObjects(markedAsPending, 'pending');
+      this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
+    });
+  }
+
+  public async getPendingTxHashes(): Promise<TxHash[]> {
+    const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({ reverse: true }));
+    return vals.map(x => TxHash.fromString(x));
+  }
+
+  public async getMinedTxHashes(): Promise<[TxHash, number][]> {
+    const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
+    return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
+  }
+
+  public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+    const key = txHash.toString();
+    const [isMined, isKnown] = await Promise.all([this.#minedTxHashToBlock.hasAsync(key), this.#txs.hasAsync(key)]);
+
+    if (isMined) {
+      return 'mined';
+    } else if (isKnown) {
+      return 'pending';
+    } else {
+      return undefined;
+    }
+  }
+
+  /**
+   * Checks if a transaction exists in the pool and returns it.
+   * @param txHash - The generated tx hash.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */
+  public async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#txs.getAsync(txHash.toString());
+    if (buffer) {
+      const tx = Tx.fromBuffer(buffer);
+      tx.setTxHash(txHash);
+      return tx;
+    }
+    return undefined;
+  }
+
+  /**
+   * Checks if an archived tx exists and returns it.
+   * @param txHash - The tx hash.
+   * @returns The transaction metadata, if found, 'undefined' otherwise.
+   */
+  public async getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#archivedTxs.getAsync(txHash.toString());
+    if (buffer) {
+      const tx = Tx.fromBuffer(buffer);
+      tx.setTxHash(txHash);
+      return tx;
+    }
+    return undefined;
+  }
+
+  /**
+   * Adds a list of transactions to the pool. Duplicates are ignored.
+   * @param txs - An array of txs to be added to the pool.
+   * @returns Empty promise.
+   */
+  public async addTxs(txs: Tx[]): Promise<void> {
+    const hashesAndStats = await Promise.all(
+      txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
+    );
+    await this.#store.transactionAsync(async () => {
+      let pendingCount = 0;
+      await Promise.all(
+        txs.map(async (tx, i) => {
+          const { txHash, txStats } = hashesAndStats[i];
+          this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
+            eventName: 'tx-added-to-pool',
+            ...txStats,
+          } satisfies TxAddedToPoolStats);
+
+          const key = txHash.toString();
+          await this.#txs.set(key, tx.toBuffer());
+
+          if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
+            pendingCount++;
+            // REFACTOR: Use an lmdb conditional write to avoid race conditions with this write tx
+            await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), key);
+            this.#metrics.recordSize(tx);
+          }
+        }),
+      );
+
+      this.#metrics.recordAddedObjects(pendingCount, 'pending');
+    });
+  }
+
+  /**
+   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
+   * @param txHashes - An array of tx hashes to be removed from the tx pool.
+   * @returns Empty promise.
+   */
+  public deleteTxs(txHashes: TxHash[]): Promise<void> {
+    let pendingDeleted = 0;
+    let minedDeleted = 0;
+
+    const deletedTxs: Tx[] = [];
+    const poolDbTx = this.#store.transactionAsync(async () => {
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        const tx = await this.getTxByHash(hash);
+
+        if (tx) {
+          const fee = getPendingTxPriority(tx);
+          await this.#pendingTxPriorityToHash.deleteValue(fee, key);
+
+          const isMined = await this.#minedTxHashToBlock.hasAsync(key);
+          if (isMined) {
+            minedDeleted++;
+          } else {
+            pendingDeleted++;
+          }
+
+          if (this.#archivedTxLimit) {
+            deletedTxs.push(tx);
+          }
+
+          await this.#txs.delete(key);
+          await this.#minedTxHashToBlock.delete(key);
+        }
+      }
+
+      this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
+      this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
+    });
+
+    return this.#archivedTxLimit ? poolDbTx.then(() => this.archiveTxs(deletedTxs)) : poolDbTx;
+  }
+
+  /**
+   * Gets all the transactions stored in the pool.
+   * @returns Array of tx objects in the order they were added to the pool.
+   */
+  public async getAllTxs(): Promise<Tx[]> {
+    const vals = await toArray(this.#txs.entriesAsync());
+    return vals.map(([hash, buffer]) => {
+      const tx = Tx.fromBuffer(buffer);
+      tx.setTxHash(TxHash.fromString(hash));
+      return tx;
+    });
+  }
+
+  /**
+   * Gets the hashes of all transactions currently in the tx pool.
+   * @returns An array of transaction hashes found in the tx pool.
+   */
+  public async getAllTxHashes(): Promise<TxHash[]> {
+    const vals = await toArray(this.#txs.keysAsync());
+    return vals.map(x => TxHash.fromString(x));
+  }
+
+  /**
+   * Archives a list of txs for future reference. The number of archived txs is limited by the specified archivedTxLimit.
+   * @param txs - The list of transactions to archive.
+   * @returns Empty promise.
+   */
+  private async archiveTxs(txs: Tx[]): Promise<void> {
+    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    await this.#archive.transactionAsync(async () => {
+      // calcualte the head and tail indices of the archived txs by insertion order.
+      let headIdx =
+        ((await this.#archivedTxIndices.entriesAsync({ limit: 1, reverse: true }).next()).value?.[0] ?? -1) + 1;
+      let tailIdx = (await this.#archivedTxIndices.entriesAsync({ limit: 1 }).next()).value?.[0] ?? 0;
+
+      for (let i = 0; i < txs.length; i++) {
+        const tx = txs[i];
+        while (headIdx - tailIdx >= this.#archivedTxLimit) {
+          const txHash = await this.#archivedTxIndices.getAsync(tailIdx);
+          if (txHash) {
+            await this.#archivedTxs.delete(txHash);
+            await this.#archivedTxIndices.delete(tailIdx);
+          }
+          tailIdx++;
+        }
+
+        const archivedTx: Tx = new Tx(
+          tx.data,
+          ClientIvcProof.empty(),
+          tx.contractClassLogs,
+          tx.enqueuedPublicFunctionCalls,
+          tx.publicTeardownFunctionCall,
+        );
+        const txHash = txHashes[i].toString();
+        await this.#archivedTxs.set(txHash, archivedTx.toBuffer());
+        await this.#archivedTxIndices.set(headIdx, txHash);
+        headIdx++;
+      }
+    });
+  }
+}

package/src/mem_pools/tx_pool/index.ts

@@ -0,0 +1,3 @@
+export * from './tx_pool.js';
+export * from './memory_tx_pool.js';
+export * from './aztec_kv_tx_pool.js';

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -0,0 +1,174 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { getPendingTxPriority } from './priority.js';
+import type { TxPool } from './tx_pool.js';
+
+/**
+ * In-memory implementation of the Transaction Pool.
+ */
+export class InMemoryTxPool implements TxPool {
+  /**
+   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
+   */
+  private txs: Map<bigint, Tx>;
+  private minedTxs: Map<bigint, number>;
+  private pendingTxs: Set<bigint>;
+
+  private metrics: PoolInstrumentation<Tx>;
+
+  /**
+   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
+   * @param log - A logger.
+   */
+  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:tx_pool')) {
+    this.txs = new Map<bigint, Tx>();
+    this.minedTxs = new Map();
+    this.pendingTxs = new Set();
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+  }
+
+  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+    const keys = txHashes.map(x => x.toBigInt());
+    for (const key of keys) {
+      this.minedTxs.set(key, blockNumber);
+      this.pendingTxs.delete(key);
+    }
+    this.metrics.recordRemovedObjects(txHashes.length, 'pending');
+    this.metrics.recordAddedObjects(txHashes.length, 'mined');
+    return Promise.resolve();
+  }
+
+  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
+
+    const keys = txHashes.map(x => x.toBigInt());
+    let deleted = 0;
+    let added = 0;
+    for (const key of keys) {
+      if (this.minedTxs.delete(key)) {
+        deleted++;
+      }
+
+      // only add back to the pending set if we have the tx object
+      if (this.txs.has(key)) {
+        added++;
+        this.pendingTxs.add(key);
+      }
+    }
+
+    this.metrics.recordRemovedObjects(deleted, 'mined');
+    this.metrics.recordAddedObjects(added, 'pending');
+
+    return Promise.resolve();
+  }
+
+  public async getPendingTxHashes(): Promise<TxHash[]> {
+    const txs = (await this.getAllTxs()).sort(
+      (tx1, tx2) => -getPendingTxPriority(tx1).localeCompare(getPendingTxPriority(tx2)),
+    );
+    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    return txHashes.filter(txHash => this.pendingTxs.has(txHash.toBigInt()));
+  }
+
+  public getMinedTxHashes(): Promise<[TxHash, number][]> {
+    return Promise.resolve(
+      Array.from(this.minedTxs.entries()).map(([txHash, blockNumber]) => [TxHash.fromBigInt(txHash), blockNumber]),
+    );
+  }
+
+  public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+    const key = txHash.toBigInt();
+    if (this.pendingTxs.has(key)) {
+      return Promise.resolve('pending');
+    }
+    if (this.minedTxs.has(key)) {
+      return Promise.resolve('mined');
+    }
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * Checks if a transaction exists in the pool and returns it.
+   * @param txHash - The generated tx hash.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */
+  public getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const result = this.txs.get(txHash.toBigInt());
+    return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
+  }
+
+  public getArchivedTxByHash(): Promise<Tx | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  /**
+   * Adds a list of transactions to the pool. Duplicates are ignored.
+   * @param txs - An array of txs to be added to the pool.
+   * @returns Empty promise.
+   */
+  public async addTxs(txs: Tx[]): Promise<void> {
+    let pending = 0;
+    for (const tx of txs) {
+      const txHash = await tx.getTxHash();
+      this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
+        eventName: 'tx-added-to-pool',
+        ...(await tx.getStats()),
+      } satisfies TxAddedToPoolStats);
+
+      const key = txHash.toBigInt();
+      this.txs.set(key, tx);
+      if (!this.minedTxs.has(key)) {
+        pending++;
+        this.metrics.recordSize(tx);
+        this.pendingTxs.add(key);
+      }
+    }
+
+    this.metrics.recordAddedObjects(pending, 'pending');
+    return;
+  }
+
+  /**
+   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
+   * @param txHashes - An array of tx hashes to be removed from the tx pool.
+   * @returns The number of transactions that was deleted from the pool.
+   */
+  public deleteTxs(txHashes: TxHash[]): Promise<void> {
+    let deletedMined = 0;
+    let deletedPending = 0;
+
+    for (const txHash of txHashes) {
+      const key = txHash.toBigInt();
+      this.txs.delete(key);
+      deletedPending += this.pendingTxs.delete(key) ? 1 : 0;
+      deletedMined += this.minedTxs.delete(key) ? 1 : 0;
+    }
+
+    this.metrics.recordRemovedObjects(deletedPending, 'pending');
+    this.metrics.recordRemovedObjects(deletedMined, 'mined');
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Gets all the transactions stored in the pool.
+   * @returns Array of tx objects in the order they were added to the pool.
+   */
+  public getAllTxs(): Promise<Tx[]> {
+    return Promise.resolve(Array.from(this.txs.values()).map(x => Tx.clone(x)));
+  }
+
+  /**
+   * Gets the hashes of all transactions currently in the tx pool.
+   * @returns An array of transaction hashes found in the tx pool.
+   */
+  public getAllTxHashes(): Promise<TxHash[]> {
+    return Promise.resolve(Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x)));
+  }
+}

package/src/mem_pools/tx_pool/priority.ts

@@ -0,0 +1,13 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import type { Tx } from '@aztec/stdlib/tx';
+
+/**
+ * Returns a string representing the priority of a tx.
+ * Txs with a higher priority value are returned first when retrieving pending tx hashes.
+ * We currently use the sum of the priority fees for the tx for this value, represented as hex.
+ */
+export function getPendingTxPriority(tx: Tx): string {
+  const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
+  const totalFees = priorityFees.feePerDaGas.toBigInt() + priorityFees.feePerL2Gas.toBigInt();
+  return Buffer32.fromBigInt(totalFees).toString();
+}