@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,161 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
-import type { AttestationPool } from './attestation_pool.js';
-
-export class InMemoryAttestationPool implements AttestationPool {
-  private metrics: PoolInstrumentation<BlockAttestation>;
-
-  private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
-
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:attestation_pool')) {
-    this.attestations = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
-  }
-
-  public getAttestationsForSlot(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
-    const slotAttestationMap = this.attestations.get(slot);
-    if (slotAttestationMap) {
-      const proposalAttestationMap = slotAttestationMap.get(proposalId);
-      if (proposalAttestationMap) {
-        return Promise.resolve(Array.from(proposalAttestationMap.values()));
-      }
-    }
-    return Promise.resolve([]);
-  }
-
-  public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      // Perf: order and group by slot before insertion
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
-
-      const proposalId = attestation.archive.toString();
-      const address = await attestation.getSender();
-
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
-      const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(address.toString(), attestation);
-
-      this.log.verbose(`Added attestation for slot ${slotNumber} from ${address}`);
-    }
-
-    // TODO: set these to pending or something ????
-    this.metrics.recordAddedObjects(attestations.length);
-    return Promise.resolve();
-  }
-
-  #getNumberOfAttestationsInSlot(slot: bigint): number {
-    let total = 0;
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
-
-    if (slotAttestationMap) {
-      for (const proposalAttestationMap of slotAttestationMap.values() ?? []) {
-        total += proposalAttestationMap.size;
-      }
-    }
-    return total;
-  }
-
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
-    const olderThan = [];
-
-    // Entries are iterated in insertion order, so we can break as soon as we find a slot that is older than the oldestSlot.
-    // Note: this will only prune correctly if attestations are added in order of rising slot, it is important that we do not allow
-    // insertion of attestations that are old. #(https://github.com/AztecProtocol/aztec-packages/issues/10322)
-    const slots = this.attestations.keys();
-    for (const slot of slots) {
-      if (slot < oldestSlot) {
-        olderThan.push(slot);
-      } else {
-        break;
-      }
-    }
-
-    for (const oldSlot of olderThan) {
-      await this.deleteAttestationsForSlot(oldSlot);
-    }
-    return Promise.resolve();
-  }
-
-  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
-    // We count the number of attestations we are removing
-    const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
-
-    this.attestations.delete(slot);
-    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
-
-    this.metrics.recordRemovedObjects(numberOfAttestations);
-    return Promise.resolve();
-  }
-
-  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
-    const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
-    if (slotAttestationMap) {
-      if (slotAttestationMap.has(proposalId)) {
-        const numberOfAttestations = slotAttestationMap.get(proposalId)?.size ?? 0;
-
-        slotAttestationMap.delete(proposalId);
-
-        this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-        this.metrics.recordRemovedObjects(numberOfAttestations);
-      }
-    }
-    return Promise.resolve();
-  }
-
-  public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
-    for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
-      if (slotAttestationMap) {
-        const proposalId = attestation.archive.toString();
-        const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-        if (proposalAttestationMap) {
-          const address = await attestation.getSender();
-          proposalAttestationMap.delete(address.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
-        }
-      }
-    }
-    this.metrics.recordRemovedObjects(attestations.length);
-    return Promise.resolve();
-  }
-}
-
-/**
- * Get Slot or Default
- *
- * Fetch the slot mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param slot - The slot to fetch
- * @returns The slot mapping
- */
-function getSlotOrDefault(
-  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
-  slot: bigint,
-): Map<string, Map<string, BlockAttestation>> {
-  if (!map.has(slot)) {
-    map.set(slot, new Map<string, Map<string, BlockAttestation>>());
-  }
-  return map.get(slot)!;
-}
-
-/**
- * Get Proposal or Default
- *
- * Fetch the proposal mapping, if it does not exist, then create a mapping and return it
- * @param map - The map to fetch from
- * @param proposalId - The proposal id to fetch
- * @returns The proposal mapping
- */
-function getProposalOrDefault(
-  map: Map<string, Map<string, BlockAttestation>>,
-  proposalId: string,
-): Map<string, BlockAttestation> {
-  if (!map.has(proposalId)) {
-    map.set(proposalId, new Map<string, BlockAttestation>());
-  }
-  return map.get(proposalId)!;
-}

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,309 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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();
-}