@aztec/p2p 3.0.0-nightly.20251026 → 3.0.0-nightly.20251030-2

package/dest/services/libp2p/libp2p_service.js

@@ -430,7 +430,11 @@ import { P2PInstrumentation } from './instrumentation.js';
         const result = await this.node.services.pubsub.publish(topic, p2pMessage.toMessageData());
         return result.recipients.length;
     }
-    preValidateReceivedMessage(msg, msgId, source) {
+    /**
+   * Checks if this message has already been seen, based on its msgId computed from hashing the message data.
+   * Note that we do not rely on the seenCache from gossipsub since we want to keep a longer history of seen
+   * messages to avoid tx echoes across the network.
+   */ preValidateReceivedMessage(msg, msgId, source) {
         let topicType;
         switch(msg.topic){
             case this.topicStrings[TopicType.tx]:
@@ -484,32 +488,52 @@ import { P2PInstrumentation } from './instrumentation.js';
     }
     async validateReceivedMessage(validationFunc, msgId, source, topicType) {
         let resultAndObj = {
-            result: false,
-            obj: undefined
+            result: TopicValidatorResult.Reject
         };
         const timer = new Timer();
         try {
             resultAndObj = await validationFunc();
         } catch (err) {
-            this.logger.error(`Error deserializing and validating message `, err);
+            this.logger.error(`Error deserializing and validating gossipsub message`, err, {
+                msgId,
+                source: source.toString(),
+                topicType
+            });
         }
-        if (resultAndObj.result) {
+        if (resultAndObj.result === TopicValidatorResult.Accept) {
             this.instrumentation.recordMessageValidation(topicType, timer);
         }
-        this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), resultAndObj.result && resultAndObj.obj ? TopicValidatorResult.Accept : TopicValidatorResult.Reject);
+        this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), resultAndObj.result);
         return resultAndObj;
     }
     async handleGossipedTx(payloadData, msgId, source) {
         const validationFunc = async ()=>{
             const tx = Tx.fromBuffer(payloadData);
-            const result = await this.validatePropagatedTx(tx, source);
-            return {
-                result,
-                obj: tx
-            };
+            const isValid = await this.validatePropagatedTx(tx, source);
+            const exists = isValid && await this.mempools.txPool.hasTx(tx.getTxHash());
+            this.logger.trace(`Validate propagated tx`, {
+                isValid,
+                exists,
+                [Attributes.P2P_ID]: source.toString()
+            });
+            if (!isValid) {
+                return {
+                    result: TopicValidatorResult.Reject
+                };
+            } else if (exists) {
+                return {
+                    result: TopicValidatorResult.Ignore,
+                    obj: tx
+                };
+            } else {
+                return {
+                    result: TopicValidatorResult.Accept,
+                    obj: tx
+                };
+            }
         };
         const { result, obj: tx } = await this.validateReceivedMessage(validationFunc, msgId, source, TopicType.tx);
-        if (!result || !tx) {
+        if (result !== TopicValidatorResult.Accept || !tx) {
             return;
         }
         const txHash = tx.getTxHash();
@@ -519,7 +543,7 @@ import { P2PInstrumentation } from './instrumentation.js';
             txHash: txHashString
         });
         if (this.config.dropTransactions && randomInt(1000) < this.config.dropTransactionsProbability * 1000) {
-            this.logger.debug(`Intentionally dropping tx ${txHashString} (probability rule)`);
+            this.logger.warn(`Intentionally dropping tx ${txHashString} (probability rule)`);
             return;
         }
         await this.mempools.txPool.addTxs([
@@ -534,18 +558,32 @@ import { P2PInstrumentation } from './instrumentation.js';
    */ async processAttestationFromPeer(payloadData, msgId, source) {
         const validationFunc = async ()=>{
             const attestation = BlockAttestation.fromBuffer(payloadData);
-            const result = await this.validateAttestation(source, attestation);
-            this.logger.trace(`validatePropagatedAttestation: ${result}`, {
+            const isValid = await this.validateAttestation(source, attestation);
+            const exists = isValid && await this.mempools.attestationPool.hasAttestation(attestation);
+            this.logger.trace(`Validate propagated block attestation`, {
+                isValid,
+                exists,
                 [Attributes.SLOT_NUMBER]: attestation.payload.header.slotNumber.toString(),
                 [Attributes.P2P_ID]: source.toString()
             });
-            return {
-                result,
-                obj: attestation
-            };
+            if (!isValid) {
+                return {
+                    result: TopicValidatorResult.Reject
+                };
+            } else if (exists) {
+                return {
+                    result: TopicValidatorResult.Ignore,
+                    obj: attestation
+                };
+            } else {
+                return {
+                    result: TopicValidatorResult.Accept,
+                    obj: attestation
+                };
+            }
         };
         const { result, obj: attestation } = await this.validateReceivedMessage(validationFunc, msgId, source, TopicType.block_attestation);
-        if (!result || !attestation) {
+        if (result !== TopicValidatorResult.Accept || !attestation) {
             return;
         }
         this.logger.debug(`Received attestation for slot ${attestation.slotNumber.toNumber()} from external peer ${source.toString()}`, {
@@ -561,15 +599,29 @@ import { P2PInstrumentation } from './instrumentation.js';
     async processBlockFromPeer(payloadData, msgId, source) {
         const validationFunc = async ()=>{
             const block = BlockProposal.fromBuffer(payloadData);
-            const result = await this.validateBlockProposal(source, block);
-            this.logger.trace(`validatePropagatedBlock: ${result}`, {
+            const isValid = await this.validateBlockProposal(source, block);
+            const exists = isValid && await this.mempools.attestationPool.hasBlockProposal(block);
+            this.logger.trace(`Validate propagated block proposal`, {
+                isValid,
+                exists,
                 [Attributes.SLOT_NUMBER]: block.payload.header.slotNumber.toString(),
                 [Attributes.P2P_ID]: source.toString()
             });
-            return {
-                result,
-                obj: block
-            };
+            if (!isValid) {
+                return {
+                    result: TopicValidatorResult.Reject
+                };
+            } else if (exists) {
+                return {
+                    result: TopicValidatorResult.Ignore,
+                    obj: block
+                };
+            } else {
+                return {
+                    result: TopicValidatorResult.Accept,
+                    obj: block
+                };
+            }
         };
         const { result, obj: block } = await this.validateReceivedMessage(validationFunc, msgId, source, TopicType.block_proposal);
         if (!result || !block) {

package/dest/services/reqresp/reqresp.js

@@ -362,7 +362,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                 }
             }
             const messageData = Buffer.concat(chunks);
-            const message = this.snappyTransform.inboundTransformNoTopic(messageData);
+            const message = this.snappyTransform.inboundTransformData(messageData);
             return {
                 status: status ?? ReqRespStatus.UNKNOWN,
                 data: message
@@ -462,7 +462,7 @@ import { ReqRespStatus, ReqRespStatusError, parseStatusChunk, prettyPrintReqResp
                 }
                 stream.metadata.written = true; // Mark the stream as written to;
                 yield SUCCESS;
-                yield snappy.outboundTransformNoTopic(response);
+                yield snappy.outboundTransformData(response);
             }
         }, stream.sink);
     }

package/dest/testbench/p2p_client_testbench_worker.js

@@ -34,6 +34,7 @@ function mockTxPool() {
         getTxStatus: ()=>Promise.resolve(TxStatus.PENDING),
         getTxsByHash: ()=>Promise.resolve([]),
         hasTxs: ()=>Promise.resolve([]),
+        hasTx: ()=>Promise.resolve(false),
         updateConfig: ()=>{},
         markTxsAsNonEvictable: ()=>Promise.resolve(),
         cleanupDeletedMinedTxs: ()=>Promise.resolve(0)
@@ -51,7 +52,9 @@ function mockAttestationPool() {
         getAttestationsForSlot: ()=>Promise.resolve([]),
         getAttestationsForSlotAndProposal: ()=>Promise.resolve([]),
         addBlockProposal: ()=>Promise.resolve(),
-        getBlockProposal: ()=>Promise.resolve(undefined)
+        getBlockProposal: ()=>Promise.resolve(undefined),
+        hasBlockProposal: ()=>Promise.resolve(false),
+        hasAttestation: ()=>Promise.resolve(false)
     };
 }
 function mockEpochCache() {

package/dest/testbench/testbench.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import { mockTx } from '@aztec/stdlib/testing';
 import assert from 'assert';
 import path from 'path';
@@ -34,7 +34,7 @@ async function main() {
         logger.info('Workers Ready');
         // Send tx from client 0
         const tx = await mockTx(1, {
-            clientIvcProof: ClientIvcProof.random()
+            chonkProof: ChonkProof.random()
         });
         workerClientManager.processes[0].send({
             type: 'SEND_TX',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "3.0.0-nightly.20251026",
+  "version": "3.0.0-nightly.20251030-2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -67,17 +67,17 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "3.0.0-nightly.20251026",
-    "@aztec/epoch-cache": "3.0.0-nightly.20251026",
-    "@aztec/ethereum": "3.0.0-nightly.20251026",
-    "@aztec/foundation": "3.0.0-nightly.20251026",
-    "@aztec/kv-store": "3.0.0-nightly.20251026",
-    "@aztec/noir-contracts.js": "3.0.0-nightly.20251026",
-    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20251026",
-    "@aztec/protocol-contracts": "3.0.0-nightly.20251026",
-    "@aztec/simulator": "3.0.0-nightly.20251026",
-    "@aztec/stdlib": "3.0.0-nightly.20251026",
-    "@aztec/telemetry-client": "3.0.0-nightly.20251026",
+    "@aztec/constants": "3.0.0-nightly.20251030-2",
+    "@aztec/epoch-cache": "3.0.0-nightly.20251030-2",
+    "@aztec/ethereum": "3.0.0-nightly.20251030-2",
+    "@aztec/foundation": "3.0.0-nightly.20251030-2",
+    "@aztec/kv-store": "3.0.0-nightly.20251030-2",
+    "@aztec/noir-contracts.js": "3.0.0-nightly.20251030-2",
+    "@aztec/noir-protocol-circuits-types": "3.0.0-nightly.20251030-2",
+    "@aztec/protocol-contracts": "3.0.0-nightly.20251030-2",
+    "@aztec/simulator": "3.0.0-nightly.20251030-2",
+    "@aztec/stdlib": "3.0.0-nightly.20251030-2",
+    "@aztec/telemetry-client": "3.0.0-nightly.20251030-2",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/libp2p-yamux": "^6.0.2",
@@ -104,8 +104,8 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "3.0.0-nightly.20251026",
-    "@aztec/world-state": "3.0.0-nightly.20251026",
+    "@aztec/archiver": "3.0.0-nightly.20251030-2",
+    "@aztec/world-state": "3.0.0-nightly.20251030-2",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -21,6 +21,15 @@ export interface AttestationPool {
    */
   getBlockProposal(id: string): Promise<BlockProposal | undefined>;
 
+  /**
+   * Check if a block proposal exists in the pool
+   *
+   * @param idOrProposal - The ID of the block proposal or the block proposal itself to check. The ID is proposal.payload.archive
+   *
+   * @return True if the block proposal exists, false otherwise.
+   */
+  hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean>;
+
   /**
    * AddAttestations
    *
@@ -84,6 +93,14 @@ export interface AttestationPool {
    */
   getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
 
+  /**
+   * Check if a specific attestation exists in the pool
+   *
+   * @param attestation - The attestation to check
+   * @return True if the attestation exists, false otherwise
+   */
+  hasAttestation(attestation: BlockAttestation): Promise<boolean>;
+
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;
 }

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -72,6 +72,11 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(retrievedAttestations.length).toBe(attestations.length);
     compareAttestations(retrievedAttestations, attestations);
 
+    // Check hasAttestation for added attestations
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
     const retrievedAttestationsForSlot = await ap.getAttestationsForSlot(BigInt(slotNumber));
     expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
     compareAttestations(retrievedAttestationsForSlot, attestations);
@@ -85,6 +90,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     );
     expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsAfterAdd, [...attestations, newAttestation]);
+    expect(await ap.hasAttestation(newAttestation)).toBe(true);
     const retrievedAttestationsForSlotAfterAdd = await ap.getAttestationsForSlot(BigInt(slotNumber));
     expect(retrievedAttestationsForSlotAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsForSlotAfterAdd, [...attestations, newAttestation]);
@@ -97,6 +103,11 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       archive.toString(),
     );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
+    expect(await ap.hasAttestation(newAttestation)).toBe(false);
   });
 
   it('should handle duplicate proposals in a slot', async () => {
@@ -170,10 +181,20 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
+    // Check hasAttestation before deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
     await ap.deleteAttestations(attestations);
 
     const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
     expect(gottenAfterDelete.length).toBe(0);
+
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
   });
 
   it('should blanket delete attestations per slot', async () => {
@@ -265,12 +286,19 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!).toEqual(proposal);
+
+      // Check hasBlockProposal with both id and object
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
     });
 
     it('should return undefined for non-existent block proposal', async () => {
       const nonExistentId = Fr.random().toString();
       const retrievedProposal = await ap.getBlockProposal(nonExistentId);
       expect(retrievedProposal).toBeUndefined();
+
+      // Check hasBlockProposal returns false for non-existent proposal
+      expect(await ap.hasBlockProposal(nonExistentId)).toBe(false);
     });
 
     it('should update block proposal if added twice with same id', async () => {
@@ -323,6 +351,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       // Delete attestations for slot and proposal
       await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
@@ -330,6 +359,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(false);
     });
 
     it('should delete block proposal when deleting attestations for slot', async () => {
@@ -344,6 +374,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
 
       // Delete attestations for slot
       await ap.deleteAttestationsForSlot(BigInt(slotNumber));
@@ -351,6 +382,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(false);
     });
 
     it('should be able to fetch both block proposal and attestations', async () => {
@@ -372,8 +404,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal).toEqual(proposal);
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       compareAttestations(retrievedAttestations, attestations);
+      // Check hasAttestation for all attestations
+      for (const attestation of attestations) {
+        expect(await ap.hasAttestation(attestation)).toBe(true);
+      }
     });
   });
 }

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -213,6 +213,22 @@ export class KvAttestationPool implements AttestationPool {
     });
   }
 
