@aztec/p2p 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,14 +1,20 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import type { AttestationPool } from './attestation_pool.js';
+import { ATTESTATION_CAP_BUFFER, MAX_PROPOSALS_PER_SLOT } from './kv_attestation_pool.js';
 
 export class InMemoryAttestationPool implements AttestationPool {
   private metrics: PoolInstrumentation<BlockAttestation>;
 
-  private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private attestations: Map<
+    /*slot=*/ SlotNumber,
+    Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>
+  >;
   private proposals: Map<string, BlockProposal>;
 
   constructor(
@@ -30,7 +36,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve(this.attestations.size === 0);
   }
 
-  public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
+  public getAttestationsForSlot(slot: SlotNumber): Promise<BlockAttestation[]> {
     return Promise.resolve(
       Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
         Array.from(proposalAttestationMap.values()),
@@ -38,7 +44,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     );
   }
 
-  public getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]> {
+  public getAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<BlockAttestation[]> {
     const slotAttestationMap = this.attestations.get(slot);
     if (slotAttestationMap) {
       const proposalAttestationMap = slotAttestationMap.get(proposalId);
@@ -55,16 +61,26 @@ export class InMemoryAttestationPool implements AttestationPool {
       const slotNumber = attestation.payload.header.slotNumber;
 
       const proposalId = attestation.archive.toString();
-      const address = attestation.getSender();
+      const sender = attestation.getSender();
 
-      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
+      // Skip attestations with invalid signatures
+      if (!sender) {
+        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber}`, {
+          signature: attestation.signature.toString(),
+          slotNumber,
+          proposalId,
+        });
+        continue;
+      }
+
+      const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber);
       const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(address.toString(), attestation);
+      proposalAttestationMap.set(sender.toString(), attestation);
 
-      this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${address}`, {
+      this.log.verbose(`Added attestation for slot ${slotNumber} from ${sender}`, {
         signature: attestation.signature.toString(),
         slotNumber,
-        address,
+        address: sender,
         proposalId,
       });
     }
@@ -72,7 +88,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  #getNumberOfAttestationsInSlot(slot: bigint): number {
+  #getNumberOfAttestationsInSlot(slot: SlotNumber): number {
     let total = 0;
     const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
 
@@ -84,7 +100,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return total;
   }
 
-  public async deleteAttestationsOlderThan(oldestSlot: bigint): Promise<void> {
+  public async deleteAttestationsOlderThan(oldestSlot: SlotNumber): 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.
@@ -105,7 +121,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlot(slot: bigint): Promise<void> {
+  public deleteAttestationsForSlot(slot: SlotNumber): Promise<void> {
     // We count the number of attestations we are removing
     const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
     const proposalIdsToDelete = this.attestations.get(slot)?.keys();
@@ -123,7 +139,7 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
-  public deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
+  public deleteAttestationsForSlotAndProposal(slot: SlotNumber, proposalId: string): Promise<void> {
     const slotAttestationMap = getSlotOrDefault(this.attestations, slot);
     if (slotAttestationMap) {
       if (slotAttestationMap.has(proposalId)) {
@@ -142,24 +158,54 @@ export class InMemoryAttestationPool implements AttestationPool {
   public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       const slotNumber = attestation.payload.header.slotNumber;
-      const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+      const slotAttestationMap = this.attestations.get(slotNumber);
       if (slotAttestationMap) {
         const proposalId = attestation.archive.toString();
         const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
         if (proposalAttestationMap) {
-          const address = attestation.getSender();
-          proposalAttestationMap.delete(address.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+          const sender = attestation.getSender();
+
+          // Skip attestations with invalid signatures
+          if (!sender) {
+            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber}`);
+            continue;
+          }
+
+          proposalAttestationMap.delete(sender.toString());
+          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${sender}`);
         }
       }
     }
     return Promise.resolve();
   }
 
+  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive.toString();
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return Promise.resolve(false);
+    }
+
+    const slotAttestationMap = this.attestations.get(slotNumber);
+    if (!slotAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    const proposalAttestationMap = slotAttestationMap.get(proposalId);
+    if (!proposalAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    return Promise.resolve(proposalAttestationMap.has(sender.toString()));
+  }
+
   public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     // We initialize slot-proposal mapping if it does not exist
     // This is important to ensure we can delete this proposal if there were not attestations for it
-    const slotProposalMapping = getSlotOrDefault(this.attestations, blockProposal.slotNumber.toBigInt());
+    const slotProposalMapping = getSlotOrDefault(this.attestations, blockProposal.slotNumber);
     slotProposalMapping.set(blockProposal.payload.archive.toString(), new Map<string, BlockAttestation>());
 
     this.proposals.set(blockProposal.payload.archive.toString(), blockProposal);
@@ -169,6 +215,38 @@ export class InMemoryAttestationPool implements AttestationPool {
   public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     return Promise.resolve(this.proposals.get(id));
   }
+
+  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
+
+  public hasReachedProposalCap(slot: SlotNumber): Promise<boolean> {
+    const slotAttestationMap = this.attestations.get(slot);
+    const proposalCount = slotAttestationMap?.size ?? 0;
+    return Promise.resolve(proposalCount >= MAX_PROPOSALS_PER_SLOT);
+  }
+
+  public hasReachedAttestationCap(slot: SlotNumber, proposalId: string, committeeSize: number): Promise<boolean> {
+    const limit = committeeSize + ATTESTATION_CAP_BUFFER;
+    const count = this.attestations.get(slot)?.get(proposalId)?.size ?? 0;
+    return Promise.resolve(limit <= 0 || count >= limit);
+  }
+
+  public async canAddProposal(block: BlockProposal): Promise<boolean> {
+    return this.proposals.has(block.archive.toString()) || !(await this.hasReachedProposalCap(block.slotNumber));
+  }
+
+  public async canAddAttestation(attestation: BlockAttestation, committeeSize: number): Promise<boolean> {
+    const sender = attestation.getSender();
+    const slot = attestation.payload.header.slotNumber;
+    const pid = attestation.archive.toString();
+    return (
+      !!sender &&
+      ((this.attestations.get(slot)?.get(pid)?.has(sender.toString()) ?? false) ||
+        !(await this.hasReachedAttestationCap(slot, pid, committeeSize)))
+    );
+  }
 }
 
 /**
@@ -180,8 +258,9 @@ export class InMemoryAttestationPool implements AttestationPool {
  * @returns The slot mapping
  */
 function getSlotOrDefault(
-  map: Map<bigint, Map<string, Map<string, BlockAttestation>>>,
-  slot: bigint,
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  map: Map<SlotNumber, Map<string, Map<string, BlockAttestation>>>,
+  slot: SlotNumber,
 ): Map<string, Map<string, BlockAttestation>> {
   if (!map.has(slot)) {
     map.set(slot, new Map<string, Map<string, BlockAttestation>>());

package/src/mem_pools/attestation_pool/mocks.ts

@@ -1,12 +1,12 @@
-import type { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   BlockAttestation,
   ConsensusPayload,
   SignatureDomainSeparator,
   getHashedSignaturePayloadEthSignedMessage,
 } from '@aztec/stdlib/p2p';
-import { makeHeader } from '@aztec/stdlib/testing';
+import { makeL2BlockHeader } from '@aztec/stdlib/testing';
 
 import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
@@ -32,11 +32,14 @@ export const mockAttestation = (
   archive: Fr = Fr.random(),
 ): BlockAttestation => {
   // Use arbitrary numbers for all other than slot
-  const header = makeHeader(1, 2, slot);
-  const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
+  const header = makeL2BlockHeader(1, 2, slot);
+  const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
 
-  const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-  const signature = signer.sign(hash);
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSignature = signer.sign(attestationHash);
 
-  return new BlockAttestation(header.globalVariables.blockNumber, payload, signature);
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposerSignature = signer.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };

package/src/mem_pools/instrumentation.ts

@@ -10,6 +10,7 @@ import {
   type MetricsType,
   type ObservableGauge,
   type TelemetryClient,
+  type UpDownCounter,
 } from '@aztec/telemetry-client';
 
 export enum PoolName {
@@ -20,6 +21,7 @@ export enum PoolName {
 type MetricsLabels = {
   objectInMempool: MetricsType;
   objectSize: MetricsType;
+  itemsAdded: MetricsType;
 };
 
 /**
@@ -32,11 +34,13 @@ function getMetricsLabels(name: PoolName): MetricsLabels {
     return {
       objectInMempool: Metrics.MEMPOOL_TX_COUNT,
       objectSize: Metrics.MEMPOOL_TX_SIZE,
+      itemsAdded: Metrics.MEMPOOL_TX_ADDED_COUNT,
     };
   } else if (name === PoolName.ATTESTATION_POOL) {
     return {
       objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
       objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
+      itemsAdded: Metrics.MEMPOOL_ATTESTATIONS_ADDED_COUNT,
     };
   }
 
@@ -53,6 +57,7 @@ export type PoolStatsCallback = () => Promise<{
 export class PoolInstrumentation<PoolObject extends Gossipable> {
   /** The number of txs in the mempool */
   private objectsInMempool: ObservableGauge;
+  private addObjectCounter: UpDownCounter;
   /** Tracks tx size */
   private objectSize: Histogram;
 
@@ -89,6 +94,10 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
       dbStats,
     );
 
+    this.addObjectCounter = this.meter.createUpDownCounter(metricsLabels.itemsAdded, {
+      description: 'The number of transactions added to the mempool',
+    });
+
     this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }
 
@@ -96,6 +105,10 @@ export class PoolInstrumentation<PoolObject extends Gossipable> {
     this.objectSize.record(poolObject.getSize());
   }
 
+  public incrementAddedObjects(count: number) {
+    this.addObjectCounter.add(count);
+  }
+
   private observeStats = async (observer: BatchObservableResult) => {
     const { itemCount } = await this.poolStats();
     if (typeof itemCount === 'number') {

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,4 +1,5 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
@@ -6,7 +7,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSi
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
@@ -37,7 +38,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   txPoolOverflowFactor: number = 1;
 
   /** Index from tx hash to the block number in which they were mined, filtered by mined txs. */
-  #minedTxHashToBlock: AztecAsyncMap<string, number>;
+  #minedTxHashToBlock: AztecAsyncMap<string, BlockNumber>;
 
   /** Index from tx priority (stored as hex) to its tx hash, filtered by pending txs. */
   #pendingTxPriorityToHash: AztecAsyncMultiMap<string, string>;
@@ -48,6 +49,12 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   /** Index from tx hash to its header hash, filtered by pending txs. */
   #pendingTxHashToHeaderHash: AztecAsyncMap<string, string>;
 
+  /** Map from tx hash to the block number it was originally mined in (for soft-deleted txs). */
+  #deletedMinedTxHashes: AztecAsyncMap<string, BlockNumber>;
+
+  /** MultiMap from block number to deleted mined tx hashes for efficient cleanup. */
+  #blockToDeletedMinedTxHash: AztecAsyncMultiMap<BlockNumber, string>;
+
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
 
@@ -103,6 +110,8 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
     this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
     this.#pendingTxSize = store.openSingleton('pendingTxSize');
+    this.#deletedMinedTxHashes = store.openMap('deletedMinedTxHashes');
+    this.#blockToDeletedMinedTxHash = store.openMultiMap('blockToDeletedMinedTxHash');
 
     this.#pendingTxs = new Map<string, Tx>();
     this.#nonEvictableTxs = new Set<string>();
@@ -152,6 +161,17 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
+
+        // If this tx was previously soft-deleted, remove it from the deleted sets
+        if (await this.#deletedMinedTxHashes.hasAsync(key)) {
+          const originalBlock = await this.#deletedMinedTxHashes.getAsync(key);
+          await this.#deletedMinedTxHashes.delete(key);
+          // Remove from block-to-hash mapping
+          if (originalBlock !== undefined) {
+            await this.#blockToDeletedMinedTxHash.deleteValue(originalBlock, key);
+          }
+        }
+
         await this.#minedTxHashToBlock.set(key, blockHeader.globalVariables.blockNumber);
 
         const tx = await this.getPendingTxByHash(hash);
@@ -200,10 +220,10 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
     const vals = await toArray(this.#pendingTxPriorityToHash.valuesAsync({ reverse: true }));
-    return vals.map(x => TxHash.fromString(x));
+    return vals.map(TxHash.fromString);
   }
 
-  public async getMinedTxHashes(): Promise<[TxHash, number][]> {
+  public async getMinedTxHashes(): Promise<[TxHash, BlockNumber][]> {
     const vals = await toArray(this.#minedTxHashToBlock.entriesAsync());
     return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
@@ -216,11 +236,17 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return (await this.#minedTxHashToBlock.sizeAsync()) ?? 0;
   }
 
-  public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
+  public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined> {
     const key = txHash.toString();
-    const [isMined, isKnown] = await Promise.all([this.#minedTxHashToBlock.hasAsync(key), this.#txs.hasAsync(key)]);
-
-    if (isMined) {
+    const [isMined, isKnown, isDeleted] = await Promise.all([
+      this.#minedTxHashToBlock.hasAsync(key),
+      this.#txs.hasAsync(key),
+      this.#deletedMinedTxHashes.hasAsync(key),
+    ]);
+
+    if (isDeleted) {
+      return 'deleted';
+    } else if (isMined) {
       return 'mined';
     } else if (isKnown) {
       return 'pending';
@@ -236,30 +262,23 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
    */
   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;
+    return buffer ? Tx.fromBuffer(buffer) : undefined;
   }
 
   async getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
     const txs = await Promise.all(txHashes.map(txHash => this.#txs.getAsync(txHash.toString())));
-    return txs.map((buffer, index) => {
-      if (buffer) {
-        const tx = Tx.fromBuffer(buffer);
-        tx.setTxHash(txHashes[index]);
-        return tx;
-      }
-      return undefined;
-    });
+    return txs.map(buffer => (buffer ? Tx.fromBuffer(buffer) : undefined));
   }
 
   async hasTxs(txHashes: TxHash[]): Promise<boolean[]> {
     return await Promise.all(txHashes.map(txHash => this.#txs.hasAsync(txHash.toString())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   /**
    * Checks if an archived tx exists and returns it.
    * @param txHash - The tx hash.
@@ -267,12 +286,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
    */
   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;
+    return buffer ? Tx.fromBuffer(buffer) : undefined;
   }
 
   /**
@@ -322,10 +336,11 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
 
   /**
    * 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.
+   * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
+   * @param txHashes - An array of tx hashes to be deleted from the tx pool.
    * @returns Empty promise.
    */
-  public deleteTxs(txHashes: TxHash[], eviction = false): Promise<void> {
+  public deleteTxs(txHashes: TxHash[], opts: { eviction?: boolean; permanently?: boolean } = {}): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
@@ -337,18 +352,33 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
         const tx = await this.getTxByHash(hash);
 
         if (tx) {
-          const isMined = await this.#minedTxHashToBlock.hasAsync(key);
-          if (!isMined) {
+          const minedBlockNumber = await this.#minedTxHashToBlock.getAsync(key);
+
+          if (minedBlockNumber !== undefined) {
+            await this.#minedTxHashToBlock.delete(key);
+            if (opts.permanently) {
+              // Permanently delete mined transactions if specified
+              this.#log.trace(`Deleting mined tx ${key} from pool`);
+              await this.#txs.delete(key);
+            } else {
+              // Soft-delete mined transactions: remove from mined set but keep in storage
+              this.#log.trace(`Soft-deleting mined tx ${key} from pool`);
+              await this.#deletedMinedTxHashes.set(key, minedBlockNumber);
+              await this.#blockToDeletedMinedTxHash.set(minedBlockNumber, key);
+            }
+          } else {
+            // Permanently delete pending transactions
+            this.#log.trace(`Deleting pending tx ${key} from pool`);
             pendingTxSize -= tx.getSize();
             await this.removePendingTxIndices(tx, key);
+            await this.#txs.delete(key);
           }
 
-          if (!eviction && this.#archivedTxLimit) {
+          if (!opts.eviction && this.#archivedTxLimit) {
             deletedTxs.push(tx);
           }
-
-          await this.#txs.delete(key);
-          await this.#minedTxHashToBlock.delete(key);
+        } else {
+          this.#log.trace(`Skipping deletion of missing tx ${key} from pool`);
         }
       }
 
@@ -363,12 +393,8 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
    * @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;
-    });
+    const vals = await toArray(this.#txs.valuesAsync());
+    return vals.map(buffer => Tx.fromBuffer(buffer));
   }
 
   /**
@@ -402,6 +428,8 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
       assert(archivedTxLimit >= 0, 'archivedTxLimit must be greater or equal to 0');
       this.#archivedTxLimit = archivedTxLimit;
     }
+
+    // deletedMinedCleanupThresholdMs is no longer used in block-based cleanup
   }
 
   public markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void> {
@@ -409,6 +437,46 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return Promise.resolve();
   }
 
+  /**
+   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
+   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
+   * @returns The number of transactions permanently deleted.
+   */
+  public async cleanupDeletedMinedTxs(blockNumber: BlockNumber): Promise<number> {
+    let deletedCount = 0;
+    const txHashesToDelete: string[] = [];
+    const blocksToDelete: BlockNumber[] = [];
+
+    await this.#store.transactionAsync(async () => {
+      // Iterate through all entries and check block numbers
+      for await (const [block, txHash] of this.#blockToDeletedMinedTxHash.entriesAsync()) {
+        if (block <= blockNumber) {
+          // Permanently delete the transaction
+          await this.#txs.delete(txHash);
+          await this.#deletedMinedTxHashes.delete(txHash);
+          txHashesToDelete.push(txHash);
+          if (!blocksToDelete.includes(block)) {
+            blocksToDelete.push(block);
+          }
+          deletedCount++;
+        }
+      }
+
+      // Clean up block-to-hash mapping - delete all values for each block
+      for (const block of blocksToDelete) {
+        const txHashesForBlock = await toArray(this.#blockToDeletedMinedTxHash.getValuesAsync(block));
+        for (const txHash of txHashesForBlock) {
+          await this.#blockToDeletedMinedTxHash.deleteValue(block, txHash);
+        }
+      }
+    });
+
+    if (deletedCount > 0) {
+      this.#log.debug(`Permanently deleted ${deletedCount} deleted mined txs from blocks up to ${blockNumber}`);
+    }
+    return deletedCount;
+  }
+
   /**
    * Creates a GasTxValidator instance.
    * @param db - DB for the validator to use
@@ -484,7 +552,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
           const archivedTx: Tx = new Tx(
             tx.txHash,
             tx.data,
-            ClientIvcProof.empty(),
+            ChonkProof.empty(),
             tx.contractClassLogFields,
             tx.publicFunctionCalldata,
           );
@@ -546,7 +614,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     }
 
     if (txsToEvict.length > 0) {
-      await this.deleteTxs(txsToEvict, true);
+      await this.deleteTxs(txsToEvict, { eviction: true });
     }
     return {
       numLowPriorityTxsEvicted: txsToEvict.length,
@@ -620,7 +688,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     }
 
     if (txsToEvict.length > 0) {
-      await this.deleteTxs(txsToEvict, true);
+      await this.deleteTxs(txsToEvict, { eviction: true });
     }
     return txsToEvict.length;
   }
@@ -663,7 +731,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     }
 
     if (txsToEvict.length > 0) {
-      await this.deleteTxs(txsToEvict, true);
+      await this.deleteTxs(txsToEvict, { eviction: true });
     }
     return txsToEvict.length;
   }
@@ -671,7 +739,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
   private async addPendingTxIndices(tx: Tx, txHash: string): Promise<void> {
     await this.#pendingTxPriorityToHash.set(getPendingTxPriority(tx), txHash);
     await this.#pendingTxHashToSize.set(txHash, tx.getSize());
-    await this.#pendingTxHashToHeaderHash.set(txHash, (await tx.data.constants.historicalHeader.hash()).toString());
+    await this.#pendingTxHashToHeaderHash.set(txHash, (await tx.data.constants.anchorBlockHeader.hash()).toString());
   }
 
   private async removePendingTxIndices(tx: Tx, txHash: string): Promise<void> {