@aztec/p2p 0.0.1-commit.2ed92850 → 0.0.1-commit.2f68f620

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -1,16 +1,25 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
-import { createLogger } from '@aztec/foundation/log';
-import {
-  type AnyTx,
-  TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP,
-  type TxValidationResult,
-  type TxValidator,
-  getTxHash,
-} from '@aztec/stdlib/tx';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+import { TX_ERROR_INVALID_EXPIRATION_TIMESTAMP, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
-export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
-  #log = createLogger('p2p:tx_validator:timestamp');
+/** Structural interface for timestamp validation. */
+export interface HasTimestampData {
+  txHash: { toString(): string };
+  data: {
+    expirationTimestamp: bigint;
+    constants: {
+      anchorBlockHeader: {
+        globalVariables: {
+          blockNumber: BlockNumber;
+        };
+      };
+    };
+  };
+}
+
+export class TimestampTxValidator<T extends HasTimestampData> implements TxValidator<T> {
+  #log: Logger;
 
   constructor(
     private values: {
@@ -20,28 +29,27 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
       // Block number in which the tx is considered to be included.
       blockNumber: BlockNumber;
     },
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:timestamp', bindings);
+  }
 
   validateTx(tx: T): Promise<TxValidationResult> {
-    const includeByTimestamp = tx.data.includeByTimestamp;
-    // If building block 1, we skip the expiration check. For details on why see the `validate_include_by_timestamp`
+    const expirationTimestamp = tx.data.expirationTimestamp;
+    // If building block 1, we skip the expiration check. For details on why see the `validate_expiration_timestamp`
     // function in `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/base/components/validation_requests.nr`.
     const buildingBlock1 = this.values.blockNumber === 1;
 
-    if (!buildingBlock1 && includeByTimestamp < this.values.timestamp) {
+    if (!buildingBlock1 && expirationTimestamp < this.values.timestamp) {
       if (tx.data.constants.anchorBlockHeader.globalVariables.blockNumber === 0) {
         this.#log.warn(
           `A tx built against a genesis block failed to be included in block 1 which is the only block in which txs built against a genesis block are allowed to be included.`,
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${getTxHash(
-          tx,
-        )} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
-          this.values.timestamp
-        }.`,
+        `Rejecting tx ${tx.txHash} for low expiration timestamp. Tx expiration timestamp: ${expirationTimestamp}, timestamp: ${this.values.timestamp}.`,
       );
-      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP] });
+      return Promise.resolve({ result: 'invalid', reason: [TX_ERROR_INVALID_EXPIRATION_TIMESTAMP] });
     } else {
       return Promise.resolve({ result: 'valid' });
     }

package/src/msg_validators/tx_validator/tx_permitted_validator.ts

@@ -1,10 +1,15 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { Tx, TxValidationResult, TxValidator } from '@aztec/stdlib/tx';
 
 export class TxPermittedValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:tx_permitted');
+  #log: Logger;
 
-  constructor(private permitted: boolean) {}
+  constructor(
+    private permitted: boolean,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:tx_permitted', bindings);
+  }
 
   validateTx(tx: Tx): Promise<TxValidationResult> {
     if (!this.permitted) {

package/src/msg_validators/tx_validator/tx_proof_validator.ts

@@ -1,11 +1,18 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
 import { TX_ERROR_INVALID_PROOF, Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
 
 export class TxProofValidator implements TxValidator<Tx> {
-  #log = createLogger('p2p:tx_validator:private_proof');
+  public readonly identifier: symbol = Symbol('TxProofValidator');
 
-  constructor(private verifier: ClientProtocolCircuitVerifier) {}
+  #log: Logger;
+
+  constructor(
+    private verifier: ClientProtocolCircuitVerifier,
+    bindings?: LoggerBindings,
+  ) {
+    this.#log = createLogger('p2p:tx_validator:proof', bindings);
+  }
 
   async validateTx(tx: Tx): Promise<TxValidationResult> {
     const result = await this.verifier.verifyProof(tx);

package/src/msg_validators/tx_validator/tx_validation_cache.ts

@@ -0,0 +1,101 @@
+import { LruMap } from '@aztec/foundation/collection';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { Tx, TxValidationResult } from '@aztec/stdlib/tx';
+
+import { createHash } from 'node:crypto';
+
+/**
+ * Minimal interface consumed by {@link CachedTxValidator}.
+ * Keeping the dependency on an interface lets callers (and tests) substitute any cache implementation.
+ */
+export interface ITxValidationCache {
+  /** Returns the cached promise if present, otherwise calls `validate`, caches its promise, and returns it. */
+  getOrValidate(
+    validatorSymbol: symbol,
+    tx: Tx,
+    validate: () => Promise<TxValidationResult>,
+  ): Promise<TxValidationResult>;
+}
+
+/**
+ * Caches per-validator tx validation results to avoid redundant work across repeated validation calls.
+ *
+ * The cache key is composed from the validator symbol and tx hash, ensuring results are
+ * scoped to the specific validator that produced them.
+ *
+ * Promises are stored before they are awaited, so concurrent calls for the same pair share
+ * a single in-flight validation rather than launching duplicate work.
+ *
+ * Entries are evicted in least-recently-used order once the cache reaches `maxSize`.
+ */
+export class TxValidationCache implements ITxValidationCache {
+  #log: Logger;
+
+  private readonly entries: LruMap<string, Promise<TxValidationResult>>;
+  // Remember hashes for known Tx object references to skip rehashing on subsequent lookups.
+  // WeakMap holds keys weakly, so an entry doesn't keep the Tx alive once nothing else references it.
+  private readonly txHashesCache: WeakMap<Tx, string> = new WeakMap();
+
+  constructor(maxSize: number) {
+    this.entries = new LruMap(maxSize);
+    this.#log = createLogger('p2p:tx_validation_cache');
+  }
+
+  /**
+   * Computes the cache key scoping a validation result to a specific validator and tx.
+   *
+   * @param validatorSymbol - The symbol of the validator.
+   * @param tx - The tx to compute the key for.
+   * @returns The cache key.
+   *
+   * Note: the key should NOT use the tx.hash because it can't be trusted at this point.
+   */
+  public key(validatorSymbol: symbol, tx: Tx): string {
+    // Serializing the tx dominates cost (~5 ms). If we have already hashed this object, skip toBuffer + hash.
+    let hash = this.txHashesCache.get(tx);
+    if (hash === undefined) {
+      hash = createHash('sha256').update(tx.toBuffer()).digest('hex');
+      this.txHashesCache.set(tx, hash);
+    }
+    return `${Symbol.keyFor(validatorSymbol) ?? validatorSymbol.toString()}:${hash}`;
+  }
+
+  /** Returns the cached promise for the given key, or undefined if not cached. Refreshes recency. */
+  public get(key: string): Promise<TxValidationResult> | undefined {
+    return this.entries.get(key);
+  }
+
+  /** Stores a validation promise under the given key, evicting the LRU entry if at capacity. */
+  public set(key: string, result: Promise<TxValidationResult>): void {
+    this.entries.set(key, result);
+  }
+
+  /** Removes the cached validation promise for the given key. */
+  public delete(key: string): void {
+    this.entries.delete(key);
+  }
+
+  /**
+   * Returns the cached promise if present, otherwise calls `validate`, stores its promise
+   * immediately (before awaiting), and returns it.
+   */
+  public getOrValidate(
+    validatorSymbol: symbol,
+    tx: Tx,
+    validate: () => Promise<TxValidationResult>,
+  ): Promise<TxValidationResult> {
+    const key = this.key(validatorSymbol, tx);
+    const cached = this.get(key);
+    if (cached !== undefined) {
+      this.#log.debug('Returning cached tx validation result', {
+        validator: validatorSymbol.toString(),
+        txHash: tx.txHash.toString(),
+        key: key,
+      });
+      return cached;
+    }
+    const promise = validate();
+    this.set(key, promise);
+    return promise;
+  }
+}

package/src/services/data_store.ts

@@ -24,17 +24,16 @@ class KeyNotFoundError extends Error {
 }
 
 export class AztecDatastore implements Datastore {
+  #db: AztecAsyncKVStore;
   #memoryDatastore: Map<string, MemoryItem>;
   #dbDatastore: AztecAsyncMap<string, Uint8Array>;
 
-  #batchOps: BatchOp[] = [];
-
   private maxMemoryItems: number;
 
   constructor(db: AztecAsyncKVStore, { maxMemoryItems } = { maxMemoryItems: 50 }) {
+    this.#db = db;
     this.#memoryDatastore = new Map();
     this.#dbDatastore = db.openMap('p2p_datastore');
-
     this.maxMemoryItems = maxMemoryItems;
   }
 
@@ -91,29 +90,25 @@ export class AztecDatastore implements Datastore {
   }
 
   batch(): Batch {
+    const ops: BatchOp[] = [];
     return {
       put: (key, value) => {
-        this.#batchOps.push({
-          type: 'put',
-          key,
-          value,
-        });
+        ops.push({ type: 'put', key, value });
       },
       delete: key => {
-        this.#batchOps.push({
-          type: 'del',
-          key,
-        });
+        ops.push({ type: 'del', key });
       },
       commit: async () => {
-        for (const op of this.#batchOps) {
-          if (op.type === 'put' && op.value) {
-            await this.put(op.key, op.value);
-          } else if (op.type === 'del') {
-            await this.delete(op.key);
+        await this.#db.transactionAsync(async () => {
+          for (const op of ops) {
+            if (op.type === 'put' && op.value) {
+              await this.put(op.key, op.value);
+            } else if (op.type === 'del') {
+              await this.delete(op.key);
+            }
           }
-        }
-        this.#batchOps = []; // Clear operations after commit
+        });
+        ops.length = 0;
       },
     };
   }

package/src/services/discv5/discV5_service.ts

@@ -38,6 +38,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
 
   private startTime = 0;
 
+  private currentIp: string | undefined;
+
   private handlers = {
     onMultiaddrUpdated: this.onMultiaddrUpdated.bind(this),
     onDiscovered: this.onDiscovered.bind(this),
@@ -53,8 +55,10 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     configOverrides: Partial<IDiscv5CreateOptions> = {},
   ) {
     super();
+
     const { p2pIp, p2pPort, p2pBroadcastPort, bootstrapNodes, trustedPeers, privatePeers } = config;
 
+    this.currentIp = p2pIp;
     this.bootstrapNodeEnrs = bootstrapNodes.map(x => ENR.decodeTxt(x));
     const privatePeerEnrs = new Set(privatePeers);
     this.trustedPeerEnrs = trustedPeers.filter(x => !privatePeerEnrs.has(x)).map(x => ENR.decodeTxt(x));
@@ -87,7 +91,7 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
       this.packageVersion,
     ));
 
-    const metricsRegistry = new OtelMetricsAdapter(telemetry);
+    const metricsRegistry = new OtelMetricsAdapter(telemetry, this.logger.getBindings());
     this.discv5 = Discv5.create({
       enr: this.enr,
       peerId,
@@ -96,7 +100,8 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
         lookupTimeout: 2000,
         requestTimeout: 2000,
         allowUnverifiedSessions: true,
-        enrUpdate: !p2pIp ? true : false, // If no p2p IP is set, enrUpdate can automatically resolve it
+        enrUpdate: config.queryForIp || !p2pIp,
+        pingInterval: config.queryForIp ? 10_000 : 300_000,
         ...configOverrides.config,
       },
       metricsRegistry,
@@ -127,11 +132,34 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
   }
 
   private onMultiaddrUpdated(m: Multiaddr) {
-    // We want to update our tcp port to match the udp port
-    // p2pBroadcastPort is optional on config, however it is set to default within the p2p client factory
-    const multiAddrTcp = multiaddr(convertToMultiaddr(m.nodeAddress().address, this.config.p2pBroadcastPort!, 'tcp'));
+    const newIp = m.nodeAddress().address;
+    const previousIp = this.currentIp;
+
+    if (newIp === previousIp) {
+      this.logger.debug('Discv5 confirmed current IP (no change)', { ip: newIp });
+      return;
+    }
+
+    const multiAddrTcp = multiaddr(convertToMultiaddr(newIp, this.config.p2pBroadcastPort!, 'tcp'));
     this.enr.setLocationMultiaddr(multiAddrTcp);
-    this.logger.info('Multiaddr updated', { multiaddr: multiAddrTcp.toString() });
+    this.currentIp = newIp;
+
+    if (previousIp) {
+      this.logger.info('IP address changed, ENR updated', {
+        previousIp,
+        newIp,
+        multiaddr: multiAddrTcp.toString(),
+        enr: this.enr.encodeTxt(),
+      });
+    } else {
+      this.logger.info('Initial IP discovered via discv5, ENR updated', {
+        ip: newIp,
+        multiaddr: multiAddrTcp.toString(),
+        enr: this.enr.encodeTxt(),
+      });
+    }
+
+    this.emit('ip:changed', newIp);
   }
 
   public async start(): Promise<void> {
@@ -142,12 +170,17 @@ export class DiscV5Service extends EventEmitter implements PeerDiscoveryService
     await this.discv5.start();
     this.startTime = Date.now();
 
+    const enrUpdateEnabled = this.config.queryForIp || !this.config.p2pIp;
     this.logger.info(`DiscV5 service started`, {
       nodeId: this.enr.nodeId,
       peerId: this.peerId,
       enrUdp: await this.enr.getFullMultiaddr('udp'),
       enrTcp: await this.enr.getFullMultiaddr('tcp'),
       versions: this.versions,
+      enrUpdateEnabled,
+      queryForIp: this.config.queryForIp,
+      configuredIp: this.config.p2pIp ?? 'none',
+      pingIntervalMs: this.config.queryForIp ? 10_000 : 300_000,
     });
     this.currentState = PeerDiscoveryState.RUNNING;
 

package/src/services/dummy_service.ts

@@ -1,6 +1,6 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
-import type { Gossipable, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { Gossipable, PeerErrorSeverity, TopicType } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -8,7 +8,9 @@ import type { ENR } from '@nethermindeth/enr';
 import EventEmitter from 'events';
 
 import type { PeerManagerInterface } from './peer-manager/interface.js';
+import type { BatchTxRequesterLibP2PService } from './reqresp/batch-tx-requester/interface.js';
 import type { P2PReqRespConfig } from './reqresp/config.js';
+import type { ConnectionSampler } from './reqresp/connection-sampler/connection_sampler.js';
 import { type AuthRequest, StatusMessage } from './reqresp/index.js';
 import type {
   ReqRespInterface,
@@ -16,14 +18,16 @@ import type {
   ReqRespSubProtocol,
   ReqRespSubProtocolHandler,
   ReqRespSubProtocolHandlers,
-  ReqRespSubProtocolValidators,
   SubProtocolMap,
 } from './reqresp/interface.js';
 import type { GoodByeReason } from './reqresp/protocols/goodbye.js';
 import { ReqRespStatus } from './reqresp/status.js';
 import {
   type P2PBlockReceivedCallback,
+  type P2PCheckpointAttestationCallback,
   type P2PCheckpointReceivedCallback,
+  type P2PDuplicateAttestationCallback,
+  type P2PDuplicateProposalCallback,
   type P2PService,
   type PeerDiscoveryService,
   PeerDiscoveryState,
@@ -33,6 +37,8 @@ import {
  * A dummy implementation of the P2P Service.
  */
 export class DummyP2PService implements P2PService {
+  private allNodesCheckpointReceivedCallback?: P2PCheckpointReceivedCallback;
+
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
 
   /** Returns an empty array for peers. */
@@ -40,6 +46,10 @@ export class DummyP2PService implements P2PService {
     return [];
   }
 
+  getGossipMeshPeerCount(_topicType: TopicType): number {
+    return 0;
+  }
+
   /**
    * Starts the dummy implementation.
    * @returns A resolved promise.
@@ -78,7 +88,22 @@ export class DummyP2PService implements P2PService {
   /**
    * Register a callback into the validator client for when a checkpoint proposal is received
    */
-  public registerCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+  public registerValidatorCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+  public registerAllNodesCheckpointReceivedCallback(callback: P2PCheckpointReceivedCallback) {
+    this.allNodesCheckpointReceivedCallback = callback;
+  }
+
+  /**
+   * Register a callback for when a duplicate proposal is detected
+   */
+  public registerDuplicateProposalCallback(_callback: P2PDuplicateProposalCallback): void {}
+
+  /**
+   * Register a callback for when a duplicate attestation is detected
+   */
+  public registerDuplicateAttestationCallback(_callback: P2PDuplicateAttestationCallback): void {}
+
+  public registerCheckpointAttestationCallback(_callback: P2PCheckpointAttestationCallback): void {}
 
   /**
    * Sends a request to a peer.
@@ -93,17 +118,13 @@ export class DummyP2PService implements P2PService {
     return Promise.resolve(undefined);
   }
 
-  /**
-   * Sends a batch request to a peer.
-   * @param _protocol - The protocol to send the request on.
-   * @param _requests - The requests to send.
-   * @returns The responses from the peer, otherwise undefined.
-   */
-  public sendBatchRequest<Protocol extends ReqRespSubProtocol>(
-    _protocol: Protocol,
-    _requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
-  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[]> {
-    return Promise.resolve([]);
+  public sendRequestToPeer(
+    _peerId: PeerId,
+    _subProtocol: ReqRespSubProtocol,
+    _payload: Buffer,
+    _dialTimeout?: number,
+  ): Promise<ReqRespResponse> {
+    return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
   }
 
   /**
@@ -114,15 +135,11 @@ export class DummyP2PService implements P2PService {
     return undefined;
   }
 
-  validate(_txs: Tx[]): Promise<void> {
+  validateTxsReceivedInBlockProposal(_txs: Tx[]): Promise<void> {
     return Promise.resolve();
   }
 
-  addReqRespSubProtocol(
-    _subProtocol: ReqRespSubProtocol,
-    _handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  addReqRespSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
     return Promise.resolve();
   }
 
@@ -132,6 +149,28 @@ export class DummyP2PService implements P2PService {
 
   //this is no-op
   registerThisValidatorAddresses(_address: EthAddress[]): void {}
+
+  /**
+   * Get dummy BatchTxRequesterLibP2PService for testing
+   */
+  getBatchTxRequesterService(): BatchTxRequesterLibP2PService {
+    return {
+      reqResp: this, // The dummy service implements ReqRespInterface
+      connectionSampler: new DummyReqResp().getConnectionSampler(),
+      txValidatorConfig: {
+        l1ChainId: 1,
+        rollupVersion: 1,
+        proofVerifier: {
+          verifyProof: () => Promise.resolve({ valid: true, durationMs: 0, totalDurationMs: 0 }),
+          stop: () => Promise.resolve(),
+        },
+      },
+      peerScoring: {
+        penalizePeer: (_peerId, _penalty) => {},
+      },
+      validateRequestedBlockTxsConsistency: () => Promise.resolve(true),
+    };
+  }
 }
 
 /**
@@ -234,10 +273,8 @@ export class DummyPeerManager implements PeerManagerInterface {
 
 export class DummyReqResp implements ReqRespInterface {
   updateConfig(_config: Partial<P2PReqRespConfig>): void {}
-  start(
-    _subProtocolHandlers: ReqRespSubProtocolHandlers,
-    _subProtocolValidators: ReqRespSubProtocolValidators,
-  ): Promise<void> {
+  setShouldRejectPeer(): void {}
+  start(_subProtocolHandlers: ReqRespSubProtocolHandlers): Promise<void> {
     return Promise.resolve();
   }
   stop(): Promise<void> {
@@ -249,16 +286,6 @@ export class DummyReqResp implements ReqRespInterface {
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
     return Promise.resolve(undefined);
   }
-  sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
-    _subProtocol: SubProtocol,
-    _requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
-    _pinnedPeer: PeerId | undefined,
-    _timeoutMs?: number,
-    _maxPeers?: number,
-    _maxRetryAttempts?: number,
-  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
-    return Promise.resolve([]);
-  }
   public sendRequestToPeer(
     _peerId: PeerId,
     _subProtocol: ReqRespSubProtocol,
@@ -268,11 +295,16 @@ export class DummyReqResp implements ReqRespInterface {
     return Promise.resolve({ status: ReqRespStatus.SUCCESS, data: Buffer.from([]) });
   }
 
-  addSubProtocol(
-    _subProtocol: ReqRespSubProtocol,
-    _handler: ReqRespSubProtocolHandler,
-    _validator?: ReqRespSubProtocolValidators[ReqRespSubProtocol],
-  ): Promise<void> {
+  /**
+   * Get dummy connection sampler for testing
+   */
+  getConnectionSampler(): Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'> {
+    return {
+      getPeerListSortedByConnectionCountAsc: () => [],
+    };
+  }
+
+  addSubProtocol(_subProtocol: ReqRespSubProtocol, _handler: ReqRespSubProtocolHandler): Promise<void> {
     return Promise.resolve();
   }
 }

package/src/services/encoding.ts

@@ -1,14 +1,22 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
-import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { createLogger } from '@aztec/foundation/log';
 import { MAX_TX_SIZE_KB, TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
 import type { Message } from '@libp2p/interface';
+import { webcrypto } from 'node:crypto';
 import { compressSync, uncompressSync } from 'snappy';
 import xxhashFactory from 'xxhash-wasm';
 
+/** Thrown when a Snappy-compressed response exceeds the allowed decompressed size. */
+export class OversizedSnappyResponseError extends Error {
+  constructor(decompressedSize: number, maxSizeKb: number) {
+    super(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);
+    this.name = 'OversizedSnappyResponseError';
+  }
+}
+
 // Load WASM
 const xxhash = await xxhashFactory();
 
@@ -44,11 +52,10 @@ export function msgIdToStrFn(msgId: Uint8Array): string {
  * @param message - The libp2p message
  * @returns The message identifier
  */
-export function getMsgIdFn(message: Message) {
-  const { topic } = message;
-
-  const vec = [Buffer.from(topic), message.data];
-  return sha256(Buffer.concat(vec)).subarray(0, 20);
+export async function getMsgIdFn({ topic, data }: Message): Promise<Uint8Array> {
+  const buffer = Buffer.concat([Buffer.from(topic), data]);
+  const hash = await webcrypto.subtle.digest('SHA-256', buffer);
+  return Buffer.from(hash.slice(0, 20));
 }
 
 const DefaultMaxSizesKb: Record<TopicType, number> = {
@@ -58,7 +65,8 @@ const DefaultMaxSizesKb: Record<TopicType, number> = {
   // Proposals may carry some tx objects, so we allow a larger size capped at 10mb
   // Note this may not be enough for carrying all tx objects in a block
   [TopicType.block_proposal]: 1024 * 10,
-  // TODO(palla/mbps): Check size for checkpoint proposal
+  // Checkpoint proposals carry almost the same data as a block proposal (see the lastBlockProposal)
+  // Only diff is an additional header, which is pretty small compared to the 10mb limit
   [TopicType.checkpoint_proposal]: 1024 * 10,
 };
 
@@ -78,15 +86,15 @@ export class SnappyTransform implements DataTransform {
     return this.inboundTransformData(Buffer.from(data), topic);
   }
 
-  public inboundTransformData(data: Buffer, topic?: TopicType): Buffer {
+  public inboundTransformData(data: Buffer, topic?: TopicType, maxSizeKbOverride?: number): Buffer {
     if (data.length === 0) {
       return data;
     }
-    const maxSizeKb = this.maxSizesKb[topic!] ?? this.defaultMaxSizeKb;
+    const maxSizeKb = maxSizeKbOverride ?? this.maxSizesKb[topic!] ?? this.defaultMaxSizeKb;
     const { decompressedSize } = readSnappyPreamble(data);
     if (decompressedSize > maxSizeKb * 1024) {
       this.logger.warn(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);
-      throw new Error(`Decompressed size ${decompressedSize} exceeds maximum allowed size of ${maxSizeKb}kb`);
+      throw new OversizedSnappyResponseError(decompressedSize, maxSizeKb);
     }
 
     return Buffer.from(uncompressSync(data, { asBuffer: true }));