@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f8ca9b2f3

package/src/mem_pools/tx_pool_v2/tx_pool_v2_impl.ts

@@ -1,4 +1,4 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { Logger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
@@ -10,6 +10,7 @@ import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { BlockHeader, Tx, TxHash, type TxValidator } from '@aztec/stdlib/tx';
 
 import { TxArchive } from './archive/index.js';
+import { DeletedPool } from './deleted_pool.js';
 import {
   EvictionManager,
   FeePayerBalanceEvictionRule,
@@ -53,7 +54,7 @@ export class TxPoolV2Impl {
   // === Dependencies ===
   #l2BlockSource: L2BlockSource;
   #worldStateSynchronizer: WorldStateSynchronizer;
-  #pendingTxValidator: TxValidator<Tx>;
+  #createTxValidator: TxPoolV2Dependencies['createTxValidator'];
 
   // === In-Memory Indices ===
   #indices: TxPoolIndices = new TxPoolIndices();
@@ -61,6 +62,7 @@ export class TxPoolV2Impl {
   // === Config & Services ===
   #config: TxPoolV2Config;
   #archive: TxArchive;
+  #deletedPool: DeletedPool;
   #evictionManager: EvictionManager;
   #log: Logger;
   #callbacks: TxPoolV2Callbacks;
@@ -78,10 +80,11 @@ export class TxPoolV2Impl {
 
     this.#l2BlockSource = deps.l2BlockSource;
     this.#worldStateSynchronizer = deps.worldStateSynchronizer;
-    this.#pendingTxValidator = deps.pendingTxValidator;
+    this.#createTxValidator = deps.createTxValidator;
 
     this.#config = { ...DEFAULT_TX_POOL_V2_CONFIG, ...config };
     this.#archive = new TxArchive(archiveStore, this.#config.archivedTxLimit, log);
+    this.#deletedPool = new DeletedPool(store, this.#txsDB, log);
     this.#log = log;
     this.#callbacks = callbacks;
 
@@ -116,7 +119,10 @@ export class TxPoolV2Impl {
    * by running pre-add rules to resolve nullifier conflicts, balance checks, and pool size limits.
    */
   async hydrateFromDatabase(): Promise<void> {
-    // Step 1: Load all transactions from DB
+    // Step 0: Hydrate deleted pool state
+    await this.#deletedPool.hydrateFromDatabase();
+
+    // Step 1: Load all transactions from DB (excluding soft-deleted)
     const { loaded, errors: deserializationErrors } = await this.#loadAllTxsFromDb();
 
     // Step 2: Check mined status for each tx
@@ -134,7 +140,10 @@ export class TxPoolV2Impl {
     }
 
     // Step 4: Validate non-mined transactions
-    const { valid, invalid } = await this.#validateTxBatch(nonMined, 'on startup');
+    const { valid, invalid } = await this.#revalidateMetadata(
+      nonMined.map(e => e.meta),
+      'on startup',
+    );
 
     // Step 5: Populate mined indices (these don't need conflict resolution)
     for (const meta of mined) {
@@ -229,13 +238,13 @@ export class TxPoolV2Impl {
     const txHash = tx.getTxHash();
     const txHashStr = txHash.toString();
 
-    // Validate transaction
-    if (!(await this.#validateTx(tx))) {
+    // Build metadata and validate using metadata
+    const meta = await buildTxMetaData(tx);
+    if (!(await this.#validateMeta(meta))) {
       return { status: 'rejected' };
     }
 
-    // Build metadata and run pre-add rules
-    const meta = await buildTxMetaData(tx);
+    // Run pre-add rules
     const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess);
 
     if (preAddResult.shouldIgnore) {
@@ -267,14 +276,14 @@ export class TxPoolV2Impl {
       return 'ignored';
     }
 
-    // Validate transaction (no logging for dry-run check)
-    const validationResult = await this.#pendingTxValidator.validateTx(tx);
-    if (validationResult.result !== 'valid') {
+    // Build metadata and validate using metadata
+    const meta = await buildTxMetaData(tx);
+    const validationResult = await this.#validateMeta(meta, undefined, 'can add pending');
+    if (validationResult !== true) {
       return 'rejected';
     }
 
-    // Build metadata and use pre-add rules
-    const meta = await buildTxMetaData(tx);
+    // Use pre-add rules
     const poolAccess = this.#createPreAddPoolAccess();
     const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess);
 
@@ -347,6 +356,7 @@ export class TxPoolV2Impl {
           // Add new mined tx (callback emitted by #addTx)
           await this.#addTx(tx, { mined: blockId }, opts);
         }
+        await this.#deletedPool.clearIfMinedHigher(txHashStr, blockId.number);
       }
     });
   }
@@ -373,6 +383,7 @@ export class TxPoolV2Impl {
     // Step 4: Mark txs as mined (only those we have in the pool)
     for (const meta of found) {
       this.#indices.markAsMined(meta, blockId);
+      await this.#deletedPool.clearIfMinedHigher(meta.txHash, blockId.number);
     }
 
     // Step 5: Run eviction rules (remove pending txs with conflicting nullifiers/expired timestamps)
@@ -397,7 +408,7 @@ export class TxPoolV2Impl {
     this.#log.info(`Preparing for slot ${slotNumber}: unprotecting ${txsToRestore.length} txs`);
 
     // Step 4: Validate for pending pool
-    const { valid, invalid } = await this.#loadAndValidateTxs(txsToRestore, 'during prepareForSlot');
+    const { valid, invalid } = await this.#revalidateMetadata(txsToRestore, 'during prepareForSlot');
 
     // Step 5: Resolve nullifier conflicts and add winners to pending indices
     const { added, toEvict } = this.#applyNullifierConflictResolution(valid);
@@ -426,24 +437,34 @@ export class TxPoolV2Impl {
 
     this.#log.info(`Handling prune to block ${latestBlock.number}: un-mining ${txsToUnmine.length} txs`);
 
-    // Step 2: Unmine - clear mined status from metadata
+    // Step 2: Mark ALL un-mined txs with their original mined block number
+    // This ensures they get soft-deleted if removed later, and only hard-deleted
+    // when their original mined block is finalized
+    await this.#deletedPool.markFromPrunedBlock(
+      txsToUnmine.map(m => ({
+        txHash: m.txHash,
+        minedAtBlock: BlockNumber(m.minedL2BlockId!.number),
+      })),
+    );
+
+    // Step 3: Unmine - clear mined status from metadata
     for (const meta of txsToUnmine) {
       this.#indices.markAsUnmined(meta);
     }
 
-    // Step 3: Filter out protected txs (they'll be handled by prepareForSlot)
+    // Step 4: Filter out protected txs (they'll be handled by prepareForSlot)
     const unprotectedTxs = this.#indices.filterUnprotected(txsToUnmine);
 
     // Step 4: Validate for pending pool
-    const { valid, invalid } = await this.#loadAndValidateTxs(unprotectedTxs, 'during handlePrunedBlocks');
+    const { valid, invalid } = await this.#revalidateMetadata(unprotectedTxs, 'during handlePrunedBlocks');
 
-    // Step 5: Resolve nullifier conflicts and add winners to pending indices
+    // Step 6: Resolve nullifier conflicts and add winners to pending indices
     const { toEvict } = this.#applyNullifierConflictResolution(valid);
 
-    // Step 6: Delete invalid and evicted txs
+    // Step 7: Delete invalid and evicted txs
     await this.#deleteTxsBatch([...invalid, ...toEvict]);
 
-    // Step 7: Run eviction rules for ALL pending txs (not just restored ones)
+    // Step 8: Run eviction rules for ALL pending txs (not just restored ones)
     // This handles cases like existing pending txs with invalid fee payer balances
     await this.#evictionManager.evictAfterChainPrune(latestBlock.number);
   }
@@ -458,16 +479,13 @@ export class TxPoolV2Impl {
   async handleFinalizedBlock(block: BlockHeader): Promise<void> {
     const blockNumber = block.globalVariables.blockNumber;
 
-    // Step 1: Find txs mined at or before finalized block
-    const txsToFinalize = this.#indices.findTxsMinedAtOrBefore(blockNumber);
-    if (txsToFinalize.length === 0) {
-      return;
-    }
+    // Step 1: Find mined txs at or before finalized block
+    const minedTxsToFinalize = this.#indices.findTxsMinedAtOrBefore(blockNumber);
 
-    // Step 2: Collect txs for archiving (before deletion)
+    // Step 2: Collect mined txs for archiving (before deletion)
     const txsToArchive: Tx[] = [];
     if (this.#archive.isEnabled()) {
-      for (const txHashStr of txsToFinalize) {
+      for (const txHashStr of minedTxsToFinalize) {
         const buffer = await this.#txsDB.getAsync(txHashStr);
         if (buffer) {
           txsToArchive.push(Tx.fromBuffer(buffer));
@@ -475,15 +493,20 @@ export class TxPoolV2Impl {
       }
     }
 
-    // Step 3: Delete from active pool
-    await this.#deleteTxsBatch(txsToFinalize);
+    // Step 3: Delete mined txs from active pool
+    await this.#deleteTxsBatch(minedTxsToFinalize);
+
+    // Step 4: Finalize soft-deleted txs
+    await this.#deletedPool.finalizeBlock(blockNumber);
 
-    // Step 4: Archive
+    // Step 5: Archive mined txs
     if (txsToArchive.length > 0) {
       await this.#archive.archiveTxs(txsToArchive);
     }
 
-    this.#log.info(`Finalized ${txsToFinalize.length} txs from blocks up to ${blockNumber}`);
+    if (minedTxsToFinalize.length > 0) {
+      this.#log.info(`Finalized ${minedTxsToFinalize.length} mined txs from blocks up to ${blockNumber}`);
+    }
   }
 
   // === Query Methods ===
@@ -503,15 +526,23 @@ export class TxPoolV2Impl {
   }
 
   hasTxs(txHashes: TxHash[]): boolean[] {
-    return txHashes.map(h => this.#indices.has(h.toString()));
+    return txHashes.map(h => {
+      const hashStr = h.toString();
+      return this.#indices.has(hashStr) || this.#deletedPool.isSoftDeleted(hashStr);
+    });
   }
 
   getTxStatus(txHash: TxHash): TxState | undefined {
-    const meta = this.#indices.getMetadata(txHash.toString());
-    if (!meta) {
-      return undefined;
+    const txHashStr = txHash.toString();
+    const meta = this.#indices.getMetadata(txHashStr);
+    if (meta) {
+      return this.#indices.getTxState(meta);
+    }
+    // Check if soft-deleted
+    if (this.#deletedPool.isSoftDeleted(txHashStr)) {
+      return 'deleted';
     }
-    return this.#indices.getTxState(meta);
+    return undefined;
   }
 
   getPendingTxHashes(): TxHash[] {
@@ -624,10 +655,15 @@ export class TxPoolV2Impl {
    * Deletes a transaction from both indices and DB.
    * Emits onTxsRemoved callback immediately after DB delete.
    */
+  /**
+   * Deletes a transaction from the pool.
+   * Delegates to DeletedPool which decides soft vs hard delete based on whether
+   * the tx is from a pruned block.
+   */
   async #deleteTx(txHashStr: string): Promise<void> {
     this.#indices.remove(txHashStr);
-    await this.#txsDB.delete(txHashStr);
     this.#callbacks.onTxsRemoved([txHashStr]);
+    await this.#deletedPool.deleteTx(txHashStr);
   }
 
   /** Deletes a batch of transactions, emitting callbacks individually for each. */
@@ -641,64 +677,36 @@ export class TxPoolV2Impl {
   // PRIVATE HELPERS - Validation & Conflict Resolution
   // ============================================================================
 
-  /** Validates a single transaction, returning true if valid */
-  async #validateTx(tx: Tx, context?: string): Promise<boolean> {
-    const result = await this.#pendingTxValidator.validateTx(tx);
+  /** Validates transaction metadata, returning true if valid */
+  async #validateMeta(meta: TxMetaData, validator?: TxValidator<TxMetaData>, context?: string): Promise<boolean> {
+    const txValidator = validator ?? (await this.#createTxValidator());
+    const result = await txValidator.validateTx(meta);
     if (result.result !== 'valid') {
       const contextStr = context ? ` ${context}` : '';
-      this.#log.info(`Tx ${tx.getTxHash()}${contextStr} failed validation: ${result.reason?.join(', ')}`);
+      this.#log.info(`Tx ${meta.txHash}${contextStr} failed validation: ${result.reason?.join(', ')}`);
       return false;
     }
     return true;
   }
 
-  /** Loads transactions from DB, returning loaded txs and missing hashes */
-  async #loadTxsFromDb(metas: TxMetaData[]): Promise<{ loaded: { tx: Tx; meta: TxMetaData }[]; missing: string[] }> {
-    const loaded: { tx: Tx; meta: TxMetaData }[] = [];
-    const missing: string[] = [];
-
-    for (const meta of metas) {
-      const buffer = await this.#txsDB.getAsync(meta.txHash);
-      if (!buffer) {
-        this.#log.warn(`Tx ${meta.txHash} not found in DB`);
-        missing.push(meta.txHash);
-        continue;
-      }
-      loaded.push({ tx: Tx.fromBuffer(buffer), meta });
-    }
-
-    return { loaded, missing };
-  }
-
-  /** Validates a batch of transactions, returning valid and invalid groups */
-  async #validateTxBatch(
-    txs: { tx: Tx; meta: TxMetaData }[],
+  /** Validates metadata directly */
+  async #revalidateMetadata(
+    metas: TxMetaData[],
     context?: string,
   ): Promise<{ valid: TxMetaData[]; invalid: string[] }> {
     const valid: TxMetaData[] = [];
     const invalid: string[] = [];
-
-    for (const { tx, meta } of txs) {
-      if (await this.#validateTx(tx, context)) {
+    const validator = await this.#createTxValidator();
+    for (const meta of metas) {
+      if (await this.#validateMeta(meta, validator, context)) {
         valid.push(meta);
       } else {
         invalid.push(meta.txHash);
       }
     }
-
     return { valid, invalid };
   }
 
-  /** Loads transactions from DB and validates them */
-  async #loadAndValidateTxs(
-    metas: TxMetaData[],
-    context?: string,
-  ): Promise<{ valid: TxMetaData[]; invalid: string[] }> {
-    const { loaded, missing } = await this.#loadTxsFromDb(metas);
-    const { valid, invalid } = await this.#validateTxBatch(loaded, context);
-    return { valid, invalid: [...missing, ...invalid] };
-  }
-
   /**
    * Resolves nullifier conflicts between incoming txs and existing pending txs.
    * Modifies the pending indices during iteration to maintain consistent state
@@ -768,6 +776,11 @@ export class TxPoolV2Impl {
     const errors: string[] = [];
 
     for await (const [txHashStr, buffer] of this.#txsDB.entriesAsync()) {
+      // Skip soft-deleted transactions - they stay in DB but not in indices
+      if (this.#deletedPool.isSoftDeleted(txHashStr)) {
+        continue;
+      }
+
       try {
         const tx = Tx.fromBuffer(buffer);
         const meta = await buildTxMetaData(tx);

package/src/msg_validators/tx_validator/aggregate_tx_validator.ts

@@ -1,6 +1,6 @@
-import type { ProcessedTx, Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
+import type { TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 
-export class AggregateTxValidator<T extends Tx | ProcessedTx> implements TxValidator<T> {
+export class AggregateTxValidator<T> implements TxValidator<T> {
   #validators: TxValidator<T>[];
   constructor(...validators: TxValidator<T>[]) {
     if (validators.length === 0) {

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -1,12 +1,24 @@
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { BlockHash } from '@aztec/stdlib/block';
-import { type AnyTx, TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+import { TX_ERROR_BLOCK_HEADER, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export interface ArchiveSource {
   getArchiveIndices: (archives: BlockHash[]) => Promise<(bigint | undefined)[]>;
 }
 
-export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
+/** Structural interface for block header validation. */
+export interface HasBlockHeaderData {
+  txHash: { toString(): string };
+  data: {
+    constants: {
+      anchorBlockHeader: {
+        hash(): Promise<BlockHash>;
+      };
+    };
+  };
+}
+
+export class BlockHeaderTxValidator<T extends HasBlockHeaderData> implements TxValidator<T> {
   #log: Logger;
   #archiveSource: ArchiveSource;
 
@@ -18,7 +30,7 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   async validateTx(tx: T): Promise<TxValidationResult> {
     const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
     if (index === undefined) {
-      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };

package/src/msg_validators/tx_validator/double_spend_validator.ts

@@ -1,9 +1,8 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import {
-  type AnyTx,
   TX_ERROR_DUPLICATE_NULLIFIER_IN_TX,
   TX_ERROR_EXISTING_NULLIFIER,
-  Tx,
   type TxValidationResult,
   type TxValidator,
 } from '@aztec/stdlib/tx';
@@ -12,7 +11,13 @@ export interface NullifierSource {
   nullifiersExist: (nullifiers: Buffer[]) => Promise<boolean[]>;
 }
 
-export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
+/** Structural interface for double-spend validation. */
+export interface HasNullifierData {
+  txHash: { toString(): string };
+  data: { getNonEmptyNullifiers(): Fr[] };
+}
+
+export class DoubleSpendTxValidator<T extends HasNullifierData> implements TxValidator<T> {
   #log: Logger;
   #nullifierSource: NullifierSource;
 
@@ -22,17 +27,17 @@ export class DoubleSpendTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const nullifiers = tx instanceof Tx ? tx.data.getNonEmptyNullifiers() : tx.txEffect.nullifiers;
+    const nullifiers = tx.data.getNonEmptyNullifiers();
 
     // Ditch this tx if it has repeated nullifiers
     const uniqueNullifiers = new Set(nullifiers.map(n => n.toBigInt()));
     if (uniqueNullifiers.size !== nullifiers.length) {
-      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for emitting duplicate nullifiers`);
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for emitting duplicate nullifiers`);
       return { result: 'invalid', reason: [TX_ERROR_DUPLICATE_NULLIFIER_IN_TX] };
     }
 
     if ((await this.#nullifierSource.nullifiersExist(nullifiers.map(n => n.toBuffer()))).some(Boolean)) {
-      this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for repeating a nullifier`);
+      this.#log.verbose(`Rejecting tx ${tx.txHash} for repeating a nullifier`);
       return { result: 'invalid', reason: [TX_ERROR_EXISTING_NULLIFIER] };
     }
 

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,15 +1,24 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
-import {
-  type AnyTx,
-  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
-  type TxValidationResult,
-  type TxValidator,
-  getTxHash,
-} from '@aztec/stdlib/tx';
+import { TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
+/** Structural interface for timestamp validation. */
+export interface HasTimestampData {
+  txHash: { toString(): string };
+  data: {
+    includeByTimestamp: bigint;
+    constants: {
+      anchorBlockHeader: {
+        globalVariables: {
+          blockNumber: BlockNumber;
+        };
+      };
+    };
+  };
+}
+
+export class TimestampTxValidator<T extends HasTimestampData> implements TxValidator<T> {
   #log: Logger;
 
   constructor(
@@ -38,11 +47,7 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${getTxHash(
-          tx,
-        )} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
-          this.values.timestamp
-        }.`,
+        `Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${this.values.timestamp}.`,
       );
       return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
     } else {

package/src/services/dummy_service.ts

@@ -26,6 +26,7 @@ import { ReqRespStatus } from './reqresp/status.js';
 import {
   type P2PBlockReceivedCallback,
   type P2PCheckpointReceivedCallback,
+  type P2PDuplicateAttestationCallback,
   type P2PDuplicateProposalCallback,
   type P2PService,
   type PeerDiscoveryService,
@@ -88,6 +89,11 @@ export class DummyP2PService implements P2PService {
    */
   public registerDuplicateProposalCallback(_callback: P2PDuplicateProposalCallback): void {}
 
+  /**
+   * Register a callback for when a duplicate attestation is detected
+   */
+  public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {}
+
   /**
    * Sends a request to a peer.
    * @param _protocol - The protocol to send the request on.

package/src/services/encoding.ts

@@ -78,11 +78,11 @@ export class SnappyTransform implements DataTransform {
     return this.inboundTransformData(Buffer.from(data), topic);
   }
 
-  public inboundTransformData(data: Buffer, topic?: TopicType): Buffer {
+  public inboundTransformData(data: Buffer, topic?: TopicType, maxSizeKbOverride?: number): Buffer {
     if (data.length === 0) {
       return data;
     }
-    const maxSizeKb = this.maxSizesKb[topic!] ?? this.defaultMaxSizeKb;
+    const maxSizeKb = maxSizeKbOverride ?? this.maxSizesKb[topic!] ?? this.defaultMaxSizeKb;
     const { decompressedSize } = readSnappyPreamble(data);
     if (decompressedSize > maxSizeKb * 1024) {
       this.logger.warn(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);