@aztec/p2p 0.0.1-commit.6230efd → 0.0.1-commit.64b6bbb

package/src/mem_pools/tx_pool_v2/README.md

@@ -0,0 +1,259 @@
+# TxPoolV2
+
+Transaction pool implementation with explicit state management and pluggable eviction rules.
+
+## Overview
+
+TxPoolV2 manages transactions through a state machine with clear transitions:
+
+```
+              addPendingTxs()
+                    │
+                    ▼
+┌─────────────────────────────────────┐
+│              PENDING                │◄──────────────────┐
+│   (awaiting block inclusion)        │                   │
+└─────────────────────────────────────┘                   │
+        │                                                 │
+        │ protectTxs() / addProtectedTxs()               │
+        ▼                                                 │
+┌─────────────────────────────────────┐                   │
+│            PROTECTED                │───────────────────┘
+│   (in a block proposal)             │  prepareForSlot()
+└─────────────────────────────────────┘  (slot passed without mining)
+        │                                                 │
+        │ handleMinedBlock()                              │
+        ▼                                                 │
+┌─────────────────────────────────────┐                   │
+│              MINED                  │───────────────────┘
+│   (included in a block)             │  handlePrunedBlocks()
+└─────────────────────────────────────┘  (reorg)
+        │                                     │
+        │ handleFinalizedBlock()              │ eviction after reorg
+        ▼                                     ▼
+┌─────────────────────────────────────┐  ┌─────────────────────────────────────┐
+│             DELETED                 │  │         SOFT-DELETED                │
+│   (hard-deleted or archived)        │  │   (kept in DB for debugging)        │
+└─────────────────────────────────────┘  └─────────────────────────────────────┘
+                                                  │
+                                                  │ handleFinalizedBlock()
+                                                  │ (mined block finalized)
+                                                  ▼
+                                         ┌─────────────────────────────────────┐
+                                         │          HARD-DELETED               │
+                                         │   (permanently removed from DB)     │
+                                         └─────────────────────────────────────┘
+```
+
+## Key Components
+
+### TxPoolV2 (`tx_pool_v2.ts`)
+
+The public API wrapper that serializes all operations through a queue to prevent race conditions. Delegates to `TxPoolV2Impl` for actual logic.
+
+### TxPoolV2Impl (`tx_pool_v2_impl.ts`)
+
+Core implementation containing:
+- KV store persistence for transactions and metadata
+- In-memory indices for fast lookups (by nullifier, fee payer, priority)
+- State transition logic
+- Pre-add rule execution
+- Post-event eviction rule execution
+
+### DeletedPool (`deleted_pool.ts`)
+
+Manages soft deletion of transactions from pruned blocks:
+- When a reorg (chain prune) occurs, transactions from pruned blocks are tracked with their original mined block number
+- When these transactions are later evicted (e.g., failed validation, nullifier conflict), they are "soft-deleted" instead of removed
+- Soft-deleted transactions remain in the database for debugging and potential resubmission
+- When the original mined block is finalized on the new chain, soft-deleted transactions are permanently hard-deleted
+
+This ensures transactions from reorged blocks are kept around until we're certain they won't be needed.
+
+### TxMetaData (`tx_metadata.ts`)
+
+Lightweight metadata stored alongside each transaction:
+- `txHash`: Transaction identifier
+- `anchorBlockHeaderHash`: Hash of the anchor block header
+- `priorityFee`: For priority ordering and challenges
+- `feePayer`: For balance-based eviction
+- `claimAmount`: Fee payer's claim from bridging
+- `feeLimit`: Maximum fee the tx can pay
+- `nullifiers`: For conflict detection
+- `includeByTimestamp`: Expiration timestamp
+- `minedL2BlockId`: Set when mined (undefined otherwise)
+
+State is derived by TxPoolIndices:
+- `mined` if `minedL2BlockId` is set
+- `protected` if in protection map
+- `deleted` if soft-deleted (from a pruned block, evicted but kept in DB)
+- `pending` otherwise
+
+## Soft Deletion
+
+When a chain reorganization occurs, transactions that were mined in pruned blocks are handled specially:
+
+1. **Tracking**: When `handlePrunedBlocks` is called, all un-mined transactions are tracked by their original mined block number
+2. **Soft Delete**: If these transactions are later evicted (failed validation, nullifier conflict, etc.), they are "soft-deleted" - removed from indices but kept in the database
+3. **Retrieval**: Soft-deleted transactions can still be retrieved via `getTxByHash` and `hasTxs`, and return status `'deleted'` from `getTxStatus`
+4. **Hard Delete**: When `handleFinalizedBlock` is called and the finalized block number reaches or exceeds the transaction's original mined block, the transaction is permanently removed
+
+This design allows:
+- Debugging reorg scenarios by keeping transaction data available
+- Potential resubmission of transactions that failed validation after a reorg
+- Clean eventual cleanup once we're certain the transaction won't be needed
+
+**Example scenario:**
+1. Tx mined at block 10
+2. Chain prunes to block 5 (tx becomes un-mined, tracked as minedAtBlock=10)
+3. Tx fails validation and is soft-deleted
+4. Block 9 finalized → tx still in DB (minedAtBlock=10 > finalized=9)
+5. Block 10 finalized → tx hard-deleted (minedAtBlock=10 ≤ finalized=10)
+
+If the tx is re-mined at a higher block before being soft-deleted:
+1. Tx mined at block 10, pruned (tracked as minedAtBlock=10)
+2. Tx re-mined at block 15, pruned again (updated to minedAtBlock=15)
+3. Tx soft-deleted
+4. Block 10 finalized → tx still in DB
+5. Block 15 finalized → tx hard-deleted
+
+## Architecture: Pre-add vs Post-event Rules
+
+**Pre-add rules** (run during `addPendingTxs`):
+- Used for external transactions entering the pool
+- Can reject the incoming tx entirely
+- Can evict lower-priority existing txs to make room
+- Rules: NullifierConflictRule, FeePayerBalancePreAddRule, LowPriorityPreAddRule
+
+**Post-event rules** (run after state transitions):
+- Used for internal state changes (block mined, reorg, slot change)
+- Only evict txs already in the pool
+- Rules: InvalidTxsAfterMiningRule, InvalidTxsAfterReorgRule, FeePayerBalanceEvictionRule, LowPriorityEvictionRule
+
+This design choice means restored txs (from protected/mined states) use post-event rules only, because they were already validated on initial submission.
+
+## Eviction Rules
+
+The pool uses a pluggable rule system for managing transactions.
+
+### Pre-Add Rules
+
+Checked before adding a transaction to the pending pool:
+
+| Rule | Purpose |
+|------|---------|
+| `NullifierConflictRule` | Handles transactions with conflicting nullifiers. Higher priority tx wins. |
+| `FeePayerBalancePreAddRule` | Ensures fee payer has sufficient balance for all their pending txs. |
+| `LowPriorityPreAddRule` | Rejects txs when pool is full and new tx has lowest priority. |
+
+### Post-Event Eviction Rules
+
+Run after events to clean up the pool:
+
+| Rule | Trigger | Purpose |
+|------|---------|---------|
+| `LowPriorityEvictionRule` | `txs_added` | Evicts lowest priority txs when pool exceeds limit. |
+| `FeePayerBalanceEvictionRule` | `txs_added`, `block_mined`, `chain_pruned` | Evicts txs when fee payer has insufficient balance. |
+| `InvalidTxsAfterMiningRule` | `block_mined` | Evicts pending txs with: (1) nullifiers in mined block, (2) expired timestamp. |
+| `InvalidTxsAfterReorgRule` | `chain_pruned` | Evicts txs with invalid anchor blocks after reorg. |
+
+## Usage
+
+### Creating a Pool
+
+```typescript
+import { AztecKVTxPoolV2 } from './tx_pool_v2.js';
+
+const pool = new AztecKVTxPoolV2(txStore, archiveStore, {
+  l2BlockSource: archiver,
+  worldStateSynchronizer: worldState,
+  createTxValidator: () => validator,
+});
+
+await pool.start();
+```
+
+### Adding Transactions
+
+```typescript
+// Add to pending pool (validates and runs pre-add rules)
+const result = await pool.addPendingTxs(txs, { source: 'gossip' });
+// result: { accepted: TxHash[], ignored: TxHash[], rejected: TxHash[] }
+
+// Check without modifying pool
+const canAdd = await pool.canAddPendingTx(tx);
+// canAdd: 'accepted' | 'ignored' | 'rejected'
+```
+
+### Block Building Flow
+
+```typescript
+// 1. Proposer protects txs for their block
+await pool.protectTxs(selectedTxHashes, blockHeader);
+
+// 2. On successful mining
+await pool.handleMinedBlock(minedTxHashes, blockHeader);
+
+// 3. If slot passes without mining
+await pool.prepareForSlot(nextSlotNumber);
+
+// 4. On finalization
+await pool.handleFinalizedBlock(finalizedBlockHeader);
+```
+
+### Handling Reorgs
+
+```typescript
+// When blocks are pruned, un-mine affected transactions
+await pool.handlePrunedBlocks(latestValidBlockId);
+```
+
+## Configuration
+
+```typescript
+await pool.updateConfig({
+  maxPendingTxCount: 10000,  // 0 = unlimited
+  archivedTxLimit: 1000,     // 0 = disabled
+});
+```
+
+## Return Values
+
+### AddTxsResult
+
+When adding pending transactions, each tx is categorized:
+
+| Status | Meaning |
+|--------|---------|
+| `accepted` | Successfully added to the pool |
+| `ignored` | Valid but not added (duplicate, lost nullifier conflict, insufficient balance) |
+| `rejected` | Failed validation (invalid proof, expired, etc.) |
+
+## Archive
+
+Finalized transactions can optionally be archived for historical queries:
+
+```typescript
+const archivedTx = await pool.getArchivedTxByHash(txHash);
+```
+
+The archive uses FIFO eviction when `archivedTxLimit` is reached.
+
+## Testing
+
+```bash
+# Unit tests (177 tests)
+yarn test src/mem_pools/tx_pool_v2/tx_pool_v2.test.ts
+
+# Deleted pool tests (17 tests)
+yarn test src/mem_pools/tx_pool_v2/deleted_pool.test.ts
+
+# Compatibility tests (25 tests)
+yarn test src/mem_pools/tx_pool_v2/tx_pool_v2.compat.test.ts
+
+# Eviction rule tests
+yarn test src/mem_pools/tx_pool_v2/eviction/
+
+# Benchmarks
+yarn test src/mem_pools/tx_pool_v2/tx_pool_v2_bench.test.ts
+```

