@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/src/config.ts

@@ -16,11 +16,12 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { type AllowedElement, type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 
 import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqresp/config.js';
+import { type TxCollectionConfig, txCollectionConfigMappings } from './services/tx_collection/config.js';
 
 /**
  * P2P client configuration values.
  */
-export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionConfig {
   /** A flag dictating whether the P2P subsystem should be enabled. */
   p2pEnabled: boolean;
 
@@ -123,6 +124,9 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
   /** A list of private peers. */
   privatePeers: string[];
 
+  /** A list of preferred peers. */
+  preferredPeers: string[];
+
   /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB. */
   p2pStoreMapSizeKb?: number;
 
@@ -140,6 +144,20 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
 
   /** True to disable the status handshake on peer connected. */
   p2pDisableStatusHandshake?: boolean;
+
+  /** True to only permit validators to connect */
+  p2pAllowOnlyValidators?: boolean;
+
+  /** True to disable participating in discovery */
+  p2pDiscoveryDisabled?: boolean;
+  /** Number of auth attempts to allow before peer is banned. Number is inclusive*/
+  p2pMaxFailedAuthAttemptsAllowed: number;
+
+  /** True to simulate discarding transactions. - For testing purposes only*/
+  dropTransactions: boolean;
+
+  /** The probability that a transaction is discarded. - For testing purposes only */
+  dropTransactionsProbability: number;
 }
 
 export const DEFAULT_P2P_PORT = 40400;
@@ -150,6 +168,11 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'A flag dictating whether the P2P subsystem should be enabled.',
     ...booleanConfigHelper(),
   },
+  p2pDiscoveryDisabled: {
+    env: 'P2P_DISCOVERY_DISABLED',
+    description: 'A flag dictating whether the P2P discovery system should be disabled.',
+    ...booleanConfigHelper(false),
+  },
   blockCheckIntervalMS: {
     env: 'P2P_BLOCK_CHECK_INTERVAL_MS',
     description: 'The frequency in which to check for new L2 blocks.',
@@ -321,6 +344,13 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'A list of private peer ENRs that will always be persisted and not be used for discovery. Separated by commas.',
     defaultValue: [],
   },
+  preferredPeers: {
+    env: 'P2P_PREFERRED_PEERS',
+    parseEnv: (val: string) => val.split(','),
+    description:
+      'A list of preferred peer ENRs that will always be persisted and not be used for discovery. Separated by commas.',
+    defaultValue: [],
+  },
   p2pStoreMapSizeKb: {
     env: 'P2P_STORE_MAP_SIZE_KB',
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
@@ -353,8 +383,29 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'True to disable the status handshake on peer connected.',
     ...booleanConfigHelper(false),
   },
+  p2pAllowOnlyValidators: {
+    env: 'P2P_ALLOW_ONLY_VALIDATORS',
+    description: 'True to only permit validators to connect.',
+    ...booleanConfigHelper(false),
+  },
+  p2pMaxFailedAuthAttemptsAllowed: {
+    env: 'P2P_MAX_AUTH_FAILED_ATTEMPTS_ALLOWED',
+    description: 'Number of auth attempts to allow before peer is banned. Number is inclusive',
+    ...numberConfigHelper(3),
+  },
+  dropTransactions: {
+    env: 'P2P_DROP_TX',
+    description: 'True to simulate discarding transactions. - For testing purposes only',
+    ...booleanConfigHelper(false),
+  },
+  dropTransactionsProbability: {
+    env: 'P2P_DROP_TX_CHANCE',
+    description: 'The probability that a transaction is discarded. - For testing purposes only',
+    ...floatConfigHelper(0),
+  },
   ...p2pReqRespConfigMappings,
   ...chainConfigMappings,
