@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,7 +1,7 @@
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
-import type { Tx } from '@aztec/stdlib/tx';
+import { BlockHeader, GlobalVariables, type Tx } from '@aztec/stdlib/tx';
 
 import type { TxPool } from './tx_pool.js';
 
@@ -12,79 +12,121 @@ import type { TxPool } from './tx_pool.js';
 export function describeTxPool(getTxPool: () => TxPool) {
   let pool: TxPool;
 
+  const minedBlockHeader = BlockHeader.empty({
+    globalVariables: GlobalVariables.empty({ blockNumber: 1, timestamp: 0n }),
+  });
+
   beforeEach(() => {
     pool = getTxPool();
   });
 
-  it('Adds txs to the pool as pending', async () => {
+  afterEach(() => {
+    pool.removeAllListeners('txs-added');
+  });
+
+  it('adds txs to the pool as pending', async () => {
     const tx1 = await mockTx();
 
     await pool.addTxs([tx1]);
-    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
-    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()]);
+    const poolTx = await pool.getTxByHash(tx1.getTxHash());
+    expect(poolTx!.getTxHash()).toEqual(tx1.getTxHash());
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('pending');
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Removes txs from the pool', async () => {
-    const tx1 = await mockTx();
+  it('emits txs-added event with new txs', async () => {
+    const tx1 = await mockTx(); // existing and pending
+    const tx2 = await mockTx(); // mined but not known
+    const tx3 = await mockTx(); // brand new
 
     await pool.addTxs([tx1]);
-    await pool.deleteTxs([await tx1.getTxHash()]);
+    await pool.markAsMined([tx2.getTxHash()], minedBlockHeader);
+
+    let txsFromEvent: Tx[] | undefined = undefined;
+    pool.once('txs-added', ({ txs }) => {
+      txsFromEvent = txs;
+    });
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+    await pool.addTxs([tx1, tx2, tx3]);
+    expect(txsFromEvent).toBeDefined();
+    expect(txsFromEvent).toHaveLength(2);
+    expect(txsFromEvent).toEqual(expect.arrayContaining([tx2, tx3]));
   });
 
-  it('Marks txs as mined', async () => {
+  it('permanently deletes pending txs and soft-deletes mined txs', async () => {
+    const pendingTx = await mockTx(1);
+    const minedTx = await mockTx(2);
+
+    await pool.addTxs([pendingTx, minedTx]);
+    await pool.markAsMined([minedTx.getTxHash()], minedBlockHeader);
+
+    // Delete a pending tx - should be permanently deleted
+    await pool.deleteTxs([pendingTx.getTxHash()]);
+    await expect(pool.getTxByHash(pendingTx.getTxHash())).resolves.toBeUndefined();
+    await expect(pool.getTxStatus(pendingTx.getTxHash())).resolves.toBeUndefined();
+
+    // Delete a mined tx - should be soft-deleted (still in storage)
+    await pool.deleteTxs([minedTx.getTxHash()]);
+    await expect(pool.getTxByHash(minedTx.getTxHash())).resolves.toBeDefined();
+    await expect(pool.getTxStatus(minedTx.getTxHash())).resolves.toEqual('deleted');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+
+    await expect(pool.getPendingTxCount()).resolves.toEqual(0);
+  });
+
+  it('marks txs as mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-    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.getTxByHash(tx1.getTxHash())).resolves.toEqual(tx1);
+    await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
+    await expect(pool.getMinedTxHashes()).resolves.toEqual([[tx1.getTxHash(), 1]]);
+    await expect(pool.getPendingTxHashes()).resolves.toEqual([tx2.getTxHash()]);
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Marks txs as pending after being mined', async () => {
+  it('marks txs as pending after being mined', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
 
     await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
+    await pool.markAsMined([tx1.getTxHash()], minedBlockHeader);
 
-    await pool.markMinedAsPending([await tx1.getTxHash()]);
+    await pool.markMinedAsPending([tx1.getTxHash()]);
     await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
     const pending = await pool.getPendingTxHashes();
     expect(pending).toHaveLength(2);
-    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
+    expect(pending).toEqual(expect.arrayContaining([tx1.getTxHash(), tx2.getTxHash()]));
+    await expect(pool.getPendingTxCount()).resolves.toEqual(2);
   });
 
-  it('Only marks txs as pending if they are known', async () => {
+  it('only marks txs as pending if they are known', async () => {
     const tx1 = await mockTx(1);
     // simulate a situation where not all peers have all the txs
     const tx2 = await mockTx(2);
-    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+    const someTxHashThatThisPeerDidNotSee = tx2.getTxHash();
     await pool.addTxs([tx1]);
     // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
+    await pool.markAsMined([tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], minedBlockHeader);
     expect(await pool.getMinedTxHashes()).toEqual(
       expect.arrayContaining([
-        [await tx1.getTxHash(), 1],
+        [tx1.getTxHash(), 1],
         [someTxHashThatThisPeerDidNotSee, 1],
       ]),
     );
 
     // reorg: both txs should now become available again
-    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
+    await pool.markMinedAsPending([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.getPendingTxHashes()).resolves.toEqual([tx1.getTxHash()]); // tx2 is not in the pool
+    await expect(pool.getPendingTxCount()).resolves.toEqual(1);
   });
 
-  it('Returns all transactions in the pool', async () => {
+  it('returns all transactions in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -94,9 +136,10 @@ 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 () => {
+  it('returns all txHashes in the pool', async () => {
     const tx1 = await mockTx(1);
     const tx2 = await mockTx(2);
     const tx3 = await mockTx(3);
@@ -104,13 +147,56 @@ export function describeTxPool(getTxPool: () => TxPool) {
     await pool.addTxs([tx1, tx2, tx3]);
 
     const poolTxHashes = await pool.getAllTxHashes();
+    const expectedHashes = [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 pending tx hashes sorted by priority', async () => {
+  it('returns txs by their hash', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const requestedTxs = await pool.getTxsByHash([tx1.getTxHash(), tx3.getTxHash()]);
+    expect(requestedTxs).toHaveLength(2);
+    expect(requestedTxs).toEqual(expect.arrayContaining([tx1, tx3]));
+  });
+
+  it('returns a large number of transactions by their hash', async () => {
+    const numTxs = 1000;
+    const txs = await Promise.all(Array.from({ length: numTxs }, (_, i) => mockTx(i)));
+    const hashes = txs.map(tx => tx.getTxHash());
+    await pool.addTxs(txs);
+    const requestedTxs = await pool.getTxsByHash(hashes);
+    expect(requestedTxs).toHaveLength(numTxs);
+    expect(requestedTxs).toEqual(expect.arrayContaining(txs));
+  });
+
+  it('returns whether or not txs exist', async () => {
+    const tx1 = await mockTx(1);
+    const tx2 = await mockTx(2);
+    const tx3 = await mockTx(3);
+
+    await pool.addTxs([tx1, tx2, tx3]);
+
+    const tx4 = await mockTx(4);
+    const tx5 = await mockTx(5);
+
+    const availability = await pool.hasTxs([
+      tx1.getTxHash(),
+      tx2.getTxHash(),
+      tx3.getTxHash(),
+      tx4.getTxHash(),
+      tx5.getTxHash(),
+    ]);
+    expect(availability).toHaveLength(5);
+    expect(availability).toEqual(expect.arrayContaining([true, true, true, false, false]));
+  });
+
+  it('returns pending tx hashes sorted by priority', async () => {
     const withPriorityFee = (tx: Tx, fee: number) => {
       unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
       return tx;
@@ -125,6 +211,103 @@ export function describeTxPool(getTxPool: () => TxPool) {
 
     const poolTxHashes = await pool.getPendingTxHashes();
     expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
+    expect(poolTxHashes).toEqual([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash()));
+  });
+
+  describe('soft-delete', () => {
+    it('soft-deletes mined txs and keeps them in storage', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first tx as mined
+      await pool.markAsMined([txs[0].getTxHash()], minedBlockHeader);
+
+      // Verify initial state
+      await expect(pool.getPendingTxCount()).resolves.toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
+
+      // Delete mined tx - should be soft-deleted
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Delete pending tx - should be permanently deleted
+      await pool.deleteTxs([txs[1].getTxHash()]);
+
+      // Verify mined tx still exists in storage but has 'deleted' status
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+      await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
+
+      // Verify pending tx is permanently deleted
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
+
+      // Verify remaining pending count
+      await expect(pool.getPendingTxCount()).resolves.toBe(1);
+
+      // Verify pending hashes don't include deleted txs
+      const pendingHashes = await pool.getPendingTxHashes();
+      expect(pendingHashes).toHaveLength(1);
+      expect(pendingHashes.map(h => h.toString())).toContain(txs[2].getTxHash().toString());
+    });
+
+    it('cleans up old deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2), mockTx(3)]);
+      await pool.addTxs(txs);
+
+      // Mark first two as mined in block 1
+      await pool.markAsMined([txs[0].getTxHash(), txs[1].getTxHash()], minedBlockHeader);
+
+      // Soft-delete mined transactions
+      await pool.deleteTxs([txs[0].getTxHash(), txs[1].getTxHash()]);
+
+      // Clean up deleted mined txs from block 1 and earlier
+      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+
+      // Verify old transactions are permanently deleted
+      expect(deletedCount).toBe(2);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+      await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('does not clean up recent deleted mined transactions', async () => {
+      const txs = await Promise.all([mockTx(1), mockTx(2)]);
+      await pool.addTxs(txs);
+
+      // Mark as mined in block 2
+      const laterBlockHeader = BlockHeader.empty({
+        globalVariables: GlobalVariables.empty({ blockNumber: 2, timestamp: 0n }),
+      });
+      await pool.markAsMined([txs[0].getTxHash()], laterBlockHeader);
+
+      // Soft-delete a mined transaction
+      await pool.deleteTxs([txs[0].getTxHash()]);
+
+      // Try to clean up with block 1 (before the mined block)
+      const deletedCount = await pool.cleanupDeletedMinedTxs(1);
+
+      // Verify no transactions were cleaned up
+      expect(deletedCount).toBe(0);
+      await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+    });
+
+    it('restores deleted mined tx when it is mined again', async () => {
+      const tx = await mockTx(1);
+      await pool.addTxs([tx]);
+
+      // Mark as mined
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Soft-delete it
+      await pool.deleteTxs([tx.getTxHash()]);
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
+
+      // Mark as mined again (e.g., after a reorg)
+      await pool.markAsMined([tx.getTxHash()], minedBlockHeader);
+
+      // Should be back to mined status
+      await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
+      await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
+    });
   });
 }

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,26 +1,69 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { NoCommitteeError } from '@aztec/ethereum';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCacheInterface;
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
+    this.logger = createLogger('p2p:attestation-validator');
   }
 
   async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
-    const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+    const slotNumber = message.payload.header.slotNumber;
 
-    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
-    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+    try {
+      const { currentProposer, nextProposer, currentSlot, nextSlot } =
+        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
-    const attester = await message.getSender();
-    if (!(await this.epochCache.isInCommittee(attester))) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.warn(`Attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
+        return PeerErrorSeverity.HighToleranceError;
+      }
+
+      // Verify the signature is valid
+      const attester = message.getSender();
+      if (attester === undefined) {
+        this.logger.warn(`Invalid signature in attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
 
-    return undefined;
+      // Verify the attester is in the committee for this slot
+      if (!(await this.epochCache.isInCommittee(slotNumber, attester))) {
+        this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumber}`);
+        return PeerErrorSeverity.HighToleranceError;
+      }
+
+      // Verify the proposer signature matches the expected proposer for this slot
+      const proposer = message.getProposer();
+      const expectedProposer = slotNumber === currentSlot ? currentProposer : nextProposer;
+      if (!expectedProposer) {
+        this.logger.warn(`No proposer defined for slot ${slotNumber}`);
+        return PeerErrorSeverity.HighToleranceError;
+      }
+      if (!proposer) {
+        this.logger.warn(`Invalid proposer signature in attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      if (!proposer.equals(expectedProposer)) {
+        this.logger.warn(
+          `Proposer signature mismatch in attestation. ` +
+            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
+        );
+        return PeerErrorSeverity.HighToleranceError;
+      }
+
+      return undefined;
+    } catch (e) {
+      // People shouldn't be sending us attestations if the committee doesn't exist
+      if (e instanceof NoCommitteeError) {
+        this.logger.warn(`No committee exists for attestation for slot ${slotNumber}`);
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      throw e;
+    }
   }
 }

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -0,0 +1,91 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type BlockAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
+
+import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
+import { AttestationValidator } from './attestation_validator.js';
+
+/**
+ * FishermanAttestationValidator extends the base AttestationValidator to add
+ * additional validation for fisherman nodes: verifying that attestations sign
+ * the same payload as the original proposal.
+ * Invalid attestations are rejected (not propagated), but peer penalization is
+ * handled by LibP2PService based on the fishermanMode config to ensure a better
+ * view of the network.
+ */
+export class FishermanAttestationValidator extends AttestationValidator {
+  private invalidAttestationCounter;
+
+  constructor(
+    epochCache: EpochCacheInterface,
+    private attestationPool: AttestationPool,
+    telemetryClient: TelemetryClient,
+  ) {
+    super(epochCache);
+    this.logger = this.logger.createChild('[FISHERMAN]');
+
+    const meter = telemetryClient.getMeter('FishermanAttestationValidator');
+    this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT, {
+      description: 'The number of invalid attestations received',
+      valueType: ValueType.INT,
+    });
+  }
+
+  override async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+    // First run the standard validation
+    const baseValidationResult = await super.validate(message);
+    if (baseValidationResult !== undefined) {
+      // Track base validation failures (invalid signature, wrong committee, etc.)
+      this.invalidAttestationCounter.add(1, {
+        [Attributes.ERROR_TYPE]: 'base_validation_failed',
+      });
+      return baseValidationResult;
+    }
+
+    // fisherman validation: verify attestation payload matches proposal payload
+    const slotNumberBigInt = message.payload.header.slotNumber;
+    const attester = message.getSender();
+    const proposer = message.getProposer();
+
+    if (!attester || !proposer) {
+      return undefined;
+    }
+
+    const proposalId = message.archive.toString();
+    const proposal = await this.attestationPool.getBlockProposal(proposalId);
+
+    if (proposal) {
+      // Compare the attestation payload with the proposal payload
+      if (!message.payload.equals(proposal.payload)) {
+        this.logger.error(
+          `Attestation payload mismatch for slot ${slotNumberBigInt}! ` +
+            `Attester ${attester.toString()} signed different data than the proposal.`,
+          {
+            slot: slotNumberBigInt.toString(),
+            attester: attester.toString(),
+            proposer: proposer.toString(),
+            proposalArchive: proposal.archive.toString(),
+            attestationArchive: message.archive.toString(),
+            proposalHeader: proposal.payload.header.hash().toString(),
+            attestationHeader: message.payload.header.hash().toString(),
+          },
+        );
+
+        // Track invalid attestation metric
+        this.invalidAttestationCounter.add(1, {
+          [Attributes.ERROR_TYPE]: 'payload_mismatch',
+        });
+
+        // Return error to reject the message, but LibP2PService won't penalize in fisherman mode
+        return PeerErrorSeverity.LowToleranceError;
+      }
+    } else {
+      // We might receive attestations before proposals in some cases
+      this.logger.debug(
+        `Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`,
+      );
+    }
+
+    return undefined;
+  }
+}

package/src/msg_validators/attestation_validator/index.ts

@@ -1 +1,2 @@
 export * from './attestation_validator.js';
+export * from './fisherman_attestation_validator.js';

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,29 +1,97 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { NoCommitteeError } from '@aztec/ethereum';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
 export class BlockProposalValidator implements P2PValidator<BlockProposal> {
   private epochCache: EpochCacheInterface;
+  private logger: Logger;
+  private txsPermitted: boolean;
 
-  constructor(epochCache: EpochCacheInterface) {
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
     this.epochCache = epochCache;
+    this.txsPermitted = opts.txsPermitted;
+    this.logger = createLogger('p2p:block_proposal_validator');
   }
 
   async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
-    const { currentProposer, nextProposer, currentSlot, nextSlot } =
-      await this.epochCache.getProposerInCurrentOrNextSlot();
+    try {
+      // Check signature validity first - invalid signatures are a high-severity issue
+      const proposer = block.getSender();
+      if (!proposer) {
+        this.logger.debug(`Penalizing peer for block proposal with invalid signature`);
+        return PeerErrorSeverity.MidToleranceError;
+      }
 
-    // Check that the attestation is for the current or next slot
-    const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
-    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+      // Check if transactions are permitted when the proposal contains transaction hashes
+      const embeddedTxCount = block.txs?.length ?? 0;
+      if (!this.txsPermitted && (block.txHashes.length > 0 || embeddedTxCount > 0)) {
+        this.logger.debug(
+          `Penalizing peer for block proposal with ${block.txHashes.length} transaction(s) when transactions are not permitted`,
+        );
+        return PeerErrorSeverity.MidToleranceError;
+      }
 
-    // Check that the block proposal is from the current or next proposer
-    const proposer = await block.getSender();
-    if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+      // If there are embedded txs, they must be listed in txHashes; if there are no txHashes, there must be no txs
+      const hashSet = new Set(block.txHashes.map(h => h.toString()));
+      const missingTxHashes =
+        embeddedTxCount > 0
+          ? block.txs!.filter(tx => !hashSet.has(tx.getTxHash().toString())).map(tx => tx.getTxHash().toString())
+          : [];
+      if (embeddedTxCount > 0 && missingTxHashes.length > 0) {
+        this.logger.warn('Penalizing peer for embedded transaction(s) not included in txHashes', {
+          embeddedTxCount,
+          txHashesLength: block.txHashes.length,
+          missingTxHashes,
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      const { currentProposer, nextProposer, currentSlot, nextSlot } =
+        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+
+      // Check that the attestation is for the current or next slot
+      const slotNumber = block.payload.header.slotNumber;
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+        return PeerErrorSeverity.HighToleranceError;
+      }
 
-    return undefined;
+      // Check that the block proposal is from the current or next proposer
+      if (slotNumber === currentSlot && currentProposer !== undefined && !proposer.equals(currentProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
+          currentProposer,
+          nextProposer,
+          proposer: proposer.toString(),
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
+        this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
+          currentProposer,
+          nextProposer,
+          proposer: proposer.toString(),
+        });
+        return PeerErrorSeverity.MidToleranceError;
+      }
+
+      // Validate tx hashes for all txs embedded in the proposal
+      if (!(await Promise.all(block.txs?.map(tx => tx.validateTxHash()) ?? [])).every(v => v)) {
+        this.logger.warn(`Penalizing peer for invalid tx hashes in block proposal`, {
+          proposer,
+          slotNumber,
+        });
+        return PeerErrorSeverity.LowToleranceError;
+      }
+
+      return undefined;
+    } catch (e) {
+      // People shouldn't be sending us block proposals if the committee doesn't exist
+      if (e instanceof NoCommitteeError) {
+        return PeerErrorSeverity.LowToleranceError;
+      }
+      throw e;
+    }
   }
 }

package/src/msg_validators/msg_seen_validator/msg_seen_validator.ts

@@ -0,0 +1,36 @@
+// Implements a queue of message IDs
+export class MessageSeenValidator {
+  private queue: Array<string>;
+  private writePointer = 0;
+  private seenMessages: Set<string> = new Set();
+
+  constructor(private queueLength: number) {
+    if (this.queueLength <= 0) {
+      throw new Error('Queue length must be greater than 0');
+    }
+    this.queue = new Array<string>(this.queueLength);
+  }
+
+  // Adds a message if not seen before. Returns true if added, false if already seen.
+  public addMessage(msgId: string): boolean {
+    // Check if the message is already in the cache
+    if (this.seenMessages.has(msgId)) {
+      return false;
+    }
+    // If we are at the cache limit, remove the oldest msg ID
+    if (this.seenMessages.size >= this.queueLength) {
+      const msgToRemove = this.queue[this.writePointer];
+      this.seenMessages.delete(msgToRemove);
+    }
+
+    // Insert the message into the cache and the queue
+    this.seenMessages.add(msgId);
+    this.queue[this.writePointer] = msgId;
+    this.writePointer = this.writePointer === this.queueLength - 1 ? 0 : this.writePointer + 1;
+    return true;
+  }
+
+  public size() {
+    return this.seenMessages.size;
+  }
+}