@aztec/p2p 0.23.0 → 0.26.1

package/src/tx_pool/aztec_kv_tx_pool.ts

@@ -0,0 +1,99 @@
+import { Tx, TxHash } from '@aztec/circuit-types';
+import { TxAddedToPoolStats } from '@aztec/circuit-types/stats';
+import { Logger, createDebugLogger } from '@aztec/foundation/log';
+import { AztecKVStore, AztecMap } from '@aztec/kv-store';
+
+import { TxPool } from './tx_pool.js';
+
+/**
+ * In-memory implementation of the Transaction Pool.
+ */
+export class AztecKVTxPool implements TxPool {
+  #store: AztecKVStore;
+
+  /**
+   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
+   */
+  #txs: AztecMap<string, Buffer>;
+
+  #log: Logger;
+
+  /**
+   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
+   * @param store - A KV store.
+   * @param log - A logger.
+   */
+  constructor(store: AztecKVStore, log = createDebugLogger('aztec:tx_pool')) {
+    this.#txs = store.openMap('txs');
+    this.#store = store;
+    this.#log = log;
+  }
+
+  /**
+   * 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): Tx | undefined {
+    const buffer = this.#txs.get(txHash.toString());
+    return buffer ? Tx.fromBuffer(buffer) : 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 txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    return this.#store.transaction(() => {
+      for (const [i, tx] of txs.entries()) {
+        const txHash = txHashes[i];
+        this.#log.info(`Adding tx with id ${txHash.toString()}`, {
+          eventName: 'tx-added-to-pool',
+          ...tx.getStats(),
+        } satisfies TxAddedToPoolStats);
+
+        void this.#txs.set(txHash.toString(), tx.toBuffer());
+      }
+    });
+  }
+
+  /**
+   * 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> {
+    return this.#store.transaction(() => {
+      for (const hash of txHashes) {
+        void this.#txs.delete(hash.toString());
+      }
+    });
+  }
+
+  /**
+   * Gets all the transactions stored in the pool.
+   * @returns Array of tx objects in the order they were added to the pool.
+   */
+  public getAllTxs(): Tx[] {
+    return Array.from(this.#txs.values()).map(buffer => Tx.fromBuffer(buffer));
+  }
+
+  /**
+   * Gets the hashes of all transactions currently in the tx pool.
+   * @returns An array of transaction hashes found in the tx pool.
+   */
+  public getAllTxHashes(): TxHash[] {
+    return Array.from(this.#txs.keys()).map(x => TxHash.fromString(x));
+  }
+
+  /**
+   * Returns a boolean indicating if the transaction is present in the pool.
+   * @param txHash - The hash of the transaction to be queried.
+   * @returns True if the transaction present, false otherwise.
+   */
+  public hasTx(txHash: TxHash): boolean {
+    return this.#txs.has(txHash.toString());
+  }
+}

package/src/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/tx_pool/memory_tx_pool.ts

@@ -0,0 +1,87 @@
+import { Tx, TxHash } from '@aztec/circuit-types';
+import { TxAddedToPoolStats } from '@aztec/circuit-types/stats';
+import { createDebugLogger } from '@aztec/foundation/log';
+
+import { 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>;
+
+  /**
+   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
+   * @param log - A logger.
+   */
+  constructor(private log = createDebugLogger('aztec:tx_pool')) {
+    this.txs = new Map<bigint, Tx>();
+  }
+
+  /**
+   * 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): Tx | undefined {
+    const result = this.txs.get(txHash.toBigInt());
+    return result === undefined ? undefined : Tx.clone(result);
+  }
+
+  /**
+   * 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 addTxs(txs: Tx[]): Promise<void> {
+    for (const tx of txs) {
+      const txHash = tx.getTxHash();
+      this.log(`Adding tx with id ${txHash.toString()}`, {
+        eventName: 'tx-added-to-pool',
+        ...tx.getStats(),
+      } satisfies TxAddedToPoolStats);
+      this.txs.set(txHash.toBigInt(), tx);
+    }
+    return Promise.resolve();
+  }
+
+  /**
+   * 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> {
+    for (const txHash of txHashes) {
+      this.txs.delete(txHash.toBigInt());
+    }
+    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(): Tx[] {
+    return 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(): TxHash[] {
+    return Array.from(this.txs.keys()).map(x => TxHash.fromBigInt(x));
+  }
+
+  /**
+   * Returns a boolean indicating if the transaction is present in the pool.
+   * @param txHash - The hash of the transaction to be queried.
+   * @returns True if the transaction present, false otherwise.
+   */
+  public hasTx(txHash: TxHash): boolean {
+    return this.txs.has(txHash.toBigInt());
+  }
+}

package/src/tx_pool/tx_pool.ts

@@ -0,0 +1,44 @@
+import { Tx, TxHash } from '@aztec/circuit-types';
+
+/**
+ * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
+ */
+export interface TxPool {
+  /**
+   * Adds a list of transactions to the pool. Duplicates are ignored.
+   * @param txs - An array of txs to be added to the pool.
+   */
+  addTxs(txs: Tx[]): Promise<void>;
+
+  /**
+   * Checks if a transaction exists in the pool and returns it.
+   * @param txHash - The hash of the transaction, used as an ID.
+   * @returns The transaction, if found, 'undefined' otherwise.
+   */
+  getTxByHash(txHash: TxHash): Tx | undefined;
+
+  /**
+   * 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.
+   */
+  deleteTxs(txHashes: TxHash[]): Promise<void>;
+
+  /**
+   * Gets all transactions currently in the tx pool.
+   * @returns An array of transaction objects found in the tx pool.
+   */
+  getAllTxs(): Tx[];
+
+  /**
+   * Gets the hashes of all transactions currently in the tx pool.
+   * @returns An array of transaction hashes found in the tx pool.
+   */
+  getAllTxHashes(): TxHash[];
+
+  /**
+   * Returns a boolean indicating if the transaction is present in the pool.
+   * @param txHash - The hash of the transaction to be queried.
+   * @returns True if the transaction present, false otherwise.
+   */
+  hasTx(txHash: TxHash): boolean;
+}

package/src/tx_pool/tx_pool_test_suite.ts

@@ -0,0 +1,57 @@
+import { mockTx } from '@aztec/circuit-types';
+
+import { TxPool } from './tx_pool.js';
+
+/**
+ * Tests a TxPool implementation.
+ * @param getTxPool - Gets a fresh TxPool
+ */
+export function describeTxPool(getTxPool: () => TxPool) {
+  let pool: TxPool;
+
+  beforeEach(() => {
+    pool = getTxPool();
+  });
+
+  it('Adds txs to the pool', async () => {
+    const tx1 = mockTx();
+
+    await pool.addTxs([tx1]);
+    const poolTx = pool.getTxByHash(tx1.getTxHash());
+    expect(poolTx!.getTxHash()).toEqual(tx1.getTxHash());
+  });
+
+  it('Removes txs from the pool', async () => {
+    const tx1 = mockTx();
+
+    await pool.addTxs([tx1]);
+    await pool.deleteTxs([tx1.getTxHash()]);
+
+    const poolTx = pool.getTxByHash(tx1.getTxHash());
+    expect(poolTx).toBeFalsy();
+  });
+
+  it('Returns all transactions in the pool', async () => {
+    const tx1 = mockTx(1);
+    const tx2 = mockTx(2);
+    const tx3 = mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const poolTxs = pool.getAllTxs();
+    expect(poolTxs).toHaveLength(3);
+    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+  });
+
+  it('Returns all txHashes in the pool', async () => {
+    const tx1 = mockTx(1);
+    const tx2 = mockTx(2);
+    const tx3 = mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const poolTxHashes = pool.getAllTxHashes();
+    expect(poolTxHashes).toHaveLength(3);
+    expect(poolTxHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
+  });
+}