@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,26 +1,84 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import {
+  type CheckpointAttestation,
+  type P2PValidator,
+  PeerErrorSeverity,
+  type ValidationResult,
+} from '@aztec/stdlib/p2p';
 
-export class AttestationValidator implements P2PValidator<BlockAttestation> {
-  private epochCache: EpochCacheInterface;
+import { isWithinClockTolerance } from '../clock_tolerance.js';
+
+export class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
+    this.logger = createLogger('p2p:checkpoint-attestation-validator');
   }
 
-  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
-    const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
+  async validate(message: CheckpointAttestation): Promise<ValidationResult> {
+    const slotNumber = message.payload.header.slotNumber;
 
-    const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
-    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+    try {
+      const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
 
-    const attester = await message.getSender();
-    if (!(await this.epochCache.isInCommittee(attester))) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        // Check if message is for previous slot and within clock tolerance
+        if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
+          this.logger.warn(
+            `Checkpoint attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`,
+          );
+          return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+        }
+        this.logger.debug(`Ignoring checkpoint attestation for previous slot ${slotNumber} within clock tolerance`);
+        return { result: 'ignore' };
+      }
+
+      // Verify the signature is valid
+      const attester = message.getSender();
+      if (attester === undefined) {
+        this.logger.warn(`Invalid signature in checkpoint attestation for slot ${slotNumber}`);
+        return { result: 'reject', severity: 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 { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+      }
+
+      // Verify the proposer signature matches the expected proposer for the attestation's slot
+      // We look up the proposer for the specific slot rather than using currentSlot/nextSlot
+      // since timing differences could cause mismatches
+      const proposer = message.getProposer();
+      const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
+      if (!expectedProposer) {
+        this.logger.warn(`No proposer defined for slot ${slotNumber}`);
+        return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+      }
+      if (!proposer) {
+        this.logger.warn(`Invalid proposer signature in checkpoint attestation for slot ${slotNumber}`);
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
+      }
+      if (!proposer.equals(expectedProposer)) {
+        this.logger.warn(
+          `Proposer signature mismatch in checkpoint attestation. ` +
+            `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
+        );
+        return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+      }
+
+      return { result: 'accept' };
+    } 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 checkpoint attestation for slot ${slotNumber}`);
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
+      }
+      throw e;
+    }
   }
 }

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -0,0 +1,94 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type CheckpointAttestation, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, type TelemetryClient, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+
+import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
+import { CheckpointAttestationValidator } 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 CheckpointAttestationValidator {
+  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 = createUpDownCounterWithDefault(
+      meter,
+      Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: ['base_validation_failed', 'payload_mismatch'],
+      },
+    );
+  }
+
+  override async validate(message: CheckpointAttestation): Promise<ValidationResult> {
+    // First run the standard validation
+    const baseValidationResult = await super.validate(message);
+    if (baseValidationResult.result !== 'accept') {
+      // 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 { result: 'accept' };
+    }
+
+    const proposalId = message.archive.toString();
+    const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
+
+    if (proposal) {
+      // Compare the attestation payload with the proposal payload
+      if (!message.payload.equals(proposal)) {
+        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.checkpointHeader.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 { result: 'reject', severity: 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 { result: 'accept' };
+  }
+}

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/clock_tolerance.ts

@@ -0,0 +1,51 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+
+/**
+ * Maximum clock disparity tolerance for P2P message validation (in milliseconds).
+ * Messages for the previous slot are accepted if we're within this many milliseconds
+ * of the current slot start. This prevents penalizing peers for messages that
+ * were valid when sent but arrived slightly late due to network latency.
+ *
+ * This follows Ethereum's MAXIMUM_GOSSIP_CLOCK_DISPARITY approach.
+ */
+export const MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS = 500;
+
+/**
+ * Checks if a message for the previous slot should be accepted due to clock tolerance.
+ *
+ * @param messageSlot - The slot number from the received message
+ * @param currentSlot - The current slot number
+ * @param epochCache - EpochCache to get timing information
+ * @returns true if the message is for the previous slot AND we're within the clock tolerance window
+ */
+export function isWithinClockTolerance(
+  messageSlot: SlotNumber,
+  currentSlot: SlotNumber,
+  epochCache: EpochCacheInterface,
+): boolean {
+  // Guard against slot 0 edge case (genesis)
+  if (currentSlot === SlotNumber.ZERO) {
+    return false;
+  }
+
+  // Only apply tolerance to messages for the previous slot
+  const previousSlot = SlotNumber(currentSlot - 1);
+  if (messageSlot !== previousSlot) {
+    return false;
+  }
+
+  // Check how far we are into the current slot (in milliseconds)
+  const { ts: slotStartTs, nowMs, slot } = epochCache.getEpochAndSlotNow();
+
+  // Sanity check: ensure the epoch cache's current slot matches the expected current slot
+  if (slot !== currentSlot) {
+    return false;
+  }
+
+  // ts is in seconds, convert to ms; nowMs is already in milliseconds
+  const slotStartMs = slotStartTs * 1000n;
+  const elapsedMs = Number(nowMs - slotStartMs);
+
+  return elapsedMs < MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS;
+}

package/src/msg_validators/index.ts

@@ -1,3 +1,3 @@
 export * from './tx_validator/index.js';
-export * from './block_proposal_validator/index.js';
+export * from './proposal_validator/index.js';
 export * from './attestation_validator/index.js';

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;
+  }
+}

