@aztec/p2p 0.86.0 → 0.87.0

package/src/config.ts

@@ -99,12 +99,6 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   queryForIp: boolean;
 
-  /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
-  keepProvenTxsInPoolFor: number;
-
-  /** How many slots to keep attestations for. */
-  keepAttestationsInPoolFor: number;
-
   /**
    * The interval of the gossipsub heartbeat to perform maintenance tasks.
    */
@@ -145,6 +139,11 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
    */
   gossipsubMcacheGossip: number;
 
+  /**
+   * How long to keep message IDs in the seen cache (ms).
+   */
+  gossipsubSeenTTL: number;
+
   /**
    * The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it.
    */
@@ -281,17 +280,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
     ...booleanConfigHelper(),
   },
-  keepProvenTxsInPoolFor: {
-    env: 'P2P_TX_POOL_KEEP_PROVEN_FOR',
-    description:
-      'How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven)',
-    ...numberConfigHelper(0),
-  },
-  keepAttestationsInPoolFor: {
-    env: 'P2P_ATTESTATION_POOL_KEEP_FOR',
-    description: 'How many slots to keep attestations for.',
-    ...numberConfigHelper(96),
-  },
   gossipsubInterval: {
     env: 'P2P_GOSSIPSUB_INTERVAL_MS',
     description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
@@ -329,9 +317,14 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   gossipsubMcacheGossip: {
     env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
-    description: 'How many message cache windows to include when gossiping with other pears.',
+    description: 'How many message cache windows to include when gossiping with other peers.',
     ...numberConfigHelper(3),
   },
+  gossipsubSeenTTL: {
+    env: 'P2P_GOSSIPSUB_SEEN_TTL',
+    description: 'How long to keep message IDs in the seen cache.',
+    ...numberConfigHelper(20 * 60 * 1000),
+  },
   gossipsubTxTopicWeight: {
     env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
     description: 'The weight of the tx topic for the gossipsub protocol.',

package/src/enr/generate-enr.ts

@@ -1,13 +1,16 @@
 import type { LogFn } from '@aztec/foundation/log';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
+import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
 import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
-import { multiaddr } from '@multiformats/multiaddr';
+import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
 
-import { AZTEC_ENR_KEY } from '../types/index.js';
+import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from '../types/index.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
-import { setAztecEnrKey } from '../versioning.js';
+import { setAztecClientVersionEnrKey, setAztecEnrKey } from '../versioning.js';
+
+export { ENR };
 
 export async function createBootnodeENRandPeerId(
   privateKey: string,
@@ -29,12 +32,41 @@ export async function createBootnodeENRandPeerId(
   return { enr, peerId };
 }
 
+export function createNodeENR(
+  peerId: PeerId,
+  multiAddrUdp: Multiaddr | undefined,
+  multiAddrTcp: Multiaddr | undefined,
+  chainConfig: ChainConfig,
+  packageVersion: string,
+): { enr: SignableENR; versions: ComponentsVersions } {
+  // create ENR from PeerId
+  const enr = SignableENR.createFromPeerId(peerId);
+  // Add aztec identification to ENR
+  const versions = setAztecEnrKey(enr, chainConfig);
+  // Add aztec client version to ENR
+  setAztecClientVersionEnrKey(enr, packageVersion);
+
+  // set location multiaddr in ENR record
+  if (multiAddrUdp) {
+    enr.setLocationMultiaddr(multiAddrUdp);
+  }
+  if (multiAddrTcp) {
+    enr.setLocationMultiaddr(multiAddrTcp);
+  }
+
+  return { enr, versions };
+}
+
 export async function printENR(enr: string, log: LogFn) {
   const decoded = ENR.decodeTxt(enr);
   log(`PeerID: ${await decoded.peerId()}`);
   log(`IP: ${decoded.ip}`);
   log(`UDP: ${decoded.udp}`);
   log(`TCP: ${decoded.tcp}`);
+
   const aztec = decoded.kvs.get(AZTEC_ENR_KEY);
   log(`Aztec version: ${aztec?.toString()}`);
+
+  const aztecClientVersion = decoded.kvs.get(AZTEC_ENR_CLIENT_VERSION_KEY);
+  log(`Aztec client version ${aztecClientVersion ? aztecClientVersion!.toString() : 'N/A'}`);
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
+export * from './enr/index.js';
 export * from './config.js';
 export * from './mem_pools/attestation_pool/index.js';
 export * from './mem_pools/tx_pool/index.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -69,4 +69,7 @@ export interface AttestationPool {
    * @return BlockAttestations
    */
   getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
+
+  /** Returns whether the pool is empty. */
+  isEmpty(): Promise<boolean>;
 }

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -118,13 +118,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     await ap.addAttestations(attestations);
 
     for (const attestation of attestations) {
-      const slot = attestation.payload.header.globalVariables.slotNumber;
+      const slot = attestation.payload.header.slotNumber;
       const archive = attestation.archive.toString();
 
       const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot.toBigInt(), archive);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
-      expect(retreivedAttestations[0].payload.header.globalVariables.slotNumber).toEqual(slot);
+      expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
     }
   });
 