+  ...txCollectionConfigMappings,
 };
 
 /**

package/src/index.ts

@@ -1,3 +1,4 @@
+export { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 export type { PeerId } from '@libp2p/interface';
 
 export * from './bootstrap/bootstrap.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -1,4 +1,4 @@
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 
 /**
  * An Attestation Pool contains attestations collected by a validator
@@ -7,6 +7,20 @@ import type { BlockAttestation } from '@aztec/stdlib/p2p';
  * from the validator to produce a block, or to serve to other peers.
  */
 export interface AttestationPool {
+  /**
+   * Adds new block proposal to the pool
+   */
+  addBlockProposal(blockProposal: BlockProposal): Promise<void>;
+
+  /**
+   * Get block proposal by it's ID
+   *
+   * @param id - The ID of the block proposal to retrieve. The ID is proposal.payload.archive
+   *
+   * @return The block proposal if it exists, otherwise undefined.
+   */
+  getBlockProposal(id: string): Promise<BlockProposal | undefined>;
+
   /**
    * AddAttestations
    *

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -1,6 +1,13 @@
 import { Secp256k1Signer } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
+import {
+  BlockProposal as BlockProposalClass,
+  ConsensusPayload,
+  SignatureDomainSeparator,
+  getHashedSignaturePayloadEthSignedMessage,
+} from '@aztec/stdlib/p2p';
+import { makeHeader } from '@aztec/stdlib/testing';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import { jest } from '@jest/globals';
@@ -33,6 +40,19 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     return signers.map(signer => mockAttestation(signer, slotNumber, archive));
   };
 
+  const mockBlockProposal = (signer: Secp256k1Signer, slotNumber: number, archive: Fr = Fr.random()): BlockProposal => {
+    const blockNumber = 1;
+    const header = makeHeader(1, 2, slotNumber);
+    const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
+
+    const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+    const signature = signer.sign(hash);
+
+    const txHashes = [TxHash.random(), TxHash.random()]; // Mock tx hashes
+
+    return new BlockProposalClass(blockNumber, payload, signature, txHashes);
+  };
+
   // We compare buffers as the objects can have cached values attached to them which are not serialised
   // using array containing as the kv store does not respect insertion order
   const compareAttestations = (a1: BlockAttestation[], a2: BlockAttestation[]) => {
@@ -83,13 +103,12 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   it('should handle duplicate proposals in a slot', async () => {
     const slotNumber = 420;
     const archive = Fr.random();
-    const txs = [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
 
     // Use the same signer for all attestations
     const attestations: BlockAttestation[] = [];
     const signer = signers[0];
     for (let i = 0; i < NUMBER_OF_SIGNERS_PER_TEST; i++) {
-      attestations.push(mockAttestation(signer, slotNumber, archive, txs));
+      attestations.push(mockAttestation(signer, slotNumber, archive));
     }
 
     // Add them to store and check we end up with only one
@@ -98,7 +117,6 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), archive.toString());
     expect(retreivedAttestations.length).toBe(1);
     expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
-    expect(retreivedAttestations[0].payload.txHashes).toEqual(txs);
     expect(retreivedAttestations[0].getSender().toString()).toEqual(signer.address.toString());
 
     // Try adding them on another operation and check they are still not duplicated
@@ -234,4 +252,137 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(69));
     expect(deleteAttestationsSpy).toHaveBeenCalledWith(BigInt(72));
   });
+
+  describe('BlockProposal in attestation pool', () => {
+    it('should add and retrieve block proposal', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal.archive.toString();
+
+      await ap.addBlockProposal(proposal);
+
+      const retrievedProposal = await ap.getBlockProposal(proposalId);
+
+      // This are cached values, so we need to call them to ensure they are not undefined
+      retrievedProposal!.payload.getSize();
+      retrievedProposal!.signature.getSize();
+
+      expect(retrievedProposal).toBeDefined();
+      expect(retrievedProposal!).toEqual(proposal);
+    });
+
+    it('should return undefined for non-existent block proposal', async () => {
+      const nonExistentId = Fr.random().toString();
+      const retrievedProposal = await ap.getBlockProposal(nonExistentId);
+      expect(retrievedProposal).toBeUndefined();
+    });
+
+    it('should update block proposal if added twice with same id', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal1 = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal1.archive.toString();
+
+      await ap.addBlockProposal(proposal1);
+
+      // Create a new proposal with same archive but different signer
+      const proposal2 = mockBlockProposal(signers[1], slotNumber, archive);
+
+      await ap.addBlockProposal(proposal2);
+
+      const retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeDefined();
+      // Should have the second proposal
+      expect(retrievedProposal!.toBuffer()).toEqual(proposal2.toBuffer());
+      expect(retrievedProposal!.getSender().toString()).toBe(signers[1].address.toString());
+    });
+
+    it('should handle block proposals with different slots and same archive', async () => {
+      const archive = Fr.random();
+      const proposal1 = mockBlockProposal(signers[0], 100, archive);
+      const proposal2 = mockBlockProposal(signers[1], 200, archive);
+      const proposalId = archive.toString();
+
+      await ap.addBlockProposal(proposal1);
+      await ap.addBlockProposal(proposal2);
+
+      // Should get the latest one added
+      const retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeDefined();
+      expect(retrievedProposal!.toBuffer()).toEqual(proposal2.toBuffer());
+      expect(retrievedProposal!.slotNumber.toBigInt()).toBe(BigInt(200));
+    });
+
+    it('should delete block proposal when deleting attestations for slot and proposal', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal.archive.toString();
+
+      // Add proposal and some attestations
+      await ap.addBlockProposal(proposal);
+      const attestations = signers.map(signer => mockAttestation(signer, slotNumber, archive));
+      await ap.addAttestations(attestations);
+
+      // Verify proposal exists
+      let retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeDefined();
+
+      // Delete attestations for slot and proposal
+      await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+
+      // Proposal should be deleted
+      retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeUndefined();
+    });
+
+    it('should delete block proposal when deleting attestations for slot', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal.archive.toString();
+
+      // Add proposal
+      await ap.addBlockProposal(proposal);
+
+      // Verify proposal exists
+      let retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeDefined();
+
+      // Delete attestations for slot
+      await ap.deleteAttestationsForSlot(BigInt(slotNumber));
+
+      // Proposal should be deleted
+      retrievedProposal = await ap.getBlockProposal(proposalId);
+      expect(retrievedProposal).toBeUndefined();
+    });
+
+    it('should be able to fetch both block proposal and attestations', async () => {
+      const slotNumber = 420;
+      const archive = Fr.random();
+      const proposal = mockBlockProposal(signers[0], slotNumber, archive);
+      const proposalId = proposal.archive.toString();
+
+      // Add proposal first
+      await ap.addBlockProposal(proposal);
+
+      // Add attestations for the same proposal
+      const attestations = signers.slice(1).map(signer => mockAttestation(signer, slotNumber, archive));
+      await ap.addAttestations(attestations);
+
+      // Retrieve both proposal and attestations
+      const retrievedProposal = await ap.getBlockProposal(proposalId);
+      const retrievedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
+
+      expect(retrievedProposal).toBeDefined();
+      // This are cached values, so we need to call them to ensure they are not undefined
+      retrievedProposal!.payload.getSize();
+      retrievedProposal!.signature.getSize();
+
+      expect(retrievedProposal).toEqual(proposal);
+
+      compareAttestations(retrievedAttestations, attestations);
+    });
+  });
 }

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@aztec/kv-store';
-import { BlockAttestation } from '@aztec/stdlib/p2p';
+import { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
@@ -12,6 +12,10 @@ export class KvAttestationPool implements AttestationPool {
   private metrics: PoolInstrumentation<BlockAttestation>;
 
   private attestations: AztecAsyncMap<string, Buffer>;
+  private proposals: AztecAsyncMap<
+    /*  proposal.payload.archive  */ string,
+    /* buffer representation of proposal */ Buffer
+  >;
   private proposalsForSlot: AztecAsyncMultiMap<string, string>;
   private attestationsForProposal: AztecAsyncMultiMap<string, string>;
 
@@ -21,6 +25,7 @@ export class KvAttestationPool implements AttestationPool {
     private log = createLogger('aztec:attestation_pool'),
   ) {
     this.attestations = store.openMap('attestations');
+    this.proposals = store.openMap('proposals');
     this.proposalsForSlot = store.openMultiMap('proposals_for_slot');
     this.attestationsForProposal = store.openMultiMap('attestations_for_proposal');
 
@@ -137,6 +142,7 @@ export class KvAttestationPool implements AttestationPool {
           await this.attestations.delete(attestation);
         }
 
+        await this.proposals.delete(proposalId);
         await this.attestationsForProposal.delete(this.getProposalKey(slotFr, proposalId));
       }
 
@@ -157,6 +163,7 @@ export class KvAttestationPool implements AttestationPool {
         await this.attestations.delete(attestation);
       }
 
+      await this.proposals.delete(proposalId);
       await this.proposalsForSlot.deleteValue(slotString, proposalId);
       await this.attestationsForProposal.delete(this.getProposalKey(slotString, proposalId));
 
@@ -185,4 +192,24 @@ export class KvAttestationPool implements AttestationPool {
       }
     });
   }
