@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/msg_validators/attestation_validator/attestation_validator.js

@@ -1,19 +1,57 @@
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { createLogger } from '@aztec/foundation/log';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export class AttestationValidator {
+export class CheckpointAttestationValidator {
     epochCache;
+    logger;
     constructor(epochCache){
         this.epochCache = epochCache;
+        this.logger = createLogger('p2p:checkpoint-attestation-validator');
     }
     async validate(message) {
-        const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
-        const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
-        if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-            return PeerErrorSeverity.HighToleranceError;
+        const slotNumber = message.payload.header.slotNumber;
+        try {
+            const { currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+            if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+                this.logger.warn(`Checkpoint 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 checkpoint attestation for slot ${slotNumber}`);
+                return PeerErrorSeverity.LowToleranceError;
+            }
+            // 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 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 PeerErrorSeverity.HighToleranceError;
+            }
+            if (!proposer) {
+                this.logger.warn(`Invalid proposer signature in checkpoint attestation for slot ${slotNumber}`);
+                return 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 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 checkpoint attestation for slot ${slotNumber}`);
+                return PeerErrorSeverity.LowToleranceError;
+            }
+            throw e;
         }
-        const attester = await message.getSender();
-        if (!await this.epochCache.isInCommittee(attester)) {
-            return PeerErrorSeverity.HighToleranceError;
-        }
-        return undefined;
     }
 }

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts

@@ -0,0 +1,20 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type CheckpointAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type TelemetryClient } 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 declare class FishermanAttestationValidator extends CheckpointAttestationValidator {
+    private attestationPool;
+    private invalidAttestationCounter;
+    constructor(epochCache: EpochCacheInterface, attestationPool: AttestationPool, telemetryClient: TelemetryClient);
+    validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlzaGVybWFuX2F0dGVzdGF0aW9uX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci9maXNoZXJtYW5fYXR0ZXN0YXRpb25fdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUFFLEtBQUsscUJBQXFCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRixPQUFPLEVBQXVCLEtBQUssZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEYsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sc0RBQXNELENBQUM7QUFDNUYsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFNUU7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLDZCQUE4QixTQUFRLDhCQUE4QjtJQUs3RSxPQUFPLENBQUMsZUFBZTtJQUp6QixPQUFPLENBQUMseUJBQXlCLENBQUM7SUFFbEMsWUFDRSxVQUFVLEVBQUUsbUJBQW1CLEVBQ3ZCLGVBQWUsRUFBRSxlQUFlLEVBQ3hDLGVBQWUsRUFBRSxlQUFlLEVBT2pDO0lBRWMsUUFBUSxDQUFDLE9BQU8sRUFBRSxxQkFBcUIsR0FBRyxPQUFPLENBQUMsaUJBQWlCLEdBQUcsU0FBUyxDQUFDLENBd0Q5RjtDQUNGIn0=

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fisherman_attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/fisherman_attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAClF,OAAO,EAAuB,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sDAAsD,CAAC;AAC5F,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,6BAA8B,SAAQ,8BAA8B;IAK7E,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,yBAAyB,CAAC;IAElC,YACE,UAAU,EAAE,mBAAmB,EACvB,eAAe,EAAE,eAAe,EACxC,eAAe,EAAE,eAAe,EAOjC;IAEc,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAwD9F;CACF"}

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.js

@@ -0,0 +1,64 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics } from '@aztec/telemetry-client';
+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 {
+    attestationPool;
+    invalidAttestationCounter;
+    constructor(epochCache, attestationPool, telemetryClient){
+        super(epochCache), this.attestationPool = attestationPool;
+        this.logger = this.logger.createChild('[FISHERMAN]');
+        const meter = telemetryClient.getMeter('FishermanAttestationValidator');
+        this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT);
+    }
+    async validate(message) {
+        // 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.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 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/dest/msg_validators/attestation_validator/index.d.ts

@@ -1,2 +1,3 @@
 export * from './attestation_validator.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './fisherman_attestation_validator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9hdHRlc3RhdGlvbl92YWxpZGF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHNDQUFzQyxDQUFDIn0=

package/dest/msg_validators/attestation_validator/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC"}

package/dest/msg_validators/attestation_validator/index.js

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

package/dest/msg_validators/index.d.ts

@@ -1,4 +1,4 @@
 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';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyxrQ0FBa0MsQ0FBQyJ9

package/dest/msg_validators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/msg_validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/msg_validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC"}

package/dest/msg_validators/index.js

@@ -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/dest/msg_validators/msg_seen_validator/msg_seen_validator.d.ts

@@ -0,0 +1,10 @@
+export declare class MessageSeenValidator {
+    private queueLength;
+    private queue;
+    private writePointer;
+    private seenMessages;
+    constructor(queueLength: number);
+    addMessage(msgId: string): boolean;
+    size(): number;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXNnX3NlZW5fdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvbXNnX3NlZW5fdmFsaWRhdG9yL21zZ19zZWVuX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxxQkFBYSxvQkFBb0I7SUFLbkIsT0FBTyxDQUFDLFdBQVc7SUFKL0IsT0FBTyxDQUFDLEtBQUssQ0FBZ0I7SUFDN0IsT0FBTyxDQUFDLFlBQVksQ0FBSztJQUN6QixPQUFPLENBQUMsWUFBWSxDQUEwQjtJQUU5QyxZQUFvQixXQUFXLEVBQUUsTUFBTSxFQUt0QztJQUdNLFVBQVUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FnQnhDO0lBRU0sSUFBSSxXQUVWO0NBQ0YifQ==

package/dest/msg_validators/msg_seen_validator/msg_seen_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg_seen_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/msg_seen_validator/msg_seen_validator.ts"],"names":[],"mappings":"AACA,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,WAAW;IAJ/B,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,YAAY,CAA0B;IAE9C,YAAoB,WAAW,EAAE,MAAM,EAKtC;IAGM,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAgBxC;IAEM,IAAI,WAEV;CACF"}

package/dest/msg_validators/msg_seen_validator/msg_seen_validator.js

@@ -0,0 +1,36 @@
+// Implements a queue of message IDs
+export class MessageSeenValidator {
+    queueLength;
+    queue;
+    writePointer;
+    seenMessages;
+    constructor(queueLength){
+        this.queueLength = queueLength;
+        this.writePointer = 0;
+        this.seenMessages = new Set();
+        if (this.queueLength <= 0) {
+            throw new Error('Queue length must be greater than 0');
+        }
+        this.queue = new Array(this.queueLength);
+    }
+    // Adds a message if not seen before. Returns true if added, false if already seen.
+    addMessage(msgId) {
+        // 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;
+    }
+    size() {
+        return this.seenMessages.size;
+    }
+}

package/dest/msg_validators/proposal_validator/block_proposal_validator.d.ts

@@ -0,0 +1,9 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { BlockProposal, P2PValidator } from '@aztec/stdlib/p2p';
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+export declare class BlockProposalValidator extends ProposalValidator<BlockProposal> implements P2PValidator<BlockProposal> {
+    constructor(epochCache: EpochCacheInterface, opts: {
+        txsPermitted: boolean;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfcHJvcG9zYWxfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvcHJvcG9zYWxfdmFsaWRhdG9yL2Jsb2NrX3Byb3Bvc2FsX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxZQUFZLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUVyRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUVoRixxQkFBYSxzQkFBdUIsU0FBUSxpQkFBaUIsQ0FBQyxhQUFhLENBQUUsWUFBVyxZQUFZLENBQUMsYUFBYSxDQUFDO0lBQ2pILFlBQVksVUFBVSxFQUFFLG1CQUFtQixFQUFFLElBQUksRUFBRTtRQUFFLFlBQVksRUFBRSxPQUFPLENBQUE7S0FBRSxFQUUzRTtDQUNGIn0=

package/dest/msg_validators/proposal_validator/block_proposal_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/block_proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAEhF,qBAAa,sBAAuB,SAAQ,iBAAiB,CAAC,aAAa,CAAE,YAAW,YAAY,CAAC,aAAa,CAAC;IACjH,YAAY,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,EAE3E;CACF"}

package/dest/msg_validators/proposal_validator/block_proposal_validator.js

@@ -0,0 +1,6 @@
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+export class BlockProposalValidator extends ProposalValidator {
+    constructor(epochCache, opts){
+        super(epochCache, opts, 'p2p:block_proposal_validator');
+    }
+}

package/dest/msg_validators/proposal_validator/checkpoint_proposal_validator.d.ts

@@ -0,0 +1,9 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import type { CheckpointProposal, P2PValidator } from '@aztec/stdlib/p2p';
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+export declare class CheckpointProposalValidator extends ProposalValidator<CheckpointProposal> implements P2PValidator<CheckpointProposal> {
+    constructor(epochCache: EpochCacheInterface, opts: {
+        txsPermitted: boolean;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9wcm9wb3NhbF92YWxpZGF0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvY2hlY2twb2ludF9wcm9wb3NhbF92YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxZQUFZLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUUxRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUVoRixxQkFBYSwyQkFDWCxTQUFRLGlCQUFpQixDQUFDLGtCQUFrQixDQUM1QyxZQUFXLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQztJQUUzQyxZQUFZLFVBQVUsRUFBRSxtQkFBbUIsRUFBRSxJQUFJLEVBQUU7UUFBRSxZQUFZLEVBQUUsT0FBTyxDQUFBO0tBQUUsRUFFM0U7Q0FDRiJ9

package/dest/msg_validators/proposal_validator/checkpoint_proposal_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/checkpoint_proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAEhF,qBAAa,2BACX,SAAQ,iBAAiB,CAAC,kBAAkB,CAC5C,YAAW,YAAY,CAAC,kBAAkB,CAAC;IAE3C,YAAY,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,EAE3E;CACF"}

package/dest/msg_validators/proposal_validator/checkpoint_proposal_validator.js

@@ -0,0 +1,6 @@
+import { ProposalValidator } from '../proposal_validator/proposal_validator.js';
+export class CheckpointProposalValidator extends ProposalValidator {
+    constructor(epochCache, opts){
+        super(epochCache, opts, 'p2p:checkpoint_proposal_validator');
+    }
+}

package/dest/msg_validators/proposal_validator/index.d.ts

@@ -0,0 +1,4 @@
+export * from './block_proposal_validator.js';
+export * from './checkpoint_proposal_validator.js';
+export * from './proposal_validator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMseUJBQXlCLENBQUMifQ==

package/dest/msg_validators/proposal_validator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

package/dest/msg_validators/proposal_validator/index.js

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

package/dest/msg_validators/proposal_validator/proposal_validator.d.ts

@@ -0,0 +1,13 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type Logger } from '@aztec/foundation/log';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export declare abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
+    protected epochCache: EpochCacheInterface;
+    protected logger: Logger;
+    protected txsPermitted: boolean;
+    constructor(epochCache: EpochCacheInterface, opts: {
+        txsPermitted: boolean;
+    }, loggerName: string);
+    validate(proposal: TProposal): Promise<PeerErrorSeverity | undefined>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvcHJvcG9zYWxfdmFsaWRhdG9yL3Byb3Bvc2FsX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRTlELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQUUsYUFBYSxFQUFFLGtCQUFrQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFekYsOEJBQXNCLGlCQUFpQixDQUFDLFNBQVMsU0FBUyxhQUFhLEdBQUcsa0JBQWtCO0lBQzFGLFNBQVMsQ0FBQyxVQUFVLEVBQUUsbUJBQW1CLENBQUM7SUFDMUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDekIsU0FBUyxDQUFDLFlBQVksRUFBRSxPQUFPLENBQUM7SUFFaEMsWUFBWSxVQUFVLEVBQUUsbUJBQW1CLEVBQUUsSUFBSSxFQUFFO1FBQUUsWUFBWSxFQUFFLE9BQU8sQ0FBQTtLQUFFLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFJL0Y7SUFFWSxRQUFRLENBQUMsUUFBUSxFQUFFLFNBQVMsR0FBRyxPQUFPLENBQUMsaUJBQWlCLEdBQUcsU0FBUyxDQUFDLENBMEVqRjtDQUNGIn0=

package/dest/msg_validators/proposal_validator/proposal_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEzF,8BAAsB,iBAAiB,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB;IAC1F,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,YAAY,EAAE,OAAO,CAAC;IAEhC,YAAY,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,EAAE,UAAU,EAAE,MAAM,EAI/F;IAEY,QAAQ,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CA0EjF;CACF"}

package/dest/msg_validators/proposal_validator/proposal_validator.js

@@ -0,0 +1,80 @@
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { createLogger } from '@aztec/foundation/log';
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export class ProposalValidator {
+    epochCache;
+    logger;
+    txsPermitted;
+    constructor(epochCache, opts, loggerName){
+        this.epochCache = epochCache;
+        this.txsPermitted = opts.txsPermitted;
+        this.logger = createLogger(loggerName);
+    }
+    async validate(proposal) {
+        try {
+            // Signature validity
+            const proposer = proposal.getSender();
+            if (!proposer) {
+                this.logger.debug(`Penalizing peer for proposal with invalid signature`);
+                return PeerErrorSeverity.MidToleranceError;
+            }
+            // Transactions permitted check
+            const embeddedTxCount = proposal.txs?.length ?? 0;
+            if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
+                this.logger.debug(`Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`);
+                return 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 PeerErrorSeverity.MidToleranceError;
+            }
+            // Slot and proposer checks
+            const { currentProposer, nextProposer, currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+            const slotNumber = proposal.slotNumber;
+            if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+                this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, {
+                    currentSlot,
+                    nextSlot
+                });
+                return PeerErrorSeverity.HighToleranceError;
+            }
+            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(proposal.txs?.map((tx)=>tx.validateTxHash()) ?? [])).every((v)=>v)) {
+                this.logger.warn(`Penalizing peer for invalid tx hashes in proposal`, {
+                    proposer,
+                    slotNumber
+                });
+                return PeerErrorSeverity.LowToleranceError;
+            }
+            return undefined;
+        } catch (e) {
+            if (e instanceof NoCommitteeError) {
+                return PeerErrorSeverity.LowToleranceError;
+            }
+            throw e;
+        }
+    }
+}

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts

@@ -0,0 +1,23 @@
+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 } 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<PeerErrorSeverity | undefined>;
+    };
+    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 declare function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(params: ProposalValidatorTestParams<TProposal>): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvcHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxhQUFhLEVBQUUsS0FBSyxrQkFBa0IsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25HLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXBELE1BQU0sV0FBVywyQkFBMkIsQ0FBQyxTQUFTLFNBQVMsYUFBYSxHQUFHLGtCQUFrQjtJQUMvRixnQkFBZ0IsRUFBRSxDQUNoQixVQUFVLEVBQUUsbUJBQW1CLEVBQy9CLElBQUksRUFBRTtRQUFFLFlBQVksRUFBRSxPQUFPLENBQUE7S0FBRSxLQUM1QjtRQUFFLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRSxTQUFTLEtBQUssT0FBTyxDQUFDLGlCQUFpQixHQUFHLFNBQVMsQ0FBQyxDQUFBO0tBQUUsQ0FBQztJQUNuRixZQUFZLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxHQUFHLEtBQUssT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3BELFVBQVUsRUFBRSxDQUFDLFdBQVcsRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLEdBQUcsTUFBTSxLQUFLLEdBQUcsQ0FBQztJQUM3RyxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7SUFDakMsVUFBVSxFQUFFLENBQUMsTUFBTSxDQUFDLEVBQUUsZUFBZSxLQUFLLFVBQVUsQ0FBQztJQUNyRCxPQUFPLEVBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxHQUFHLE1BQU0sS0FBSyxHQUFHLENBQUM7SUFDeEMsV0FBVyxFQUFFLENBQUMsQ0FBQyxFQUFFLE1BQU0sS0FBSyxNQUFNLEVBQUUsQ0FBQztJQUNyQyxNQUFNLEVBQUUsTUFBTSxHQUFHLEVBQUUsQ0FBQztJQUNwQixjQUFjLEVBQUUsTUFBTSxTQUFTLENBQUMsbUJBQW1CLENBQUMsQ0FBQztDQUN0RDtBQUVELHdCQUFnQiw0QkFBNEIsQ0FBQyxTQUFTLFNBQVMsYUFBYSxHQUFHLGtCQUFrQixFQUMvRixNQUFNLEVBQUUsMkJBQTJCLENBQUMsU0FBUyxDQUFDLFFBcUwvQyJ9

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proposal_validator_test_suite.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/proposal_validator_test_suite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACnG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,2BAA2B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB;IAC/F,gBAAgB,EAAE,CAChB,UAAU,EAAE,mBAAmB,EAC/B,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,KAC5B;QAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAA;KAAE,CAAC;IACnF,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACpD,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IAC7G,SAAS,EAAE,MAAM,eAAe,CAAC;IACjC,UAAU,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,UAAU,CAAC;IACrD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IACxC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACrC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,SAAS,CAAC,mBAAmB,CAAC,CAAC;CACtD;AAED,wBAAgB,4BAA4B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB,EAC/F,MAAM,EAAE,2BAA2B,CAAC,SAAS,CAAC,QAqL/C"}

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.js

@@ -0,0 +1,183 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+export function sharedProposalValidatorTests(params) {
+    const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } = params;
+    describe('shared proposal validation logic', ()=>{
+        let epochCache;
+        let validator;
+        beforeEach(()=>{
+            epochCache = epochCacheMock();
+            validator = validatorFactory(epochCache, {
+                txsPermitted: true
+            });
+        });
+        it('returns high tolerance error if slot number is not current or next slot', async ()=>{
+            const header = makeHeader(1, 97, 97);
+            const mockProposal = await makeProposal({
+                blockHeader: header,
+                lastBlockHeader: header
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(98),
+                nextSlot: getSlot(99),
+                currentProposer: getAddress(),
+                nextProposer: getAddress()
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBe(PeerErrorSeverity.HighToleranceError);
+        });
+        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
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(100),
+                nextSlot: getSlot(101),
+                currentProposer: getAddress(currentProposer),
+                nextProposer: getAddress(nextProposer)
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBe(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
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(100),
+                nextSlot: getSlot(101),
+                currentProposer: getAddress(currentProposer),
+                nextProposer: getAddress(nextProposer)
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBe(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
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(100),
+                nextSlot: getSlot(101),
+                currentProposer: getAddress(currentProposer),
+                nextProposer: getAddress(nextProposer)
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBe(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
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(100),
+                nextSlot: getSlot(101),
+                currentProposer: getAddress(currentProposer),
+                nextProposer: getAddress(nextProposer)
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBeUndefined();
+        });
+        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
+            });
+            epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                currentSlot: getSlot(100),
+                nextSlot: getSlot(101),
+                currentProposer: getAddress(currentProposer),
+                nextProposer: getAddress(nextProposer)
+            });
+            const result = await validator.validate(mockProposal);
+            expect(result).toBeUndefined();
+        });
+        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)
+                });
+                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                    currentSlot: getSlot(100),
+                    nextSlot: getSlot(101),
+                    currentProposer: getAddress(currentProposer),
+                    nextProposer: getAddress()
+                });
+                const result = await validatorWithTxsDisabled.validate(mockProposal);
+                expect(result).toBe(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)
+                });
+                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                    currentSlot: getSlot(100),
+                    nextSlot: getSlot(101),
+                    currentProposer: getAddress(currentProposer),
+                    nextProposer: getAddress()
+                });
+                const result = await validatorWithTxsDisabled.validate(mockProposal);
+                expect(result).toBeUndefined();
+            });
+            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)
+                });
+                epochCache.getProposerAttesterAddressInCurrentOrNextSlot.mockResolvedValue({
+                    currentSlot: getSlot(100),
+                    nextSlot: getSlot(101),
+                    currentProposer: getAddress(currentProposer),
+                    nextProposer: getAddress()
+                });
+                const result = await validator.validate(mockProposal);
+                expect(result).toBeUndefined();
+            });
+        });
+    });
+}