@@ -136,13 +136,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     await ap.addAttestations(attestations);
 
     for (const attestation of attestations) {
-      const slot = attestation.payload.header.globalVariables.slotNumber;
+      const slot = attestation.payload.header.slotNumber;
       const proposalId = attestation.archive.toString();
 
       const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(slot.toBigInt(), proposalId);
       expect(retreivedAttestations.length).toBe(1);
       expect(retreivedAttestations[0].toBuffer()).toEqual(attestation.toBuffer());
-      expect(retreivedAttestations[0].payload.header.globalVariables.slotNumber).toEqual(slot);
+      expect(retreivedAttestations[0].payload.header.slotNumber).toEqual(slot);
     }
   });
 

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -27,14 +27,21 @@ export class KvAttestationPool implements AttestationPool {
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
   }
 
+  public async isEmpty(): Promise<boolean> {
+    for await (const _ of this.attestations.entriesAsync()) {
+      return false;
+    }
+    return true;
+  }
+
   private getProposalKey(slot: number | bigint | Fr | string, proposalId: Fr | string | Buffer): string {
     const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
     const proposalIdStr =
       typeof proposalId === 'string'
         ? proposalId
         : Buffer.isBuffer(proposalId)
-        ? Fr.fromBuffer(proposalId).toString()
-        : proposalId.toString();
+          ? Fr.fromBuffer(proposalId).toString()
+          : proposalId.toString();
 
     return `${slotStr}-${proposalIdStr}`;
   }