+  public async hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive;
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return false;
+    }
+
+    const address = sender.toString();
+    const key = this.getAttestationKey(slotNumber, proposalId, address);
+
+    return await this.attestations.hasAsync(key);
+  }
+
   public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     const buffer = await this.proposals.getAsync(id);
     try {
@@ -226,6 +242,11 @@ export class KvAttestationPool implements AttestationPool {
     return Promise.resolve(undefined);
   }
 
+  public async hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return await this.proposals.hasAsync(id);
+  }
+
   public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     await this.store.transactionAsync(async () => {
       await this.proposalsForSlot.set(blockProposal.slotNumber.toString(), blockProposal.archive.toString());

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -173,6 +173,29 @@ export class InMemoryAttestationPool implements AttestationPool {
     return Promise.resolve();
   }
 
+  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive.toString();
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return Promise.resolve(false);
+    }
+
+    const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+    if (!slotAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    const proposalAttestationMap = slotAttestationMap.get(proposalId);
+    if (!proposalAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    return Promise.resolve(proposalAttestationMap.has(sender.toString()));
+  }
+
   public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     // We initialize slot-proposal mapping if it does not exist
     // This is important to ensure we can delete this proposal if there were not attestations for it
@@ -186,6 +209,11 @@ export class InMemoryAttestationPool implements AttestationPool {
   public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     return Promise.resolve(this.proposals.get(id));
   }
+
+  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
 }
 
 /**

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -6,7 +6,7 @@ import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncMultiMap, AztecAsyncSi
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
@@ -273,6 +273,11 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return await Promise.all(txHashes.map(txHash => this.#txs.hasAsync(txHash.toString())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   /**
    * Checks if an archived tx exists and returns it.
    * @param txHash - The tx hash.
@@ -546,7 +551,7 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
           const archivedTx: Tx = new Tx(
             tx.txHash,
             tx.data,
-            ClientIvcProof.empty(),
+            ChonkProof.empty(),
             tx.contractClassLogFields,
             tx.publicFunctionCalldata,
           );

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -151,6 +151,11 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
     return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   public getArchivedTxByHash(): Promise<Tx | undefined> {
     return Promise.resolve(undefined);
   }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -43,6 +43,13 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    */
   hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
 
+  /**
+   * Checks if a transaction exists in the pool
+   * @param txHash - The hash of the transaction to check for
+   * @returns True if the transaction exists, false otherwise
+   */
+  hasTx(txHash: TxHash): Promise<boolean>;
+
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.

package/src/services/encoding.ts

@@ -1,5 +1,7 @@
 // Taken from lodestar: https://github.com/ChainSafe/lodestar
 import { sha256 } from '@aztec/foundation/crypto';
+import { createLogger } from '@aztec/foundation/log';
+import { TopicType, getTopicFromString } from '@aztec/stdlib/p2p';
 
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
@@ -49,31 +51,104 @@ export function getMsgIdFn(message: Message) {
   return sha256(Buffer.concat(vec)).subarray(0, 20);
 }
 
+const DefaultMaxSizesKb: Record<TopicType, number> = {
+  // Tx effects should not exceed 128kb, so 512kb for the full tx obj should be sufficient
+  [TopicType.tx]: 512,
+  // An attestation has roughly 30 fields, which is 1kb, so 5x is plenty
+  [TopicType.block_attestation]: 5,
+  // 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,
+};
+
 /**
  * Snappy transform for libp2p gossipsub
  */
 export class SnappyTransform implements DataTransform {
+  constructor(
+    private maxSizesKb: Record<TopicType, number> = DefaultMaxSizesKb,
+    private defaultMaxSizeKb: number = 10 * 1024,
+    private logger = createLogger('p2p:snappy-transform'),
+  ) {}
+
   // Topic string included to satisfy DataTransform interface
-  inboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    return this.inboundTransformNoTopic(Buffer.from(data));
+  inboundTransform(topicStr: string, data: Uint8Array): Uint8Array {
+    const topic = getTopicFromString(topicStr);
+    return this.inboundTransformData(Buffer.from(data), topic);
   }
 
-  public inboundTransformNoTopic(data: Buffer): Buffer {
+  public inboundTransformData(data: Buffer, topic?: TopicType): Buffer {
     if (data.length === 0) {
       return data;
     }
+    const maxSizeKb = 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`);
+    }
+
     return Buffer.from(uncompressSync(data, { asBuffer: true }));
   }
 
   // Topic string included to satisfy DataTransform interface
   outboundTransform(_topicStr: string, data: Uint8Array): Uint8Array {
-    return this.outboundTransformNoTopic(Buffer.from(data));
+    return this.outboundTransformData(Buffer.from(data));
   }
 
-  public outboundTransformNoTopic(data: Buffer): Buffer {
+  public outboundTransformData(data: Buffer): Buffer {
     if (data.length === 0) {
       return data;
     }
     return Buffer.from(compressSync(data));
   }
 }
+
+/**
+ * Reads the Snappy preamble from compressed data and returns the expected decompressed size.
+ *
+ * The Snappy format starts with a little-endian varint encoding the uncompressed length.
+ * Varints consist of a series of bytes where:
+ * - Lower 7 bits contain data
+ * - Upper bit (0x80) is set if more bytes follow
+ *
+ * @param data - The compressed data starting with the Snappy preamble
+ * @returns Object containing the decompressed size and the number of bytes read from the preamble
+ * @throws Error if the data is too short or the varint is invalid
+ */
+export function readSnappyPreamble(data: Uint8Array): { decompressedSize: number; bytesRead: number } {
+  if (data.length === 0) {
+    throw new Error('Cannot read preamble from empty data');
+  }
+
+  let result = 0;
+  let shift = 0;
+  let bytesRead = 0;
+
+  // Maximum varint length for 32-bit value is 5 bytes
+  // (7 bits per byte, so 5 bytes = 35 bits, enough for 2^32 - 1)
+  const maxBytes = 5;
+
+  for (let i = 0; i < Math.min(data.length, maxBytes); i++) {
+    const byte = data[i];
+    bytesRead++;
+
+    // Extract lower 7 bits and add to result with appropriate shift
+    // Use >>> 0 to convert to unsigned 32-bit integer to avoid sign issues
+    result = (result | ((byte & 0x7f) << shift)) >>> 0;
+
+    // If upper bit is not set, we're done
+    if ((byte & 0x80) === 0) {
+      return { decompressedSize: result, bytesRead };
+    }
+
+    shift += 7;
+  }
+
+  // If we get here, either we ran out of data or the varint is too long
+  if (bytesRead >= maxBytes) {
+    throw new Error('Varint is too long (max 5 bytes for 32-bit value)');
+  }
+
+  throw new Error('Incomplete varint: data ended before varint termination');
+}