@aztec/p2p 0.87.7 → 0.87.8

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -5,7 +5,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap } from '@azte
 import { BlockAttestation } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import type { AttestationPool } from './attestation_pool.js';
 
 export class KvAttestationPool implements AttestationPool {
@@ -24,9 +24,15 @@ export class KvAttestationPool implements AttestationPool {
     this.proposalsForSlot = store.openMultiMap('proposals_for_slot');
     this.attestationsForProposal = store.openMultiMap('attestations_for_proposal');
 
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
   }
 
+  private poolStats: PoolStatsCallback = async () => {
+    return {
+      itemCount: await this.attestations.sizeAsync(),
+    };
+  };
+
   public async isEmpty(): Promise<boolean> {
     for await (const _ of this.attestations.entriesAsync()) {
       return false;
@@ -73,8 +79,6 @@ export class KvAttestationPool implements AttestationPool {
         });
       }
     });
-
-    this.metrics.recordAddedObjects(attestations.length);
   }
 
   public async getAttestationsForSlot(slot: bigint): Promise<BlockAttestation[]> {
@@ -135,10 +139,9 @@ export class KvAttestationPool implements AttestationPool {
 
         await this.attestationsForProposal.delete(this.getProposalKey(slotFr, proposalId));
       }
-    });
 
-    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
-    this.metrics.recordRemovedObjects(numberOfAttestations);
+      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
+    });
   }
 
   public async deleteAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<void> {
@@ -156,10 +159,9 @@ export class KvAttestationPool implements AttestationPool {
 
       await this.proposalsForSlot.deleteValue(slotString, proposalId);
       await this.attestationsForProposal.delete(this.getProposalKey(slotString, proposalId));
-    });
 
-    this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-    this.metrics.recordRemovedObjects(numberOfAttestations);
+      this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
+    });
   }
 
   public async deleteAttestations(attestations: BlockAttestation[]): Promise<void> {
@@ -168,8 +170,12 @@ export class KvAttestationPool implements AttestationPool {
         const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
         const address = attestation.getSender().toString();
+        const key = this.getAttestationKey(slotNumber, proposalId, address);
+
+        if (await this.attestations.hasAsync(key)) {
+          await this.attestations.delete(key);
+        }
 
-        await this.attestations.delete(this.getAttestationKey(slotNumber, proposalId, address));
         await this.attestationsForProposal.deleteValue(
           this.getProposalKey(slotNumber, proposalId),
           this.getAttestationKey(slotNumber, proposalId, address),
@@ -178,6 +184,5 @@ export class KvAttestationPool implements AttestationPool {
         this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
       }
     });
-    this.metrics.recordRemovedObjects(attestations.length);
   }
 }

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@aztec/foundation/log';
 import type { BlockAttestation } from '@aztec/stdlib/p2p';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import type { AttestationPool } from './attestation_pool.js';
 
 export class InMemoryAttestationPool implements AttestationPool {
@@ -15,9 +15,15 @@ export class InMemoryAttestationPool implements AttestationPool {
     private log = createLogger('p2p:attestation_pool'),
   ) {
     this.attestations = new Map();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL);
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
   }
 
+  private poolStats: PoolStatsCallback = () => {
+    return Promise.resolve({
+      itemCount: this.attestations.size,
+    });
+  };
+
   public isEmpty(): Promise<boolean> {
     return Promise.resolve(this.attestations.size === 0);
   }
@@ -61,8 +67,6 @@ export class InMemoryAttestationPool implements AttestationPool {
       });
     }
 
-    // TODO: set these to pending or something ????
-    this.metrics.recordAddedObjects(attestations.length);
     return Promise.resolve();
   }
 