package/src/mem_pools/tx_pool_v2/archive/index.ts

@@ -0,0 +1 @@
+export { TxArchive } from './tx_archive.js';

package/src/mem_pools/tx_pool_v2/archive/tx_archive.ts

@@ -0,0 +1,120 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+import { ChonkProof } from '@aztec/stdlib/proofs';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */
+export class TxArchive {
+  #store: AztecAsyncKVStore;
+  #txs: AztecAsyncMap<string, Buffer>;
+  #indices: AztecAsyncMap<number, string>;
+  #limit: number;
+  #log: Logger;
+
+  constructor(store: AztecAsyncKVStore, limit: number, log?: Logger) {
+    this.#store = store;
+    this.#txs = store.openMap('archivedTxs');
+    this.#indices = store.openMap('archivedTxIndices');
+    this.#limit = limit;
+    this.#log = log ?? createLogger('p2p:tx_pool_v2:archive');
+  }
+
+  /**
+   * Updates the maximum number of archived transactions.
+   */
+  updateLimit(limit: number): void {
+    this.#limit = limit;
+  }
+
+  /**
+   * Gets the current archive limit.
+   */
+  getLimit(): number {
+    return this.#limit;
+  }
+
+  /**
+   * Checks if archiving is enabled.
+   */
+  isEnabled(): boolean {
+    return this.#limit > 0;
+  }
+
+  /**
+   * Archives transactions, stripping their proofs.
+   * Evicts oldest transactions if the limit is exceeded.
+   */
+  async archiveTxs(txs: Tx[]): Promise<void> {
+    if (!this.isEnabled() || txs.length === 0) {
+      return;
+    }
+
+    try {
+      await this.#store.transactionAsync(async () => {
+        // Get current head and tail indices
+        let headIdx = await this.getHeadIndex();
+        let tailIdx = await this.getTailIndex();
+
+        for (const tx of txs) {
+          // Evict oldest entries if at capacity
+          while (headIdx - tailIdx >= this.#limit) {
+            const txHashToEvict = await this.#indices.getAsync(tailIdx);
+            if (txHashToEvict) {
+              await this.#txs.delete(txHashToEvict);
+              await this.#indices.delete(tailIdx);
+            }
+            tailIdx++;
+          }
+
+          // Archive the transaction with stripped proof
+          const archivedTx = this.stripProof(tx);
+          const txHash = tx.getTxHash().toString();
+          await this.#txs.set(txHash, archivedTx.toBuffer());
+          await this.#indices.set(headIdx, txHash);
+          headIdx++;
+        }
+
+        this.#log.debug(`Archived ${txs.length} txs, total: ${headIdx - tailIdx}`);
+      });
+    } catch (error) {
+      this.#log.error('Error archiving transactions', { error });
+    }
+  }
+
+  /**
+   * Retrieves an archived transaction by its hash.
+   */
+  async getTxByHash(txHash: TxHash): Promise<Tx | undefined> {
+    const buffer = await this.#txs.getAsync(txHash.toString());
+    return buffer ? Tx.fromBuffer(buffer) : undefined;
+  }
+
+  /**
+   * Gets the current count of archived transactions.
+   */
+  async getCount(): Promise<number> {
+    const head = await this.getHeadIndex();
+    const tail = await this.getTailIndex();
+    return head - tail;
+  }
+
+  /**
+   * Strips the proof from a transaction for archival.
+   */
+  private stripProof(tx: Tx): Tx {
+    return new Tx(tx.txHash, tx.data, ChonkProof.empty(), tx.contractClassLogFields, tx.publicFunctionCalldata);
+  }
+
+  private async getHeadIndex(): Promise<number> {
+    const entry = await this.#indices.entriesAsync({ limit: 1, reverse: true }).next();
+    return (entry.value?.[0] ?? -1) + 1;
+  }
+
+  private async getTailIndex(): Promise<number> {
+    const entry = await this.#indices.entriesAsync({ limit: 1 }).next();
+    return entry.value?.[0] ?? 0;
+  }
+}

