@aztec/p2p 0.0.0-test.0

package/dest/mem_pools/tx_pool/aztec_kv_tx_pool.js

@@ -0,0 +1,245 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { createLogger } from '@aztec/foundation/log';
+import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { getPendingTxPriority } from './priority.js';
+/**
+ * KV implementation of the Transaction Pool.
+ */ export class AztecKVTxPool {
+    #store;
+    /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */ #txs;
+    /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */ #minedTxHashToBlock;
+    /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */ #pendingTxPriorityToHash;
+    /** KV store for archived txs. */ #archive;
+    /** Archived txs map for future lookup. */ #archivedTxs;
+    /** Indexes of the archived txs by insertion order. */ #archivedTxIndices;
+    /** Number of txs to archive. */ #archivedTxLimit;
+    #log;
+    #metrics;
+    /**
+   * 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, archive, telemetry = getTelemetryClient(), archivedTxLimit = 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());
+    }
+    markAsMined(txHashes, blockNumber) {
+        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');
+        });
+    }
+    markMinedAsPending(txHashes) {
+        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');
+        });
+    }
+    async getPendingTxHashes() {
+        const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({
+            reverse: true
+        }));
+        return vals.map((x)=>TxHash.fromString(x));
+    }
+    async getMinedTxHashes() {
+        const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
+        return vals.map(([txHash, blockNumber])=>[
+                TxHash.fromString(txHash),
+                blockNumber
+            ]);
+    }
+    async getTxStatus(txHash) {
+        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.
+   */ async getTxByHash(txHash) {
+        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.
+   */ async getArchivedTxByHash(txHash) {
+        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.
+   */ async addTxs(txs) {
+        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
+                });
+                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.
+   */ deleteTxs(txHashes) {
+        let pendingDeleted = 0;
+        let minedDeleted = 0;
+        const deletedTxs = [];
+        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.
+   */ async getAllTxs() {
+        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.
+   */ async getAllTxHashes() {
+        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.
+   */ async archiveTxs(txs) {
+        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 = 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/dest/mem_pools/tx_pool/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tx_pool.js';
+export * from './memory_tx_pool.js';
+export * from './aztec_kv_tx_pool.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/mem_pools/tx_pool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

package/dest/mem_pools/tx_pool/index.js

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

package/dest/mem_pools/tx_pool/memory_tx_pool.d.ts

@@ -0,0 +1,56 @@
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { TxPool } from './tx_pool.js';
+/**
+ * In-memory implementation of the Transaction Pool.
+ */
+export declare class InMemoryTxPool implements TxPool {
+    private log;
+    /**
+     * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
+     */
+    private txs;
+    private minedTxs;
+    private pendingTxs;
+    private metrics;
+    /**
+     * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
+     * @param log - A logger.
+     */
+    constructor(telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+    markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+    getPendingTxHashes(): Promise<TxHash[]>;
+    getMinedTxHashes(): Promise<[TxHash, number][]>;
+    getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 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.
+     */
+    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    getArchivedTxByHash(): Promise<Tx | 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.
+     */
+    addTxs(txs: Tx[]): Promise<void>;
+    /**
+     * 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.
+     */
+    deleteTxs(txHashes: TxHash[]): Promise<void>;
+    /**
+     * Gets all the transactions stored in the pool.
+     * @returns Array of tx objects in the order they were added to the pool.
+     */
+    getAllTxs(): Promise<Tx[]>;
+    /**
+     * Gets the hashes of all transactions currently in the tx pool.
+     * @returns An array of transaction hashes found in the tx pool.
+     */
+    getAllTxHashes(): Promise<TxHash[]>;
+}
+//# sourceMappingURL=memory_tx_pool.d.ts.map

package/dest/mem_pools/tx_pool/memory_tx_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory_tx_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/memory_tx_pool.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAInF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;GAEG;AACH,qBAAa,cAAe,YAAW,MAAM;IAcoB,OAAO,CAAC,GAAG;IAb1E;;OAEG;IACH,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,UAAU,CAAc;IAEhC,OAAO,CAAC,OAAO,CAA0B;IAEzC;;;OAGG;gBACS,SAAS,GAAE,eAAsC,EAAU,GAAG,yCAA8B;IAOjG,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWnE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B/C,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAQ7C,gBAAgB,IAAI,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAM/C,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IAW5E;;;;OAIG;IACI,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAKpD,mBAAmB,IAAI,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAIrD;;;;OAIG;IACU,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB7C;;;;OAIG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBnD;;;OAGG;IACI,SAAS,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAIjC;;;OAGG;IACI,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAG3C"}

package/dest/mem_pools/tx_pool/memory_tx_pool.js

@@ -0,0 +1,141 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { getPendingTxPriority } from './priority.js';
+/**
+ * In-memory implementation of the Transaction Pool.
+ */ export class InMemoryTxPool {
+    log;
+    /**
+   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
+   */ txs;
+    minedTxs;
+    pendingTxs;
+    metrics;
+    /**
+   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
+   * @param log - A logger.
+   */ constructor(telemetry = getTelemetryClient(), log = createLogger('p2p:tx_pool')){
+        this.log = log;
+        this.txs = new Map();
+        this.minedTxs = new Map();
+        this.pendingTxs = new Set();
+        this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+    }
+    markAsMined(txHashes, blockNumber) {
+        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();
+    }
+    markMinedAsPending(txHashes) {
+        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();
+    }
+    async getPendingTxHashes() {
+        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()));
+    }
+    getMinedTxHashes() {
+        return Promise.resolve(Array.from(this.minedTxs.entries()).map(([txHash, blockNumber])=>[
+                TxHash.fromBigInt(txHash),
+                blockNumber
+            ]));
+    }
+    getTxStatus(txHash) {
+        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.
+   */ getTxByHash(txHash) {
+        const result = this.txs.get(txHash.toBigInt());
+        return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
+    }
+    getArchivedTxByHash() {
+        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.
+   */ async addTxs(txs) {
+        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()
+            });
+            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.
+   */ deleteTxs(txHashes) {
+        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.
+   */ getAllTxs() {
+        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.
+   */ getAllTxHashes() {
+        return Promise.resolve(Array.from(this.txs.keys()).map((x)=>TxHash.fromBigInt(x)));
+    }
+}

package/dest/mem_pools/tx_pool/priority.d.ts

@@ -0,0 +1,8 @@
+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 declare function getPendingTxPriority(tx: Tx): string;
+//# sourceMappingURL=priority.d.ts.map

package/dest/mem_pools/tx_pool/priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/priority.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAInD"}

package/dest/mem_pools/tx_pool/priority.js

@@ -0,0 +1,10 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+/**
+ * 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) {
+    const priorityFees = tx.getGasSettings().maxPriorityFeesPerGas;
+    const totalFees = priorityFees.feePerDaGas.toBigInt() + priorityFees.feePerL2Gas.toBigInt();
+    return Buffer32.fromBigInt(totalFees).toString();
+}

package/dest/mem_pools/tx_pool/tx_pool.d.ts

@@ -0,0 +1,66 @@
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+/**
+ * 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): Promise<Tx | undefined>;
+    /**
+     * Checks if an archived 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.
+     */
+    getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    /**
+     * Marks the set of txs as mined, as opposed to pending.
+     * @param txHashes - Hashes of the txs to flag as mined.
+     */
+    markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
+    /**
+     * Moves mined txs back to the pending set in the case of a reorg.
+     * Note: txs not known by this peer will be ignored.
+     * @param txHashes - Hashes of the txs to flag as pending.
+     */
+    markMinedAsPending(txHashes: TxHash[]): Promise<void>;
+    /**
+     * 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(): Promise<Tx[]>;
+    /**
+     * Gets the hashes of all transactions currently in the tx pool.
+     * @returns An array of transaction hashes found in the tx pool.
+     */
+    getAllTxHashes(): Promise<TxHash[]>;
+    /**
+     * Gets the hashes of pending transactions currently in the tx pool sorted by priority (see getPendingTxPriority).
+     * @returns An array of pending transaction hashes found in the tx pool.
+     */
+    getPendingTxHashes(): Promise<TxHash[]>;
+    /**
+     * Gets the hashes of mined transactions currently in the tx pool.
+     * @returns An array of mined transaction hashes found in the tx pool.
+     */
+    getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
+    /**
+     * 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): Promise<'pending' | 'mined' | undefined>;
+}
+//# sourceMappingURL=tx_pool.d.ts.map

package/dest/mem_pools/tx_pool/tx_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjC;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAErD;;;;OAIG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;IAE7D;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;OAIG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtD;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7C;;;OAGG;IACH,SAAS,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;IAE3B;;;OAGG;IACH,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAEpC;;;OAGG;IACH,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAExC;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAEjE;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;CACvE"}

package/dest/mem_pools/tx_pool/tx_pool.js

@@ -0,0 +1,3 @@
+/**
+ * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
+ */ export { };

package/dest/mem_pools/tx_pool/tx_pool_test_suite.d.ts

@@ -0,0 +1,7 @@
+import type { TxPool } from './tx_pool.js';
+/**
+ * Tests a TxPool implementation.
+ * @param getTxPool - Gets a fresh TxPool
+ */
+export declare function describeTxPool(getTxPool: () => TxPool): void;
+//# sourceMappingURL=tx_pool_test_suite.d.ts.map

package/dest/mem_pools/tx_pool/tx_pool_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/tx_pool_test_suite.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,MAAM,QAsHrD"}