@aztec/p2p 0.46.7 → 0.47.1

package/dest/tx_pool/tx_pool_test_suite.js

@@ -8,18 +8,30 @@ export function describeTxPool(getTxPool) {
     beforeEach(() => {
         pool = getTxPool();
     });
-    it('Adds txs to the pool', async () => {
+    it('Adds txs to the pool as pending', async () => {
         const tx1 = mockTx();
         await pool.addTxs([tx1]);
         const poolTx = pool.getTxByHash(tx1.getTxHash());
         expect(poolTx.getTxHash()).toEqual(tx1.getTxHash());
+        expect(pool.getTxStatus(tx1.getTxHash())).toEqual('pending');
+        expect(pool.getPendingTxHashes()).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();
+        expect(pool.getTxByHash(tx1.getTxHash())).toBeFalsy();
+        expect(pool.getTxStatus(tx1.getTxHash())).toBeUndefined();
+    });
+    it('Marks txs as mined', async () => {
+        const tx1 = mockTx(1);
+        const tx2 = mockTx(2);
+        await pool.addTxs([tx1, tx2]);
+        await pool.markAsMined([tx1.getTxHash()]);
+        expect(pool.getTxByHash(tx1.getTxHash())).toEqual(tx1);
+        expect(pool.getTxStatus(tx1.getTxHash())).toEqual('mined');
+        expect(pool.getMinedTxHashes()).toEqual([tx1.getTxHash()]);
+        expect(pool.getPendingTxHashes()).toEqual([tx2.getTxHash()]);
     });
     it('Returns all transactions in the pool', async () => {
         const tx1 = mockTx(1);
@@ -40,4 +52,4 @@ export function describeTxPool(getTxPool) {
         expect(poolTxHashes).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash(), tx3.getTxHash()]));
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "0.46.7",
+  "version": "0.47.1",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -56,11 +56,11 @@
     "testTimeout": 15000
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.46.7",
-    "@aztec/circuits.js": "0.46.7",
-    "@aztec/foundation": "0.46.7",
-    "@aztec/kv-store": "0.46.7",
-    "@aztec/telemetry-client": "0.46.7",
+    "@aztec/circuit-types": "0.47.1",
+    "@aztec/circuits.js": "0.47.1",
+    "@aztec/foundation": "0.47.1",
+    "@aztec/kv-store": "0.47.1",
+    "@aztec/telemetry-client": "0.47.1",
     "@chainsafe/discv5": "9.0.0",
     "@chainsafe/enr": "3.0.0",
     "@chainsafe/libp2p-gossipsub": "13.0.0",

package/src/client/index.ts

@@ -12,8 +12,8 @@ import { getPublicIp, splitAddressPort } from '../util.js';
 export * from './p2p_client.js';
 
 export const createP2PClient = async (
-  store: AztecKVStore,
   config: P2PConfig,
+  store: AztecKVStore,
   txPool: TxPool,
   l2BlockSource: L2BlockSource,
 ) => {
@@ -63,5 +63,5 @@ export const createP2PClient = async (
   } else {
     p2pService = new DummyP2PService();
   }
-  return new P2PClient(store, l2BlockSource, txPool, p2pService);
+  return new P2PClient(store, l2BlockSource, txPool, p2pService, config.keepProvenTxsInPoolFor);
 };

package/src/client/mocks.ts

@@ -8,14 +8,23 @@ 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);
+  constructor(numBlocks = 100, private provenBlockNumber?: number) {
+    this.addBlocks(numBlocks);
+  }
+
+  public addBlocks(numBlocks: number) {
+    for (let i = 0; i < numBlocks; i++) {
+      const blockNum = this.l2Blocks.length;
+      const block = L2Block.random(blockNum);
       this.l2Blocks.push(block);
       this.txEffects.push(...block.body.txEffects);
     }
   }
 
+  public setProvenBlockNumber(provenBlockNumber: number) {
+    this.provenBlockNumber = provenBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -40,8 +49,8 @@ export class MockBlockSource implements L2BlockSource {
     return Promise.resolve(this.l2Blocks.length - 1);
   }
 
-  public getProvenBlockNumber(): Promise<number> {
-    return this.getBlockNumber();
+  public async getProvenBlockNumber(): Promise<number> {
+    return this.provenBlockNumber ?? (await this.getBlockNumber());
   }
 
   /**
@@ -59,8 +68,12 @@ export class MockBlockSource implements L2BlockSource {
    * @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));
+  public getBlocks(from: number, limit: number, proven?: boolean) {
+    return Promise.resolve(
+      this.l2Blocks
+        .slice(from, from + limit)
+        .filter(b => !proven || this.provenBlockNumber === undefined || b.number <= this.provenBlockNumber),
+    );
   }
 
   /**

package/src/client/p2p_client.ts

@@ -52,14 +52,21 @@ export interface P2P {
    * Returns all transactions in the transaction pool.
    * @returns An array of Txs.
    */
-  getTxs(): Promise<Tx[]>;
+  getTxs(filter: 'all' | 'pending' | 'mined'): 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>;
+  getTxByHash(txHash: TxHash): Tx | undefined;
+
+  /**
+   * Returns whether the given tx hash is flagged as pending or mined.
+   * @param txHash - Hash of the tx to query.
+   * @returns Pending or mined depending on its status, or undefined if not found.
+   */
+  getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined;
 
   /**
    * Starts the p2p client.
@@ -89,26 +96,26 @@ export interface P2P {
  * 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;
+  /** L2 block download to stay in sync with latest blocks. */
+  private latestBlockDownloader: L2BlockDownloader;
 
-  /**
-   * Property that indicates whether the client is running.
-   */
+  /** L2 block download to stay in sync with proven blocks. */
+  private provenBlockDownloader: 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.
-   */
+  /** 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>;
+  private latestBlockNumberAtStart = -1;
+  private provenBlockNumberAtStart = -1;
+
+  private synchedLatestBlockNumber: AztecSingleton<number>;
+  private synchedProvenBlockNumber: AztecSingleton<number>;
 
   /**
    * In-memory P2P client constructor.
@@ -116,6 +123,7 @@ export class P2PClient implements P2P {
    * @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 keepProvenTxsFor - How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven).
    * @param log - A logger.
    */
   constructor(
@@ -123,14 +131,19 @@ export class P2PClient implements P2P {
     private l2BlockSource: L2BlockSource,
     private txPool: TxPool,
     private p2pService: P2PService,
+    private keepProvenTxsFor: number,
     private log = createDebugLogger('aztec:p2p'),
   ) {
     const { p2pBlockCheckIntervalMS: checkInterval, p2pL2QueueSize } = getP2PConfigEnvVars();
-    this.blockDownloader = new L2BlockDownloader(l2BlockSource, {
-      maxQueueSize: p2pL2QueueSize,
-      pollIntervalMS: checkInterval,
-    });
-    this.synchedBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+    const l2DownloaderOpts = { maxQueueSize: p2pL2QueueSize, pollIntervalMS: checkInterval };
+    // TODO(palla/prover-node): This effectively downloads blocks twice from the archiver, which is an issue
+    // if the archiver is remote. We should refactor this so the downloader keeps a single queue and handles
+    // latest/proven metadata, as well as block reorgs.
+    this.latestBlockDownloader = new L2BlockDownloader(l2BlockSource, l2DownloaderOpts);
+    this.provenBlockDownloader = new L2BlockDownloader(l2BlockSource, { ...l2DownloaderOpts, proven: true });
+
+    this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+    this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
   }
 
   /**
@@ -145,41 +158,47 @@ export class P2PClient implements P2P {
       return this.syncPromise;
     }
 
-    // get the current latest block number
+    // get the current latest block numbers
     this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+    this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
 
-    const blockToDownloadFrom = this.getSyncedBlockNum() + 1;
+    const syncedLatestBlock = this.getSyncedLatestBlockNum() + 1;
+    const syncedProvenBlock = this.getSyncedProvenBlockNum() + 1;
 
     // if there are blocks to be retrieved, go to a synching state
-    if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
+    if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
       this.setCurrentState(P2PClientState.SYNCHING);
       this.syncPromise = new Promise(resolve => {
         this.syncResolve = resolve;
       });
-      this.log.verbose(`Starting sync from ${blockToDownloadFrom}, latest block ${this.latestBlockNumberAtStart}`);
+      this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
     } 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.verbose(
-        `Next block ${blockToDownloadFrom} already beyond latest block at ${this.latestBlockNumberAtStart}`,
-      );
+      this.log.verbose(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
     }
 
     // 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 () => {
+    const processLatest = async () => {
       while (!this.stopping) {
-        const blocks = await this.blockDownloader.getBlocks();
-        await this.handleL2Blocks(blocks);
+        await this.latestBlockDownloader.getBlocks(1).then(this.handleLatestL2Blocks.bind(this));
+      }
+    };
+    const processProven = async () => {
+      while (!this.stopping) {
+        await this.provenBlockDownloader.getBlocks(1).then(this.handleProvenL2Blocks.bind(this));
       }
     };
-    this.runningPromise = blockProcess();
-    this.blockDownloader.start(blockToDownloadFrom);
-    this.log.verbose(`Started block downloader from block ${blockToDownloadFrom}`);
+
+    this.runningPromise = Promise.all([processLatest(), processProven()]).then(() => {});
+    this.latestBlockDownloader.start(syncedLatestBlock);
+    this.provenBlockDownloader.start(syncedLatestBlock);
+    this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
 
     return this.syncPromise;
   }
@@ -193,7 +212,8 @@ export class P2PClient implements P2P {
     this.stopping = true;
     await this.p2pService.stop();
     this.log.debug('Stopped p2p service');
-    await this.blockDownloader.stop();
+    await this.latestBlockDownloader.stop();
+    await this.provenBlockDownloader.stop();
     this.log.debug('Stopped block downloader');
     await this.runningPromise;
     this.setCurrentState(P2PClientState.STOPPED);
@@ -204,8 +224,23 @@ export class P2PClient implements P2P {
    * Returns all transactions in the transaction pool.
    * @returns An array of Txs.
    */
-  public getTxs(): Promise<Tx[]> {
-    return Promise.resolve(this.txPool.getAllTxs());
+  public getTxs(filter: 'all' | 'pending' | 'mined'): Tx[] {
+    if (filter === 'all') {
+      return this.txPool.getAllTxs();
+    } else if (filter === 'mined') {
+      return this.txPool
+        .getMinedTxHashes()
+        .map(txHash => this.txPool.getTxByHash(txHash))
+        .filter((tx): tx is Tx => !!tx);
+    } else if (filter === 'pending') {
+      return this.txPool
+        .getPendingTxHashes()
+        .map(txHash => this.txPool.getTxByHash(txHash))
+        .filter((tx): tx is Tx => !!tx);
+    } else {
+      const _: never = filter;
+      throw new Error(`Unknown filter ${filter}`);
+    }
   }
 
   /**
@@ -213,8 +248,8 @@ export class P2PClient implements P2P {
    * @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));
+  getTxByHash(txHash: TxHash): Tx | undefined {
+    return this.txPool.getTxByHash(txHash);
   }
 
   /**
@@ -231,6 +266,15 @@ export class P2PClient implements P2P {
     this.p2pService.propagateTx(tx);
   }
 
+  /**
+   * Returns whether the given tx hash is flagged as pending or mined.
+   * @param txHash - Hash of the tx to query.
+   * @returns Pending or mined depending on its status, or undefined if not found.
+   */
+  public getTxStatus(txHash: TxHash): 'pending' | 'mined' | undefined {
+    return this.txPool.getTxStatus(txHash);
+  }
+
   /**
    * Deletes the 'txs' from the pool.
    * NOT used if we use sendTx as reconcileTxPool will handle this.
@@ -257,8 +301,16 @@ export class P2PClient implements P2P {
    * 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;
+  public getSyncedLatestBlockNum() {
+    return this.synchedLatestBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
+  }
+
+  /**
+   * Public function to check the latest proven block number that the P2P client is synced to.
+   * @returns Block number of latest proven L2 Block we've synced with.
+   */
+  public getSyncedProvenBlockNum() {
+    return this.synchedProvenBlockNumber.get() ?? INITIAL_L2_BLOCK_NUM - 1;
   }
 
   /**
@@ -268,16 +320,29 @@ export class P2PClient implements P2P {
   public getStatus(): Promise<P2PSyncState> {
     return Promise.resolve({
       state: this.currentState,
-      syncedToL2Block: this.getSyncedBlockNum(),
+      syncedToL2Block: this.getSyncedLatestBlockNum(),
     } as P2PSyncState);
   }
 
   /**
-   * Internal method that uses the provided blocks to check against the client's tx pool.
+   * Mark all txs from these blocks as mined.
    * @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> {
+  private async markTxsAsMinedFromBlocks(blocks: L2Block[]): Promise<void> {
+    for (const block of blocks) {
+      const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
+      await this.txPool.markAsMined(txHashes);
+    }
+  }
+
+  /**
+   * Deletes txs from these 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 deleteTxsFromBlocks(blocks: L2Block[]): Promise<void> {
+    this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
     for (const block of blocks) {
       const txHashes = block.body.txEffects.map(txEffect => txEffect.txHash);
       await this.txPool.deleteTxs(txHashes);
@@ -285,20 +350,56 @@ export class P2PClient implements P2P {
   }
 
   /**
-   * Method for processing new blocks.
+   * Handles new mined blocks by marking the txs in them as mined.
    * @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> {
+  private async handleLatestL2Blocks(blocks: L2Block[]): Promise<void> {
     if (!blocks.length) {
       return Promise.resolve();
     }
-    await this.reconcileTxPool(blocks);
+    await this.markTxsAsMinedFromBlocks(blocks);
     const lastBlockNum = blocks[blocks.length - 1].number;
-    await this.synchedBlockNumber.set(lastBlockNum);
-    this.log.debug(`Synched to block ${lastBlockNum}`);
+    await this.synchedLatestBlockNumber.set(lastBlockNum);
+    this.log.debug(`Synched to latest block ${lastBlockNum}`);
+    await this.startServiceIfSynched();
+  }
+
+  /**
+   * Handles new proven blocks by deleting the txs in them, or by deleting the txs in blocks `keepProvenTxsFor` ago.
+   * @param blocks - A list of proven L2 blocks.
+   * @returns Empty promise.
+   */
+  private async handleProvenL2Blocks(blocks: L2Block[]): Promise<void> {
+    if (!blocks.length) {
+      return Promise.resolve();
+    }
+
+    const firstBlockNum = blocks[0].number;
+    const lastBlockNum = blocks[blocks.length - 1].number;
+
+    if (this.keepProvenTxsFor === 0) {
+      await this.deleteTxsFromBlocks(blocks);
+    } else if (lastBlockNum - this.keepProvenTxsFor >= INITIAL_L2_BLOCK_NUM) {
+      const fromBlock = Math.max(INITIAL_L2_BLOCK_NUM, firstBlockNum - this.keepProvenTxsFor);
+      const toBlock = lastBlockNum - this.keepProvenTxsFor;
+      const limit = toBlock - fromBlock + 1;
+      const blocksToDeleteTxsFrom = await this.l2BlockSource.getBlocks(fromBlock, limit, true);
+      await this.deleteTxsFromBlocks(blocksToDeleteTxsFrom);
+    }
+
+    await this.synchedProvenBlockNumber.set(lastBlockNum);
+    this.log.debug(`Synched to proven block ${lastBlockNum}`);
+    await this.startServiceIfSynched();
+  }
 
-    if (this.currentState === P2PClientState.SYNCHING && lastBlockNum >= this.latestBlockNumberAtStart) {
+  private async startServiceIfSynched() {
+    if (
+      this.currentState === P2PClientState.SYNCHING &&
+      this.getSyncedLatestBlockNum() >= this.latestBlockNumberAtStart &&
+      this.getSyncedProvenBlockNum() >= this.provenBlockNumberAtStart
+    ) {
+      this.log.debug(`Synched to blocks at start`);
       this.setCurrentState(P2PClientState.RUNNING);
       if (this.syncResolve !== undefined) {
         this.syncResolve();

package/src/config.ts

@@ -88,6 +88,9 @@ export interface P2PConfig {
    * If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.
    */
   queryForIp: boolean;
+
+  /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
+  keepProvenTxsInPoolFor: number;
 }
 
 /**
@@ -113,6 +116,7 @@ export function getP2PConfigEnvVars(): P2PConfig {
     TX_GOSSIP_VERSION,
     P2P_TX_PROTOCOL,
     P2P_QUERY_FOR_IP,
+    P2P_TX_POOL_KEEP_PROVEN_FOR,
   } = process.env;
   // P2P listen & announce addresses passed in format: <IP_ADDRESS>:<PORT>
   // P2P announce multiaddrs passed in format: /ip4/<IP_ADDRESS>/<protocol>/<PORT>
@@ -134,6 +138,7 @@ export function getP2PConfigEnvVars(): P2PConfig {
     dataDirectory: DATA_DIRECTORY,
     txGossipVersion: TX_GOSSIP_VERSION ? new SemVer(TX_GOSSIP_VERSION) : new SemVer('0.1.0'),
     queryForIp: P2P_QUERY_FOR_IP === 'true',
+    keepProvenTxsInPoolFor: P2P_TX_POOL_KEEP_PROVEN_FOR ? +P2P_TX_POOL_KEEP_PROVEN_FOR : 0,
   };
   return envVars;
 }

package/src/service/libp2p_service.ts

@@ -1,4 +1,4 @@
-import { type Tx } from '@aztec/circuit-types';
+import { Tx } from '@aztec/circuit-types';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -21,7 +21,7 @@ import { convertToMultiaddr } from '../util.js';
 import { AztecDatastore } from './data_store.js';
 import { PeerManager } from './peer_manager.js';
 import type { P2PService, PeerDiscoveryService } from './service.js';
-import { AztecTxMessageCreator, fromTxMessage } from './tx_messages.js';
+import { AztecTxMessageCreator } from './tx_messages.js';
 
 export interface PubSubLibp2p extends Libp2p {
   services: {
@@ -239,7 +239,7 @@ export class LibP2PService implements P2PService {
       return;
     }
 
-    const tx = fromTxMessage(Buffer.from(data));
+    const tx = Tx.fromBuffer(Buffer.from(data));
     await this.processTxFromPeer(tx);
   }
 

package/src/service/tx_messages.ts

@@ -1,6 +1,4 @@
-import { EncryptedNoteTxL2Logs, EncryptedTxL2Logs, Tx, UnencryptedTxL2Logs } from '@aztec/circuit-types';
-import { ClientIvcProof, PrivateKernelTailCircuitPublicInputs, PublicCallRequest } from '@aztec/circuits.js';
-import { numToUInt32BE } from '@aztec/foundation/serialize';
+import { type Tx } from '@aztec/circuit-types';
 
 import { type SemVer } from 'semver';
 
@@ -13,7 +11,7 @@ export class AztecTxMessageCreator {
   }
 
   createTxMessage(tx: Tx) {
-    const messageData = toTxMessage(tx);
+    const messageData = tx.toBuffer();
 
     return { topic: this.topic, data: messageData };
   }
@@ -22,122 +20,3 @@ export class AztecTxMessageCreator {
     return this.topic;
   }
 }
-
-/**
- * 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;
-}
-
-/**
- * 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.clientIvcProof),
-    createMessageComponent(tx.noteEncryptedLogs),
-    createMessageComponent(tx.encryptedLogs),
-    createMessageComponent(tx.unencryptedLogs),
-    createMessageComponents(tx.enqueuedPublicFunctionCalls),
-    createMessageComponent(tx.publicTeardownFunctionCall),
-  ]);
-  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 clientIvcProof = toObject(publicInputs.remainingData, ClientIvcProof);
-
-  const noteEncryptedLogs = toObject(clientIvcProof.remainingData, EncryptedNoteTxL2Logs);
-  if (!noteEncryptedLogs.obj) {
-    noteEncryptedLogs.obj = new EncryptedNoteTxL2Logs([]);
-  }
-  const encryptedLogs = toObject(noteEncryptedLogs.remainingData, EncryptedTxL2Logs);
-  if (!encryptedLogs.obj) {
-    encryptedLogs.obj = new EncryptedTxL2Logs([]);
-  }
-  const unencryptedLogs = toObject(encryptedLogs.remainingData, UnencryptedTxL2Logs);
-  if (!unencryptedLogs.obj) {
-    unencryptedLogs.obj = new UnencryptedTxL2Logs([]);
-  }
-
-  const publicCalls = toObjectArray(unencryptedLogs.remainingData, PublicCallRequest);
-
-  const publicTeardownCall = toObject(publicCalls.remainingData, PublicCallRequest);
-  return new Tx(
-    publicInputs.obj!,
-    clientIvcProof.obj!,
-    noteEncryptedLogs.obj,
-    encryptedLogs.obj,
-    unencryptedLogs.obj,
-    publicCalls.objects,
-    publicTeardownCall.obj!,
-  );
-}