package/src/mem_pools/tx_pool_v2/deleted_pool.ts

@@ -0,0 +1,234 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+
+/**
+ * State stored for each transaction from a pruned block.
+ */
+type DeletedTxState = {
+  /** Block number in which the transaction was originally mined (before being un-mined by a prune) */
+  minedAtBlock: BlockNumber;
+  /** Whether the transaction has been soft-deleted (removed from indices) */
+  softDeleted: boolean;
+};
+
+/**
+ * Serializes DeletedTxState to a Buffer.
+ * Format: 4 bytes for blockNumber (uint32) + 1 byte for softDeleted (0 or 1)
+ */
+function serializeState(state: DeletedTxState): Buffer {
+  const buffer = Buffer.alloc(5);
+  buffer.writeUInt32BE(Number(state.minedAtBlock), 0);
+  buffer.writeUInt8(state.softDeleted ? 1 : 0, 4);
+  return buffer;
+}
+
+/**
+ * Deserializes a Buffer to DeletedTxState.
+ */
+function deserializeState(buffer: Buffer): DeletedTxState {
+  return {
+    minedAtBlock: BlockNumber(buffer.readUInt32BE(0)),
+    softDeleted: buffer.readUInt8(4) === 1,
+  };
+}
+
+/**
+ * Manages all transaction deletions in the pool.
+ *
+ * When a chain prune (reorg) happens, transactions from pruned blocks are tracked here.
+ * This class is responsible for ALL deletion decisions:
+ *
+ * - Transactions from pruned blocks are "soft deleted" - removed from indices but kept
+ *   in the database for later re-execution
+ * - Transactions NOT from pruned blocks are "hard deleted" - completely removed from DB
+ *
+ * When a block is finalized, soft-deleted transactions that were originally mined at or
+ * before that block number are permanently (hard) deleted.
+ */
+export class DeletedPool {
+  /** Persisted map: txHash -> DeletedTxState (serialized) */
+  #deletedTxsDB: AztecAsyncMap<string, Buffer>;
+
+  /** Reference to the main txs database for hard deletion */
+  #txsDB: AztecAsyncMap<string, Buffer>;
+
+  /** In-memory state for transactions from pruned blocks */
+  #state: Map<string, DeletedTxState> = new Map();
+
+  #log: Logger;
+
+  constructor(store: AztecAsyncKVStore, txsDB: AztecAsyncMap<string, Buffer>, log: Logger) {
+    this.#deletedTxsDB = store.openMap('deleted_txs');
+    this.#txsDB = txsDB;
+    this.#log = log;
+  }
+
+  /**
+   * Loads state from the database on startup.
+   */
+  async hydrateFromDatabase(): Promise<void> {
+    let prunedCount = 0;
+    let softDeletedCount = 0;
+
+    for await (const [txHash, buffer] of this.#deletedTxsDB.entriesAsync()) {
+      const state = deserializeState(buffer);
+      this.#state.set(txHash, state);
+      prunedCount++;
+      if (state.softDeleted) {
+        softDeletedCount++;
+      }
+    }
+
+    if (prunedCount > 0 || softDeletedCount > 0) {
+      this.#log.info(`Loaded ${prunedCount} txs from pruned blocks, ${softDeletedCount} soft-deleted`);
+    }
+  }
+
+  /**
+   * Marks transactions as being from a pruned block.
+   * Called during handlePrunedBlocks for ALL transactions that were un-mined.
+   *
+   * If a tx was previously tracked (e.g., mined at block 4, pruned, re-mined at block 5,
+   * pruned again), updates to the higher block number. This ensures the tx is kept until
+   * its most recent mined block is finalized.
+   *
+   * @param txs - Array of {txHash, minedAtBlock} pairs, where minedAtBlock is the block
+   *              number in which the tx was mined before being un-mined
+   */
+  async markFromPrunedBlock(txs: { txHash: string; minedAtBlock: BlockNumber }[]): Promise<void> {
+    if (txs.length === 0) {
+      return;
+    }
+
+    let count = 0;
+    for (const { txHash, minedAtBlock } of txs) {
+      const existing = this.#state.get(txHash);
+      // Update if not tracked, or if this is a higher mined block (tx was re-mined then pruned again)
+      if (existing === undefined || minedAtBlock > existing.minedAtBlock) {
+        const state: DeletedTxState = {
+          minedAtBlock,
+          softDeleted: existing?.softDeleted ?? false,
+        };
+        this.#state.set(txHash, state);
+        await this.#deletedTxsDB.set(txHash, serializeState(state));
+        count++;
+      }
+    }
+
+    if (count > 0) {
+      this.#log.debug(`Marked ${count} transactions from pruned blocks`);
+    }
+  }
+
+  /**
+   * Deletes a transaction. This is the single entry point for ALL deletions.
+   *
+   * - If the tx is from a pruned block: soft-delete (keep in DB, mark as deleted)
+   * - If the tx is NOT from a pruned block: hard-delete (remove from DB)
+   *
+   * @returns 'soft' if soft-deleted, 'hard' if hard-deleted
+   */
+  async deleteTx(txHash: string): Promise<'soft' | 'hard'> {
+    const existing = this.#state.get(txHash);
+    if (existing !== undefined) {
+      // Soft delete - keep in DB
+      const state: DeletedTxState = {
+        minedAtBlock: existing.minedAtBlock,
+        softDeleted: true,
+      };
+      this.#state.set(txHash, state);
+      await this.#deletedTxsDB.set(txHash, serializeState(state));
+      return 'soft';
+    } else {
+      // Hard delete - remove from DB
+      await this.#txsDB.delete(txHash);
+      return 'hard';
+    }
+  }
+
+  /**
+   * Clears tracking for a transaction if it re-mines at a block number >= the tracked minedAtBlock.
+   *
+   * When a tx re-mines at a higher (or equal) block, the old high-water mark is no longer needed:
+   * any future prune would re-add the tx with an even higher block number. Clearing keeps
+   * DeletedPool consistent — only txs that are actually un-mined should be tracked here.
+   *
+   * When a tx re-mines at a lower block, we must preserve the existing entry to retain
+   * the high-water mark for re-execution purposes.
+   */
+  async clearIfMinedHigher(txHash: string, minedAtBlock: BlockNumber): Promise<void> {
+    const existing = this.#state.get(txHash);
+    if (existing !== undefined && minedAtBlock >= existing.minedAtBlock) {
+      this.#state.delete(txHash);
+      await this.#deletedTxsDB.delete(txHash);
+      this.#log.debug(
+        `Cleared tracking for tx ${txHash}: re-mined at block ${minedAtBlock} (was ${existing.minedAtBlock})`,
+      );
+    }
+  }
+
+  /**
+   * Checks if a transaction is from a pruned block.
+   */
+  isFromPrunedBlock(txHash: string): boolean {
+    return this.#state.has(txHash);
+  }
+
+  /**
+   * Checks if a transaction is soft-deleted.
+   */
+  isSoftDeleted(txHash: string): boolean {
+    return this.#state.get(txHash)?.softDeleted ?? false;
+  }
+
+  /**
+   * Gets the block number in which a transaction was originally mined.
+   */
+  getMinedAtBlock(txHash: string): BlockNumber | undefined {
+    return this.#state.get(txHash)?.minedAtBlock;
+  }
+
+  /**
+   * Finalizes transactions when a block is finalized.
+   * Hard-deletes transactions that were originally mined at or before the finalized block.
+   *
+   * @returns The hashes of transactions that were hard-deleted
+   */
+  async finalizeBlock(finalizedBlockNumber: BlockNumber): Promise<string[]> {
+    const toHardDelete: string[] = [];
+    for (const [txHash, state] of this.#state) {
+      if (state.softDeleted && state.minedAtBlock <= finalizedBlockNumber) {
+        toHardDelete.push(txHash);
+      }
+    }
+
+    if (toHardDelete.length === 0) {
+      return [];
+    }
+
+    // Hard-delete from all stores
+    for (const txHash of toHardDelete) {
+      this.#state.delete(txHash);
+      await this.#deletedTxsDB.delete(txHash);
+      await this.#txsDB.delete(txHash);
+    }
+
+    this.#log.debug(`Finalized ${toHardDelete.length} txs from pruned blocks at block ${finalizedBlockNumber}`);
+    return toHardDelete;
+  }
+
+  /**
+   * Gets the count of transactions from pruned blocks.
+   */
+  getCount(): number {
+    return this.#state.size;
+  }
+
+  /**
+   * Gets all transaction hashes from pruned blocks.
+   */
+  getPrunedTxHashes(): string[] {
+    return Array.from(this.#state.keys());
+  }
+}