+
+  public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+    const buffer = await this.proposals.getAsync(id);
+    try {
+      if (buffer && buffer.length > 0) {
+        return BlockProposal.fromBuffer(buffer);
+      }
+    } catch {
+      return Promise.resolve(undefined);
+    }
+
+    return Promise.resolve(undefined);
+  }
+
+  public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
+    await this.store.transactionAsync(async () => {
+      await this.proposalsForSlot.set(blockProposal.slotNumber.toString(), blockProposal.archive.toString());
+      await this.proposals.set(blockProposal.payload.archive.toString(), blockProposal.toBuffer());
+    });
+  }
 }

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@aztec/foundation/log';
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
@@ -9,12 +9,14 @@ export class InMemoryAttestationPool implements AttestationPool {
   private metrics: PoolInstrumentation<BlockAttestation>;
 
   private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
+  private proposals: Map<string, BlockProposal>;
 
   constructor(
     telemetry: TelemetryClient = getTelemetryClient(),
     private log = createLogger('p2p:attestation_pool'),
   ) {
     this.attestations = new Map();
+    this.proposals = new Map();
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
   }
 
@@ -106,9 +108,17 @@ export class InMemoryAttestationPool implements AttestationPool {
   public deleteAttestationsForSlot(slot: bigint): Promise<void> {
     // We count the number of attestations we are removing
     const numberOfAttestations = this.#getNumberOfAttestationsInSlot(slot);
+    const proposalIdsToDelete = this.attestations.get(slot)?.keys();
+    let proposalIdsToDeleteCount = 0;
+    proposalIdsToDelete?.forEach(proposalId => {
+      this.proposals.delete(proposalId);
+      proposalIdsToDeleteCount++;
+    });
 
     this.attestations.delete(slot);
-    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+    this.log.verbose(
+      `Removed ${numberOfAttestations} attestations and ${proposalIdsToDeleteCount} proposals for slot ${slot}`,
+    );
 
     return Promise.resolve();
   }
@@ -124,6 +134,8 @@ export class InMemoryAttestationPool implements AttestationPool {
         this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
       }
     }
+
+    this.proposals.delete(proposalId);
     return Promise.resolve();
   }
 