@@ -46,7 +53,7 @@ export class KvAttestationPool implements AttestationPool {
   public async addAttestations(attestations: BlockAttestation[]): Promise<void> {
     await this.store.transactionAsync(async () => {
       for (const attestation of attestations) {
-        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
         const address = attestation.getSender().toString();
 
@@ -158,7 +165,7 @@ export class KvAttestationPool implements AttestationPool {
   public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     await this.store.transactionAsync(async () => {
       for (const attestation of attestations) {
-        const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+        const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
         const address = attestation.getSender().toString();
 

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -10,11 +10,18 @@ export class InMemoryAttestationPool implements AttestationPool {
 
   private attestations: Map</*slot=*/ bigint, Map</*proposalId*/ string, Map</*address=*/ string, BlockAttestation>>>;
 
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:attestation_pool')) {
+  constructor(
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('p2p:attestation_pool'),
+  ) {
     this.attestations = new Map();
     this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
   }
 
+  public isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.attestations.size === 0);
+  }
+
   public getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
     return Promise.resolve(
       Array.from(this.attestations.get(slot)?.values() ?? []).flatMap(proposalAttestationMap =>
@@ -37,7 +44,7 @@ export class InMemoryAttestationPool implements AttestationPool {
   public addAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
       // Perf: order and group by slot before insertion
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+      const slotNumber = attestation.payload.header.slotNumber;
 
       const proposalId = attestation.archive.toString();
       const address = attestation.getSender();
@@ -120,7 +127,7 @@ export class InMemoryAttestationPool implements AttestationPool {
 
   public deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
     for (const attestation of attestations) {
-      const slotNumber = attestation.payload.header.globalVariables.slotNumber;
+      const slotNumber = attestation.payload.header.slotNumber;
       const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
       if (slotAttestationMap) {
         const proposalId = attestation.archive.toString();

package/src/mem_pools/attestation_pool/mocks.ts

@@ -35,10 +35,10 @@ export const mockAttestation = (
 ): BlockAttestation => {
   // Use arbitrary numbers for all other than slot
   const header = makeHeader(1, 2, slot);
-  const payload = new ConsensusPayload(header, archive, txs);
+  const payload = new ConsensusPayload(header.toPropose(), archive, header.state, txs);
 
   const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
   const signature = signer.sign(hash);
 
-  return new BlockAttestation(payload, signature);
+  return new BlockAttestation(header.globalVariables.blockNumber, payload, signature);
 };

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -44,9 +44,15 @@ export class AztecKVTxPool implements TxPool {
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
 
+  /** Count of total pending txs. */
+  #pendingTxCount: AztecAsyncSingleton<number>;
+
   /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */
   #pendingTxs: Map<string, Tx>;
 
+  /** In-memory set of txs that should not be evicted from the pool. */
+  #nonEvictableTxs: Set<string>;
+
   /** KV store for archived txs. */
   #archive: AztecAsyncKVStore;
 
@@ -91,8 +97,10 @@ export class AztecKVTxPool implements TxPool {
     this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
     this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
     this.#pendingTxSize = store.openSingleton('pendingTxSize');
+    this.#pendingTxCount = store.openSingleton('pendingTxCount');
     this.#maxTxPoolSize = config.maxTxPoolSize;
     this.#pendingTxs = new Map<string, Tx>();
+    this.#nonEvictableTxs = new Set<string>();
 
     this.#archivedTxs = archive.openMap('archivedTxs');
     this.#archivedTxIndices = archive.openMap('archivedTxIndices');
@@ -105,7 +113,14 @@ export class AztecKVTxPool implements TxPool {
     this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
   }
 
-  public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
+  public async isEmpty(): Promise<boolean> {
+    for await (const _ of this.#txs.entriesAsync()) {
+      return false;
+    }
+    return true;
+  }
+
+  public async markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
@@ -113,7 +128,8 @@ export class AztecKVTxPool implements TxPool {
     let deletedPending = 0;
     const minedNullifiers = new Set<string>();
     const minedFeePayers = new Set<string>();
-    return this.#store.transactionAsync(async () => {
+
+    await this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
         const key = hash.toString();
@@ -132,6 +148,7 @@ export class AztecKVTxPool implements TxPool {
       }
       this.#metrics.recordAddedObjects(txHashes.length, 'mined');
       await this.#pendingTxSize.set(pendingTxSize);
+      await this.increasePendingTxCount(-deletedPending);
 
       const numTxsEvicted = await this.evictInvalidTxsAfterMining(
         txHashes,
@@ -141,43 +158,44 @@ export class AztecKVTxPool implements TxPool {
       );
       this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
     });
+    // We update this after the transaction above. This ensures that the non-evictable transactions are not evicted
+    // until any that have been mined are marked as such.
+    // The non-evictable set is not considered when evicting transactions that are invalid after a block is mined.
+    this.#nonEvictableTxs.clear();
   }
 
-  public markMinedAsPending(txHashes: TxHash[]): Promise<void> {
+  public async markMinedAsPending(txHashes: TxHash[]): Promise<void> {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
 
     let markedAsPending = 0;
-    return this.#store
-      .transactionAsync(async () => {
-        let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
-        for (const hash of txHashes) {
-          const key = hash.toString();
-          await this.#minedTxHashToBlock.delete(key);
+    await this.#store.transactionAsync(async () => {
+      let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
+      for (const hash of txHashes) {
+        const key = hash.toString();
+        await this.#minedTxHashToBlock.delete(key);
 
-          // Rehydrate the tx in the in-memory pending txs mapping
-          const tx = await this.getPendingTxByHash(hash);
-          if (tx) {
-            await this.addPendingTxIndices(tx, key);
-            pendingTxSize += tx.getSize();
-            markedAsPending++;
-          }
+        // Rehydrate the tx in the in-memory pending txs mapping
+        const tx = await this.getPendingTxByHash(hash);
+        if (tx) {
+          await this.addPendingTxIndices(tx, key);
+          pendingTxSize += tx.getSize();
+          markedAsPending++;
         }
+      }
+
+      await this.#pendingTxSize.set(pendingTxSize);
+    });
+
+    const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
+    const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
 
-        await this.#pendingTxSize.set(pendingTxSize);
-      })
-      .then(async () => {
-        const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
-        const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
-
-        this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
-        this.#metrics.recordRemovedObjects(
-          numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted,
-          'pending',
-        );
-        this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
-      });
+    await this.increasePendingTxCount(markedAsPending);
+
+    this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
+    this.#metrics.recordRemovedObjects(numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
+    this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
   }
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
@@ -190,6 +208,10 @@ export class AztecKVTxPool implements TxPool {
     return vals.map(([txHash, blockNumber]) => [TxHash.fromString(txHash), blockNumber]);
   }
 
+  public async getPendingTxCount(): Promise<number> {
+    return (await this.#pendingTxCount.getAsync()) ?? 0;
+  }
+
   public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toString();
     const [isMined, isKnown] = await Promise.all([this.#minedTxHashToBlock.hasAsync(key), this.#txs.hasAsync(key)]);
@@ -259,21 +281,26 @@ export class AztecKVTxPool implements TxPool {
       txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
     );
     await this.#store.transactionAsync(async () => {
-      let pendingCount = 0;
+      let addedCount = 0;
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
         txs.map(async (tx, i) => {
           const { txHash, txStats } = hashesAndStats[i];
+          const key = txHash.toString();
+          if (await this.#txs.hasAsync(key)) {
+            this.#log.debug(`Tx ${txHash.toString()} already exists in the pool`);
+            return;
+          }
+
           this.#log.verbose(`Adding tx ${txHash.toString()} to pool`, {
             eventName: 'tx-added-to-pool',
             ...txStats,
           } satisfies TxAddedToPoolStats);
 
-          const key = txHash.toString();
           await this.#txs.set(key, tx.toBuffer());
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-            pendingCount++;
+            addedCount++;
             pendingTxSize += tx.getSize();
             await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
@@ -281,13 +308,13 @@ export class AztecKVTxPool implements TxPool {
         }),
       );
 
+      await this.increasePendingTxCount(addedCount);
       await this.#pendingTxSize.set(pendingTxSize);
-
       const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(
         hashesAndStats.map(({ txHash }) => txHash),
       );
 
-      this.#metrics.recordAddedObjects(pendingCount - numNewTxsEvicted, 'pending');
+      this.#metrics.recordAddedObjects(addedCount - numNewTxsEvicted, 'pending');
       this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
     });
   }
@@ -328,6 +355,8 @@ export class AztecKVTxPool implements TxPool {
       }
 
       await this.#pendingTxSize.set(pendingTxSize);
+      await this.increasePendingTxCount(-pendingDeleted);
+
       this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
       this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
     });
@@ -362,6 +391,11 @@ export class AztecKVTxPool implements TxPool {
     return Promise.resolve();
   }
 
+  public markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void> {
+    txHashes.forEach(txHash => this.#nonEvictableTxs.add(txHash.toString()));
+    return Promise.resolve();
+  }
+
   /**
    * Creates a GasTxValidator instance.
    * @param db - DB for the validator to use
@@ -459,6 +493,9 @@ export class AztecKVTxPool implements TxPool {
     let pendingTxsSize = (await this.#pendingTxSize.getAsync()) ?? 0;
     if (pendingTxsSize > this.#maxTxPoolSize) {
       for await (const txHash of this.#pendingTxPriorityToHash.valuesAsync()) {
+        if (this.#nonEvictableTxs.has(txHash.toString())) {
+          continue;
+        }
         this.#log.verbose(`Evicting tx ${txHash} from pool due to low priority to satisfy max tx size limit`);
         txsToEvict.push(TxHash.fromString(txHash));
 
@@ -606,4 +643,12 @@ export class AztecKVTxPool implements TxPool {
     await this.#pendingTxHashToHeaderHash.delete(txHash);
     this.#pendingTxs.delete(txHash);
   }
+
+  private async increasePendingTxCount(count: number): Promise<void> {
+    const pendingTxCount = (await this.#pendingTxCount.getAsync()) ?? 0;
+    this.#log.debug(
+      `Increasing pending tx count: current ${pendingTxCount} + count ${count} = ${pendingTxCount + count}`,
+    );
+    await this.#pendingTxCount.set(pendingTxCount + count);
+  }
 }

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -24,13 +24,20 @@ export class InMemoryTxPool implements TxPool {
    * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
    * @param log - A logger.
    */
-  constructor(telemetry: TelemetryClient = getTelemetryClient(), private log = createLogger('p2p:tx_pool')) {
+  constructor(
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('p2p:tx_pool'),
+  ) {
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
     this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
   }
 
+  public isEmpty(): Promise<boolean> {
+    return Promise.resolve(this.txs.size === 0);
+  }
+
   public markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void> {
     const keys = txHashes.map(x => x.toBigInt());
     for (const key of keys) {
@@ -82,6 +89,10 @@ export class InMemoryTxPool implements TxPool {
     );
   }
 
+  public getPendingTxCount(): Promise<number> {
+    return Promise.resolve(this.pendingTxs.size);
+  }
+
   public getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
     const key = txHash.toBigInt();
     if (this.pendingTxs.has(key)) {
@@ -182,4 +193,8 @@ export class InMemoryTxPool implements TxPool {
   setMaxTxPoolSize(_maxSizeBytes: number | undefined): Promise<void> {
     return Promise.resolve();
   }
+
+  markTxsAsNonEvictable(_: TxHash[]): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -75,6 +75,9 @@ export interface TxPool {
    */
   getPendingTxHashes(): Promise<TxHash[]>;
 
+  /** Returns the number of pending txs in the pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Gets the hashes of mined transactions currently in the tx pool.
    * @returns An array of mined transaction hashes found in the tx pool.
@@ -93,4 +96,13 @@ export interface TxPool {
    * @param maxSizeBytes - The maximum size in bytes of the mempool. Set to undefined to disable it
    */
   setMaxTxPoolSize(maxSizeBytes: number | undefined): Promise<void>;
+
+  /** Returns whether the pool is empty. */
+  isEmpty(): Promise<boolean>;
+
+  /**
+   * Marks transactions as non-evictible in the pool.
+   * @param txHashes - Hashes of the transactions to mark as non-evictible.
+   */
+  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
 }

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -24,6 +24,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
     await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Removes txs from the pool', async () => {
@@ -34,6 +35,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getPendingTxCount()).resolves.toEqual(0);
   });
 
   it('Marks txs as mined', async () => {
@@ -47,6 +49,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
     await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Marks txs as pending after being mined', async () => {
@@ -61,6 +64,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
     expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(2);
   });
 
   it('Only marks txs as pending if they are known', async () => {
@@ -82,6 +86,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
   it('Returns all transactions in the pool', async () => {
@@ -94,6 +99,7 @@ export function describeTxPool(getTxPool: () => TxPool) {
     const poolTxs = await pool.getAllTxs();
     expect(poolTxs).toHaveLength(3);
     expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
   it('Returns all txHashes in the pool', async () => {
@@ -104,10 +110,10 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
 
     const poolTxHashes = await pool.getAllTxHashes();
+    const expectedHashes = await Promise.all([tx1, tx2, tx3].map(tx => tx.getTxHash()));
     expect(poolTxHashes).toHaveLength(3);
-    expect(poolTxHashes).toEqual(
-      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
-    );
+    expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(3);
   });
 
   it('Returns txs by their hash', async () => {

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -11,7 +11,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
   async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
     const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
 
-    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
+    const slotNumberBigInt = message.payload.header.slotNumber.toBigInt();
     if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
       return PeerErrorSeverity.HighToleranceError;
     }

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -16,7 +16,7 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
       await this.epochCache.getProposerInCurrentOrNextSlot();
 
     // Check that the attestation is for the current or next slot
-    const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
+    const slotNumberBigInt = block.payload.header.slotNumber.toBigInt();
     if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
       this.logger.debug(
         `Penalizing peer for invalid slot number ${slotNumberBigInt}, current slot: ${currentSlot}, next slot: ${nextSlot}`,

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -17,7 +17,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.historicalHeader.hash()]);
     if (index === undefined) {
-      this.#log.warn(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
+      this.#log.verbose(`Rejecting tx ${await Tx.getHash(tx)} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };
     }
     return { result: 'valid' };