@@ -106,7 +110,6 @@ export class InMemoryAttestationPool implements AttestationPool {
     this.attestations.delete(slot);
     this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot}`);
 
-    this.metrics.recordRemovedObjects(numberOfAttestations);
     return Promise.resolve();
   }
 
@@ -119,7 +122,6 @@ export class InMemoryAttestationPool implements AttestationPool {
         slotAttestationMap.delete(proposalId);
 
         this.log.verbose(`Removed ${numberOfAttestations} attestations for slot ${slot} and proposal ${proposalId}`);
-        this.metrics.recordRemovedObjects(numberOfAttestations);
       }
     }
     return Promise.resolve();
@@ -139,7 +141,6 @@ export class InMemoryAttestationPool implements AttestationPool {
         }
       }
     }
-    this.metrics.recordRemovedObjects(attestations.length);
     return Promise.resolve();
   }
 }

package/src/mem_pools/instrumentation.ts

@@ -1,13 +1,15 @@
 import type { Gossipable } from '@aztec/stdlib/p2p';
 import {
   Attributes,
+  type BatchObservableResult,
   type Histogram,
   LmdbMetrics,
   type LmdbStatsCallback,
+  type Meter,
   Metrics,
   type MetricsType,
+  type ObservableGauge,
   type TelemetryClient,
-  type UpDownCounter,
 } from '@aztec/telemetry-client';
 
 export enum PoolName {
@@ -41,86 +43,70 @@ function getMetricsLabels(name: PoolName): MetricsLabels {
   throw new Error('Invalid pool type');
 }
 
+export type PoolStatsCallback = () => Promise<{
+  itemCount: number | Record<string, number>;
+}>;
+
 /**
  * Instrumentation class for the Pools (TxPool, AttestationPool, etc).
  */
 export class PoolInstrumentation<PoolObject extends Gossipable> {
   /** The number of txs in the mempool */
-  private objectsInMempool: UpDownCounter;
+  private objectsInMempool: ObservableGauge;
   /** Tracks tx size */
   private objectSize: Histogram;
 
   private dbMetrics: LmdbMetrics;
 
   private defaultAttributes;
-
-  constructor(telemetry: TelemetryClient, name: PoolName, dbStats?: LmdbStatsCallback) {
-    const meter = telemetry.getMeter(name);
+  private meter: Meter;
+
+  constructor(
+    telemetry: TelemetryClient,
+    name: PoolName,
+    private poolStats: PoolStatsCallback,
+    dbStats?: LmdbStatsCallback,
+  ) {
+    this.meter = telemetry.getMeter(name);
     this.defaultAttributes = { [Attributes.POOL_NAME]: name };
 
     const metricsLabels = getMetricsLabels(name);
 
-    this.objectsInMempool = meter.createUpDownCounter(metricsLabels.objectInMempool, {
+    this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool, {
       description: 'The current number of transactions in the mempool',
     });
 
-    this.objectSize = meter.createHistogram(metricsLabels.objectSize, {
+    this.objectSize = this.meter.createHistogram(metricsLabels.objectSize, {
       unit: 'By',
       description: 'The size of transactions in the mempool',
     });
 
     this.dbMetrics = new LmdbMetrics(
-      meter,
+      this.meter,
       {
         [Attributes.DB_DATA_TYPE]: 'tx-pool',
       },
       dbStats,
     );
+
+    this.meter.addBatchObservableCallback(this.observeStats, [this.objectsInMempool]);
   }
 
   public recordSize(poolObject: PoolObject) {
     this.objectSize.record(poolObject.getSize());
   }
 
-  /**
-   * Updates the metrics with the new objects.
-   * @param txs - The objects to record
-   */
-  public recordAddedObjects(count = 1, status?: string) {
-    if (count < 0) {
-      throw new Error('Count must be positive');
-    }
-    if (count === 0) {
-      return;
-    }
-    const attributes = status
-      ? {
+  private observeStats = async (observer: BatchObservableResult) => {
+    const { itemCount } = await this.poolStats();
+    if (typeof itemCount === 'number') {
+      observer.observe(this.objectsInMempool, itemCount, this.defaultAttributes);
+    } else {
+      for (const [status, count] of Object.entries(itemCount)) {
+        observer.observe(this.objectsInMempool, count, {
           ...this.defaultAttributes,
           [Attributes.STATUS]: status,
-        }
-      : this.defaultAttributes;
-
-    this.objectsInMempool.add(count, attributes);
-  }
-
-  /**
-   * Updates the metrics by removing objects from the mempool.
-   * @param count - The number of objects to remove from the mempool
-   */
-  public recordRemovedObjects(count = 1, status?: string) {
-    if (count < 0) {
-      throw new Error('Count must be positive');
-    }
-    if (count === 0) {
-      return;
+        });
+      }
     }
-
-    const attributes = status
-      ? {
-          ...this.defaultAttributes,
-          [Attributes.STATUS]: status,
-        }
-      : this.defaultAttributes;
-    this.objectsInMempool.add(-1 * count, attributes);
-  }
+  };
 }

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -15,7 +15,7 @@ import assert from 'assert';
 
 import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
 import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
@@ -49,9 +49,6 @@ 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>;
 
@@ -102,7 +99,6 @@ 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.#pendingTxs = new Map<string, Tx>();
     this.#nonEvictableTxs = new Set<string>();
@@ -113,9 +109,20 @@ export class AztecKVTxPool implements TxPool {
     this.#store = store;
     this.#archive = archive;
     this.#worldStateSynchronizer = worldStateSynchronizer;
-    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
+    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTxs, () => store.estimateSize());
   }
 
+  private countTxs: PoolStatsCallback = async () => {
+    const [pending = 0, mined = 0] = await Promise.all([this.getPendingTxCount(), this.getMinedTxCount()]);
+
+    return Promise.resolve({
+      itemCount: {
+        pending,
+        mined,
+      },
+    });
+  };
+
   public async isEmpty(): Promise<boolean> {
     for await (const _ of this.#txs.entriesAsync()) {
       return false;
@@ -128,7 +135,6 @@ export class AztecKVTxPool implements TxPool {
       return Promise.resolve();
     }
 
-    let deletedPending = 0;
     const minedNullifiers = new Set<string>();
     const minedFeePayers = new Set<string>();
 
@@ -143,23 +149,13 @@ export class AztecKVTxPool implements TxPool {
           const nullifiers = tx.data.getNonEmptyNullifiers();
           nullifiers.forEach(nullifier => minedNullifiers.add(nullifier.toString()));
           minedFeePayers.add(tx.data.feePayer.toString());
-
-          deletedPending++;
           pendingTxSize -= tx.getSize();
           await this.removePendingTxIndices(tx, key);
         }
       }
-      this.#metrics.recordAddedObjects(txHashes.length, 'mined');
       await this.#pendingTxSize.set(pendingTxSize);
-      await this.increasePendingTxCount(-deletedPending);
 
-      const numTxsEvicted = await this.evictInvalidTxsAfterMining(
-        txHashes,
-        blockNumber,
-        minedNullifiers,
-        minedFeePayers,
-      );
-      this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
+      await this.evictInvalidTxsAfterMining(txHashes, blockNumber, minedNullifiers, minedFeePayers);
     });
     // 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.
@@ -171,8 +167,6 @@ export class AztecKVTxPool implements TxPool {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
-
-    let markedAsPending = 0;
     await this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
@@ -184,21 +178,14 @@ export class AztecKVTxPool implements TxPool {
         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.increasePendingTxCount(markedAsPending);
-
-    this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
-    this.#metrics.recordRemovedObjects(numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
-    this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
+    await this.evictInvalidTxsAfterReorg(txHashes);
+    await this.evictLowPriorityTxs(txHashes);
   }
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
@@ -212,7 +199,11 @@ export class AztecKVTxPool implements TxPool {
   }
 
   public async getPendingTxCount(): Promise<number> {
-    return (await this.#pendingTxCount.getAsync()) ?? 0;
+    return (await this.#pendingTxHashToHeaderHash.sizeAsync()) ?? 0;
+  }
+
+  public async getMinedTxCount(): Promise<number> {
+    return (await this.#minedTxHashToBlock.sizeAsync()) ?? 0;
   }
 
   public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
@@ -284,7 +275,6 @@ export class AztecKVTxPool implements TxPool {
       txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
     );
     await this.#store.transactionAsync(async () => {
-      let addedCount = 0;
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
         txs.map(async (tx, i) => {
@@ -303,7 +293,6 @@ export class AztecKVTxPool implements TxPool {
           await this.#txs.set(key, tx.toBuffer());
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-            addedCount++;
             pendingTxSize += tx.getSize();
             await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
@@ -311,14 +300,8 @@ 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(addedCount - numNewTxsEvicted, 'pending');
-      this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
+      await this.evictLowPriorityTxs(hashesAndStats.map(({ txHash }) => txHash));
     });
   }
 
@@ -328,9 +311,6 @@ export class AztecKVTxPool implements TxPool {
    * @returns Empty promise.
    */
   public deleteTxs(txHashes: TxHash[], eviction = false): Promise<void> {
-    let pendingDeleted = 0;
-    let minedDeleted = 0;
-
     const deletedTxs: Tx[] = [];
     const poolDbTx = this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
@@ -340,10 +320,7 @@ export class AztecKVTxPool implements TxPool {
 
         if (tx) {
           const isMined = await this.#minedTxHashToBlock.hasAsync(key);
-          if (isMined) {
-            minedDeleted++;
-          } else {
-            pendingDeleted++;
+          if (!isMined) {
             pendingTxSize -= tx.getSize();
             await this.removePendingTxIndices(tx, key);
           }
@@ -358,10 +335,6 @@ export class AztecKVTxPool implements TxPool {
       }
 
       await this.#pendingTxSize.set(pendingTxSize);
-      await this.increasePendingTxCount(-pendingDeleted);
-
-      this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
-      this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
     });
 
     return this.#archivedTxLimit ? poolDbTx.then(() => this.archiveTxs(deletedTxs)) : poolDbTx;
@@ -670,12 +643,4 @@ 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

@@ -3,7 +3,7 @@ import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
@@ -31,9 +31,18 @@ export class InMemoryTxPool implements TxPool {
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTx);
   }
 
+  private countTx: PoolStatsCallback = () => {
+    return Promise.resolve({
+      itemCount: {
+        mined: this.minedTxs.size,
+        pending: this.pendingTxs.size,
+      },
+    });
+  };
+
   public isEmpty(): Promise<boolean> {
     return Promise.resolve(this.txs.size === 0);
   }
@@ -44,8 +53,6 @@ export class InMemoryTxPool implements TxPool {
       this.minedTxs.set(key, blockNumber);
       this.pendingTxs.delete(key);
     }
-    this.metrics.recordRemovedObjects(txHashes.length, 'pending');
-    this.metrics.recordAddedObjects(txHashes.length, 'mined');
     return Promise.resolve();
   }
 
@@ -55,23 +62,15 @@ export class InMemoryTxPool implements TxPool {
     }
 
     const keys = txHashes.map(x => x.toBigInt());
-    let deleted = 0;
-    let added = 0;
     for (const key of keys) {
-      if (this.minedTxs.delete(key)) {
-        deleted++;
-      }
+      this.minedTxs.delete(key);
 
       // only add back to the pending set if we have the tx object
       if (this.txs.has(key)) {
-        added++;
         this.pendingTxs.add(key);
       }
     }
 
-    this.metrics.recordRemovedObjects(deleted, 'mined');
-    this.metrics.recordAddedObjects(added, 'pending');
-
     return Promise.resolve();
   }
 
@@ -131,7 +130,6 @@ export class InMemoryTxPool implements TxPool {
    * @returns Empty promise.
    */
   public async addTxs(txs: Tx[]): Promise<void> {
-    let pending = 0;
     for (const tx of txs) {
       const txHash = await tx.getTxHash();
       this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
@@ -142,14 +140,10 @@ export class InMemoryTxPool implements TxPool {
       const key = txHash.toBigInt();
       this.txs.set(key, tx);
       if (!this.minedTxs.has(key)) {
-        pending++;
         this.metrics.recordSize(tx);
         this.pendingTxs.add(key);
       }
     }
-
-    this.metrics.recordAddedObjects(pending, 'pending');
-    return;
   }
 
   /**
@@ -158,19 +152,13 @@ export class InMemoryTxPool implements TxPool {
    * @returns The number of transactions that was deleted from the pool.
    */
   public deleteTxs(txHashes: TxHash[]): Promise<void> {
-    let deletedMined = 0;
-    let deletedPending = 0;
-
     for (const txHash of txHashes) {
       const key = txHash.toBigInt();
       this.txs.delete(key);
-      deletedPending += this.pendingTxs.delete(key) ? 1 : 0;
-      deletedMined += this.minedTxs.delete(key) ? 1 : 0;
+      this.pendingTxs.delete(key);
+      this.minedTxs.delete(key);
     }
 
-    this.metrics.recordRemovedObjects(deletedPending, 'pending');
-    this.metrics.recordRemovedObjects(deletedMined, 'mined');
-
     return Promise.resolve();
   }
 

package/src/services/encoding.ts

@@ -4,7 +4,7 @@ import { sha256 } from '@aztec/foundation/crypto';
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
 import type { Message } from '@libp2p/interface';
-import { compressSync, uncompressSync } from 'snappy';
+import { compress, compressSync, uncompress, uncompressSync } from 'snappy';
 import xxhashFactory from 'xxhash-wasm';
 
 // Load WASM
@@ -76,4 +76,12 @@ export class SnappyTransform implements DataTransform {
     }
     return Buffer.from(compressSync(data));
   }
+
+  public outboundTransformAsync(data: Buffer): Promise<Buffer> {
+    return compress(data);
+  }
+
+  public inboundTransformAsync(data: Buffer): Promise<Buffer> {
+    return uncompress(data, { asBuffer: true }) as Promise<Buffer>;
+  }
 }

package/src/services/reqresp/reqresp.ts

@@ -5,7 +5,7 @@ import { executeTimeout } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
+import { CodeError, type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
 import type { Libp2p } from 'libp2p';
 import type { Uint8ArrayList } from 'uint8arraylist';
@@ -538,7 +538,7 @@ export class ReqResp {
 
     // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
     // overloaded peer
-    if (e instanceof IndividualReqRespTimeoutError) {
+    if (e instanceof IndividualReqRespTimeoutError || (e instanceof CodeError && e.code === 'ERR_TIMEOUT')) {
       this.logger.debug(
         `Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`,
         logTags,
@@ -573,7 +573,7 @@ export class ReqResp {
       }
 
       const messageData = Buffer.concat(chunks);
-      const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
+      const message = await this.snappyTransform.inboundTransformAsync(messageData);
 
       return {
         status: statusBuffer ?? ReqRespStatus.UNKNOWN,
@@ -651,13 +651,13 @@ export class ReqResp {
             const successChunk = Buffer.from([ReqRespStatus.SUCCESS]);
             yield new Uint8Array(successChunk);
 
-            yield new Uint8Array(transform.outboundTransformNoTopic(response));
+            yield new Uint8Array(await transform.outboundTransformAsync(response));
           }
         },
         stream,
       );
     } catch (e: any) {
-      this.logger.warn('Reqresp Response error: ', e);
+      this.logger.warn(`Reqresp Response error: ${e?.name} ${e?.code} ${e?.message}`, { err: e, protocol });
       this.metrics.recordResponseError(protocol);
 
       // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
@@ -677,7 +677,7 @@ export class ReqResp {
           stream,
         );
       } else {
-        this.logger.debug('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
+        this.logger.trace('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
       }
     } finally {
       //NOTE: All other status codes indicate closed stream.