@aztec/p2p 0.23.0 → 0.24.0

package/src/service/tx_messages.ts

@@ -0,0 +1,216 @@
+import { ExtendedContractData, Tx, TxHash, TxL2Logs } from '@aztec/circuit-types';
+import {
+  MAX_NEW_CONTRACTS_PER_TX,
+  PrivateKernelTailCircuitPublicInputs,
+  Proof,
+  PublicCallRequest,
+} from '@aztec/circuits.js';
+import { Tuple, numToUInt32BE } from '@aztec/foundation/serialize';
+
+/**
+ * Enumeration of P2P message types.
+ */
+export enum Messages {
+  POOLED_TRANSACTIONS = 1,
+  POOLED_TRANSACTION_HASHES = 2,
+  GET_TRANSACTIONS = 3,
+}
+
+/**
+ * Create a P2P message from the message type and message data.
+ * @param type - The type of the message.
+ * @param messageData - The binary message data.
+ * @returns The encoded message.
+ */
+export function createMessage(type: Messages, messageData: Buffer) {
+  return Buffer.concat([numToUInt32BE(type), messageData]);
+}
+
+/**
+ * Create a POOLED_TRANSACTIONS message from an array of transactions.
+ * @param txs - The transactions to encoded into a message.
+ * @returns The encoded message.
+ */
+export function createTransactionsMessage(txs: Tx[]) {
+  const messageData = txs.map(toTxMessage);
+  return createMessage(Messages.POOLED_TRANSACTIONS, Buffer.concat(messageData));
+}
+
+/**
+ * Decode a POOLED_TRANSACTIONS message into the original transaction objects.
+ * @param message - The binary message to be decoded.
+ * @returns - The array of transactions originally encoded into the message.
+ */
+export function decodeTransactionsMessage(message: Buffer) {
+  const lengthSize = 4;
+  let offset = 0;
+  const txs: Tx[] = [];
+  while (offset < message.length) {
+    const dataSize = message.readUInt32BE(offset);
+    const totalSizeOfMessage = lengthSize + dataSize;
+    txs.push(fromTxMessage(message.subarray(offset, offset + totalSizeOfMessage)));
+    offset += totalSizeOfMessage;
+  }
+  return txs;
+}
+
+/**
+ * Create a POOLED_TRANSACTION_HASHES message.
+ * @param hashes - The transaction hashes to be sent.
+ * @returns The encoded message.
+ */
+export function createTransactionHashesMessage(hashes: TxHash[]) {
+  const messageData = hashes.map(x => x.buffer);
+  return createMessage(Messages.POOLED_TRANSACTION_HASHES, Buffer.concat(messageData));
+}
+
+/**
+ * Decode a POOLED_TRANSACTION_HASHESs message ito the original transaction hash objects.
+ * @param message - The binary message to be decoded.
+ * @returns - The array of transaction hashes originally encoded into the message.
+ */
+export function decodeTransactionHashesMessage(message: Buffer) {
+  let offset = 0;
+  const txHashes: TxHash[] = [];
+  while (offset < message.length) {
+    const slice = message.subarray(offset, offset + TxHash.SIZE);
+    if (slice.length < TxHash.SIZE) {
+      throw new Error(`Invalid message size when processing transaction hashes message`);
+    }
+    txHashes.push(new TxHash(slice));
+    offset += TxHash.SIZE;
+  }
+  return txHashes;
+}
+
+/**
+ * Create a GET_TRANSACTIONS message from an array of transaction hashes.
+ * @param hashes - The hashes of the transactions to be requested.
+ * @returns The encoded message.
+ */
+export function createGetTransactionsRequestMessage(hashes: TxHash[]) {
+  const messageData = hashes.map(x => x.buffer);
+  return createMessage(Messages.GET_TRANSACTIONS, Buffer.concat(messageData));
+}
+
+/**
+ * Decode a GET_TRANSACTIONS message into the original transaction hash objects.
+ * @param message - The binary message to be decoded.
+ * @returns - The array of transaction hashes originally encoded into the message.
+ */
+export function decodeGetTransactionsRequestMessage(message: Buffer) {
+  // for the time being this payload is effectively the same as the POOLED_TRANSACTION_HASHES message
+  return decodeTransactionHashesMessage(message);
+}
+
+/**
+ * Decode the message type from a received message.
+ * @param message - The received message.
+ * @returns The decoded MessageType.
+ */
+export function decodeMessageType(message: Buffer) {
+  return message.readUInt32BE(0);
+}
+
+/**
+ * Return the encoded message (minus the header) from received message buffer.
+ * @param message - The complete received message.
+ * @returns The encoded message, without the header.
+ */
+export function getEncodedMessage(message: Buffer) {
+  return message.subarray(4);
+}
+
+/**
+ * Creates a tx 'message' for sending to a peer.
+ * @param tx - The transaction to convert to a message.
+ * @returns - The message.
+ */
+export function toTxMessage(tx: Tx): Buffer {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const createMessageComponent = (obj?: { toBuffer: () => Buffer }) => {
+    if (!obj) {
+      // specify a length of 0 bytes
+      return numToUInt32BE(0);
+    }
+    const buffer = obj.toBuffer();
+    return Buffer.concat([numToUInt32BE(buffer.length), buffer]);
+  };
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const createMessageComponents = (obj?: { toBuffer: () => Buffer }[]) => {
+    if (!obj || !obj.length) {
+      // specify a length of 0 bytes
+      return numToUInt32BE(0);
+    }
+    const allComponents = Buffer.concat(obj.map(createMessageComponent));
+    return Buffer.concat([numToUInt32BE(obj.length), allComponents]);
+  };
+  const messageBuffer = Buffer.concat([
+    createMessageComponent(tx.data),
+    createMessageComponent(tx.proof),
+    createMessageComponent(tx.encryptedLogs),
+    createMessageComponent(tx.unencryptedLogs),
+    createMessageComponents(tx.enqueuedPublicFunctionCalls),
+    createMessageComponents(tx.newContracts),
+  ]);
+  const messageLength = numToUInt32BE(messageBuffer.length);
+  return Buffer.concat([messageLength, messageBuffer]);
+}
+
+/**
+ * Reproduces a transaction from a transaction 'message'
+ * @param buffer - The message buffer to convert to a tx.
+ * @returns - The reproduced transaction.
+ */
+export function fromTxMessage(buffer: Buffer): Tx {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const toObject = <T>(objectBuffer: Buffer, factory: { fromBuffer: (b: Buffer) => T }) => {
+    const objectSize = objectBuffer.readUint32BE(0);
+    return {
+      remainingData: objectBuffer.subarray(objectSize + 4),
+      obj: objectSize === 0 ? undefined : factory.fromBuffer(objectBuffer.subarray(4, objectSize + 4)),
+    };
+  };
+
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  const toObjectArray = <T>(objectBuffer: Buffer, factory: { fromBuffer: (b: Buffer) => T }) => {
+    const output: T[] = [];
+    const numItems = objectBuffer.readUint32BE(0);
+    let workingBuffer = objectBuffer.subarray(4);
+    for (let i = 0; i < numItems; i++) {
+      const obj = toObject<T>(workingBuffer, factory);
+      workingBuffer = obj.remainingData;
+      if (obj !== undefined) {
+        output.push(obj.obj!);
+      }
+    }
+    return {
+      remainingData: workingBuffer,
+      objects: output,
+    };
+  };
+  // this is the opposite of the 'toMessage' function
+  // so the first 4 bytes is the complete length, skip it
+  const publicInputs = toObject(buffer.subarray(4), PrivateKernelTailCircuitPublicInputs);
+  const proof = toObject(publicInputs.remainingData, Proof);
+
+  const encryptedLogs = toObject(proof.remainingData, TxL2Logs);
+  if (!encryptedLogs.obj) {
+    encryptedLogs.obj = new TxL2Logs([]);
+  }
+  const unencryptedLogs = toObject(encryptedLogs.remainingData, TxL2Logs);
+  if (!unencryptedLogs.obj) {
+    unencryptedLogs.obj = new TxL2Logs([]);
+  }
+
+  const publicCalls = toObjectArray(unencryptedLogs.remainingData, PublicCallRequest);
+  const newContracts = toObjectArray(publicCalls.remainingData, ExtendedContractData);
+  return new Tx(
+    publicInputs.obj!,
+    proof.obj!,
+    encryptedLogs.obj,
+    unencryptedLogs.obj,
+    publicCalls.objects,
+    newContracts.objects as Tuple<ExtendedContractData, typeof MAX_NEW_CONTRACTS_PER_TX>,
+  );
+}

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,86 @@
+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 async addTxs(txs: Tx[]): Promise<void> {
+    for (const tx of txs) {
+      const txHash = await 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);
+    }
+  }
+
+  /**
+   * 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,59 @@
+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(await tx1.getTxHash());
+    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
+  });
+
+  it('Removes txs from the pool', async () => {
+    const tx1 = mockTx();
+
+    await pool.addTxs([tx1]);
+    await pool.deleteTxs([await tx1.getTxHash()]);
+
+    const poolTx = pool.getTxByHash(await 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([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
+    );
+  });
+}