@@ -143,6 +155,20 @@ export class InMemoryAttestationPool implements AttestationPool {
     }
     return Promise.resolve();
   }
+
+  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());
+    slotProposalMapping.set(blockProposal.payload.archive.toString(), new Map<string, BlockAttestation>());
+
+    this.proposals.set(blockProposal.payload.archive.toString(), blockProposal);
+    return Promise.resolve();
+  }
+
+  public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
+    return Promise.resolve(this.proposals.get(id));
+  }
 }
 
 /**

package/src/mem_pools/attestation_pool/mocks.ts

@@ -7,7 +7,6 @@ import {
   getHashedSignaturePayloadEthSignedMessage,
 } from '@aztec/stdlib/p2p';
 import { makeHeader } from '@aztec/stdlib/testing';
-import { TxHash } from '@aztec/stdlib/tx';
 
 import { type LocalAccount, generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 
@@ -31,11 +30,10 @@ export const mockAttestation = (
   signer: Secp256k1Signer,
   slot: number = 0,
   archive: Fr = Fr.random(),
-  txs: TxHash[] = [0, 1, 2, 3, 4, 5].map(() => TxHash.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, txs);
+  const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
 
   const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const signature = signer.sign(hash);

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { TypedEventEmitter } from '@aztec/foundation/types';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSingleton } from '@aztec/kv-store';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { GasFees } from '@aztec/stdlib/gas';
@@ -12,17 +13,18 @@ import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert';
+import EventEmitter from 'node:events';
 
 import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
 import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
 import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
-import type { TxPool, TxPoolOptions } from './tx_pool.js';
+import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
 
 /**
  * KV implementation of the Transaction Pool.
  */