package/src/msg_validators/proposal_validator/block_proposal_validator.ts

@@ -0,0 +1,10 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { BlockProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class BlockProposalValidator extends ProposalValidator<BlockProposal> implements P2PValidator<BlockProposal> {
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:block_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/checkpoint_proposal_validator.ts

@@ -0,0 +1,13 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { CheckpointProposal, P2PValidator } from '@aztec/stdlib/p2p';
+
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+
+export class CheckpointProposalValidator
+  extends ProposalValidator<CheckpointProposal>
+  implements P2PValidator<CheckpointProposal>
+{
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+    super(epochCache, opts, 'p2p:checkpoint_proposal_validator');
+  }
+}

package/src/msg_validators/proposal_validator/index.ts

@@ -0,0 +1,3 @@
+export * from './block_proposal_validator.js';
+export * from './checkpoint_proposal_validator.js';
+export * from './proposal_validator.js';

package/src/msg_validators/proposal_validator/proposal_validator.ts

@@ -0,0 +1,92 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
+
+import { isWithinClockTolerance } from '../clock_tolerance.js';
+
+export abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
+  protected txsPermitted: boolean;
+
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }, loggerName: string) {
+    this.epochCache = epochCache;
+    this.txsPermitted = opts.txsPermitted;
+    this.logger = createLogger(loggerName);
+  }
+
+  public async validate(proposal: TProposal): Promise<ValidationResult> {
+    try {
+      // Slot check
+      const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
+      const slotNumber = proposal.slotNumber;
+      if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+        // Check if message is for previous slot and within clock tolerance
+        if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
+          this.logger.warn(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+          return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+        }
+        this.logger.verbose(`Ignoring proposal for previous slot ${slotNumber} within clock tolerance`);
+        return { result: 'ignore' };
+      }
+
+      // Signature validity
+      const proposer = proposal.getSender();
+      if (!proposer) {
+        this.logger.warn(`Penalizing peer for proposal with invalid signature`);
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
+      }
+
+      // Transactions permitted check
+      const embeddedTxCount = proposal.txs?.length ?? 0;
+      if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
+        this.logger.warn(
+          `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
+        );
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
+      }
+
+      // Embedded txs must be listed in txHashes
+      const hashSet = new Set(proposal.txHashes.map(h => h.toString()));
+      const missingTxHashes =
+        embeddedTxCount > 0
+          ? proposal.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: proposal.txHashes.length,
+          missingTxHashes,
+        });
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
+      }
+
+      // Proposer check
+      const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
+      if (expectedProposer !== undefined && !proposer.equals(expectedProposer)) {
+        this.logger.warn(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
+          expectedProposer,
+          proposer: proposer.toString(),
+        });
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
+      }
+
+      // Validate tx hashes for all txs embedded in the proposal
+      if (!(await Promise.all(proposal.txs?.map(tx => tx.validateTxHash()) ?? [])).every(v => v)) {
+        this.logger.warn(`Penalizing peer for invalid tx hashes in proposal`, {
+          proposer,
+          slotNumber,
+        });
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
+      }
+
+      return { result: 'accept' };
+    } catch (e) {
+      if (e instanceof NoCommitteeError) {
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
+      }
+      throw e;
+    }
+  }
+}

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -0,0 +1,230 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import {
+  type BlockProposal,
+  type CheckpointProposal,
+  PeerErrorSeverity,
+  type ValidationResult,
+} from '@aztec/stdlib/p2p';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+import type { MockProxy } from 'jest-mock-extended';
+
+export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
+  validatorFactory: (
+    epochCache: EpochCacheInterface,
+    opts: { txsPermitted: boolean },
+  ) => { validate: (proposal: TProposal) => Promise<ValidationResult> };
+  makeProposal: (options?: any) => Promise<TProposal>;
+  makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
+  getSigner: () => Secp256k1Signer;
+  getAddress: (signer?: Secp256k1Signer) => EthAddress;
+  getSlot: (slot: number | bigint) => any;
+  getTxHashes: (n: number) => TxHash[];
+  getTxs: () => any[];
+  epochCacheMock: () => MockProxy<EpochCacheInterface>;
+}
+
+export function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(
+  params: ProposalValidatorTestParams<TProposal>,
+) {
+  const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } =
+    params;
+
+  describe('shared proposal validation logic', () => {
+    let epochCache: MockProxy<EpochCacheInterface>;
+    let validator: { validate: (proposal: TProposal) => Promise<ValidationResult> };
+    const previousSlot = getSlot(99);
+    const currentSlot = getSlot(100);
+    const nextSlot = getSlot(101);
+
+    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress, previousProposer?: EthAddress) {
+      epochCache.getProposerAttesterAddressInSlot.mockImplementation(slot => {
+        if (slot === currentSlot) {
+          return Promise.resolve(currentProposer);
+        }
+        if (slot === nextSlot) {
+          return Promise.resolve(nextProposer);
+        }
+        if (slot === previousSlot && previousProposer) {
+          return Promise.resolve(previousProposer);
+        }
+        throw new Error('Unexpected argument');
+      });
+    }
+
+    beforeEach(() => {
+      epochCache = epochCacheMock();
+      validator = validatorFactory(epochCache, { txsPermitted: true });
+      epochCache.getCurrentAndNextSlot.mockReturnValue({
+        currentSlot: currentSlot,
+        nextSlot: nextSlot,
+      });
+    });
+
+    it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async () => {
+      const header = makeHeader(1, 99, 99);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
+
+      // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1001000n, // 1000ms elapsed, outside 500ms tolerance
+      });
+
+      epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.HighToleranceError });
+
+      // Should not try to resolve proposers if base validation fails
+      expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
+    });
+
+    it('returns ignore if previous slot proposal is within clock tolerance', async () => {
+      const previousProposer = getSigner();
+      const header = makeHeader(1, 99, 99);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: previousProposer,
+      });
+
+      // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1000100n, // 100ms elapsed, within 500ms tolerance
+      });
+
+      mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'ignore' });
+    });
+
+    it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
+    });
+
+    it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const invalidProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: invalidProposer,
+      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
+    });
+
+    it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
+    });
+
+    it('returns undefined if proposal is valid for current slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 100, 100);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: currentProposer,
+      });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'accept' });
+    });
+
+    it('returns undefined if proposal is valid for next slot and proposer', async () => {
+      const currentProposer = getSigner();
+      const nextProposer = getSigner();
+      const header = makeHeader(1, 101, 101);
+      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
+
+      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'accept' });
+    });
+
+    describe('transaction permission validation', () => {
+      it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
+      });
+
+      it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
+        const currentProposer = getSigner();
+        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(0),
+        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
+        const result = await validatorWithTxsDisabled.validate(mockProposal);
+        expect(result).toEqual({ result: 'accept' });
+      });
+
+      it('returns undefined if txs permitted and proposal contains txHashes', async () => {
+        const currentProposer = getSigner();
+        const header = makeHeader(1, 100, 100);
+        const mockProposal = await makeProposal({
+          blockHeader: header,
+          lastBlockHeader: header,
+          signer: currentProposer,
+          txHashes: getTxHashes(2),
+        });
+
+        mockGetProposer(getAddress(currentProposer), getAddress());
+        const result = await validator.validate(mockProposal);
+        expect(result).toEqual({ result: 'accept' });
+      });
+    });
+  });
+}