-export class AztecKVTxPool implements TxPool {
+export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<TxPoolEvents>) implements TxPool {
   #store: AztecAsyncKVStore;
 
   /** Our tx pool, stored as a Map, with K: tx hash and V: the transaction. */
@@ -90,6 +92,8 @@ export class AztecKVTxPool implements TxPool {
     config: TxPoolOptions = {},
     log = createLogger('p2p:tx_pool'),
   ) {
+    super();
+
     this.#log = log;
     this.updateConfig(config);
 
@@ -276,11 +280,9 @@ export class AztecKVTxPool implements TxPool {
    * @param txs - An array of txs to be added to the pool.
    * @returns Empty promise.
    */
-  public async addTxs(txs: Tx[]): Promise<number> {
-    let addedCount = 0;
-    const hashesAndStats = await Promise.all(
-      txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
-    );
+  public async addTxs(txs: Tx[], opts: { source?: string } = {}): Promise<number> {
+    const addedTxs: Tx[] = [];
+    const hashesAndStats = txs.map(tx => ({ txHash: tx.getTxHash(), txStats: tx.getStats() }));
     await this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
@@ -298,9 +300,9 @@ export class AztecKVTxPool implements TxPool {
           } satisfies TxAddedToPoolStats);
 
           await this.#txs.set(key, tx.toBuffer());
+          addedTxs.push(tx as Tx);
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-            addedCount++;
             pendingTxSize += tx.getSize();
             await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
@@ -312,7 +314,10 @@ export class AztecKVTxPool implements TxPool {
       await this.evictLowPriorityTxs(hashesAndStats.map(({ txHash }) => txHash));
     });
 
-    return addedCount;
+    if (addedTxs.length > 0) {
+      this.emit('txs-added', { ...opts, txs: addedTxs });
+    }
+    return addedTxs.length;
   }
 
   /**
@@ -321,6 +326,9 @@ export class AztecKVTxPool implements TxPool {
    * @returns Empty promise.
    */
   public deleteTxs(txHashes: TxHash[], eviction = false): Promise<void> {
+    if (txHashes.length === 0) {
+      return Promise.resolve();
+    }
     const deletedTxs: Tx[] = [];
     const poolDbTx = this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
@@ -346,7 +354,7 @@ export class AztecKVTxPool implements TxPool {
 
       await this.#pendingTxSize.set(pendingTxSize);
     });
-
+    this.#log.debug(`Deleted ${txHashes.length} txs from pool`, { txHashes });
     return this.#archivedTxLimit ? poolDbTx.then(() => this.archiveTxs(deletedTxs)) : poolDbTx;
   }
 
@@ -451,36 +459,46 @@ export class AztecKVTxPool implements TxPool {
    * @returns Empty promise.
    */
   private async archiveTxs(txs: Tx[]): Promise<void> {
-    const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
-    await this.#archive.transactionAsync(async () => {
-      // calcualte the head and tail indices of the archived txs by insertion order.
-      let headIdx =
-        ((await this.#archivedTxIndices.entriesAsync({ limit: 1, reverse: true }).next()).value?.[0] ?? -1) + 1;
-      let tailIdx = (await this.#archivedTxIndices.entriesAsync({ limit: 1 }).next()).value?.[0] ?? 0;
-
-      for (let i = 0; i < txs.length; i++) {
-        const tx = txs[i];
-        while (headIdx - tailIdx >= this.#archivedTxLimit) {
-          const txHash = await this.#archivedTxIndices.getAsync(tailIdx);
-          if (txHash) {
-            await this.#archivedTxs.delete(txHash);
-            await this.#archivedTxIndices.delete(tailIdx);
+    if (txs.length === 0) {
+      return;
+    }
+    try {
+      const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+      await this.#archive.transactionAsync(async () => {
+        // calculate 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++;
           }
-          tailIdx++;
-        }
 
-        const archivedTx: Tx = new Tx(
-          tx.data,
-          ClientIvcProof.empty(),
-          tx.contractClassLogFields,
-          tx.publicFunctionCalldata,
-        );
-        const txHash = txHashes[i].toString();
-        await this.#archivedTxs.set(txHash, archivedTx.toBuffer());
-        await this.#archivedTxIndices.set(headIdx, txHash);
-        headIdx++;
-      }
-    });
+          const archivedTx: Tx = new Tx(
+            tx.txHash,
+            tx.data,
+            ClientIvcProof.empty(),
+            tx.contractClassLogFields,
+            tx.publicFunctionCalldata,
+          );
+          const txHash = txHashes[i].toString();
+          await this.#archivedTxs.set(txHash, archivedTx.toBuffer());
+          await this.#archivedTxIndices.set(headIdx, txHash);
+          headIdx++;
+        }
+        this.#log.debug(`Archived ${txs.length} txs`, { txHashes });
+        this.#log.debug(`Total archived txs: ${headIdx - tailIdx}`);
+      });
+    } catch (error) {
+      this.#log.error(`Error archiving txs`, { error });
+    }
   }
 
   /**
@@ -591,10 +609,10 @@ export class AztecKVTxPool implements TxPool {
       }
 
       // Evict pending txs with an expiration timestamp less than or equal to the mined block timestamp
-      const includeByTimestamp = tx.data.rollupValidationRequests.includeByTimestamp;
-      if (includeByTimestamp.isSome && includeByTimestamp.value <= timestamp) {
+      const includeByTimestamp = tx.data.includeByTimestamp;
+      if (includeByTimestamp <= timestamp) {
         this.#log.verbose(
-          `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp.value}, mined block timestamp: ${timestamp})`,
+          `Evicting tx ${txHash} from pool due to the tx being expired (includeByTimestamp: ${includeByTimestamp}, mined block timestamp: ${timestamp})`,
         );
         txsToEvict.push(TxHash.fromString(txHash));
         continue;