@aztec/p2p 0.0.1-commit.03f7ef2 → 0.0.1-commit.1142ef1

package/src/msg_validators/attestation_validator/attestation_validator.ts

@@ -1,33 +1,34 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-export class AttestationValidator implements P2PValidator<BlockAttestation> {
+export class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
   protected epochCache: EpochCacheInterface;
   protected logger: Logger;
 
   constructor(epochCache: EpochCacheInterface) {
     this.epochCache = epochCache;
-    this.logger = createLogger('p2p:attestation-validator');
+    this.logger = createLogger('p2p:checkpoint-attestation-validator');
   }
 
-  async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+  async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
     const slotNumber = message.payload.header.slotNumber;
 
     try {
-      const { currentProposer, nextProposer, currentSlot, nextSlot } =
-        await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
+      const { currentSlot, nextSlot } = await this.epochCache.getProposerAttesterAddressInCurrentOrNextSlot();
 
       if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-        this.logger.warn(`Attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
+        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 attestation for slot ${slotNumber}`);
+        this.logger.warn(`Invalid signature in checkpoint attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
 
@@ -37,20 +38,22 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
         return PeerErrorSeverity.HighToleranceError;
       }
 
-      // Verify the proposer signature matches the expected proposer for this slot
+      // 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 = slotNumber === currentSlot ? currentProposer : nextProposer;
+      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 attestation for slot ${slotNumber}`);
+        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 attestation. ` +
+          `Proposer signature mismatch in checkpoint attestation. ` +
             `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`,
         );
         return PeerErrorSeverity.HighToleranceError;
@@ -60,7 +63,7 @@ export class AttestationValidator implements P2PValidator<BlockAttestation> {
     } 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}`);
+        this.logger.warn(`No committee exists for checkpoint attestation for slot ${slotNumber}`);
         return PeerErrorSeverity.LowToleranceError;
       }
       throw e;

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -1,9 +1,9 @@
 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 CheckpointAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 
 import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
-import { AttestationValidator } from './attestation_validator.js';
+import { CheckpointAttestationValidator } from './attestation_validator.js';
 
 /**
  * FishermanAttestationValidator extends the base AttestationValidator to add
@@ -13,7 +13,7 @@ import { AttestationValidator } from './attestation_validator.js';
  * handled by LibP2PService based on the fishermanMode config to ensure a better
  * view of the network.
  */
-export class FishermanAttestationValidator extends AttestationValidator {
+export class FishermanAttestationValidator extends CheckpointAttestationValidator {
   private invalidAttestationCounter;
 
   constructor(
@@ -25,13 +25,10 @@ export class FishermanAttestationValidator extends AttestationValidator {
     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,
-    });
+    this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT);
   }
 
-  override async validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined> {
+  override async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
     // First run the standard validation
     const baseValidationResult = await super.validate(message);
     if (baseValidationResult !== undefined) {
@@ -52,11 +49,11 @@ export class FishermanAttestationValidator extends AttestationValidator {
     }
 
     const proposalId = message.archive.toString();
-    const proposal = await this.attestationPool.getBlockProposal(proposalId);
+    const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
 
     if (proposal) {
       // Compare the attestation payload with the proposal payload
-      if (!message.payload.equals(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.`,
@@ -66,7 +63,7 @@ export class FishermanAttestationValidator extends AttestationValidator {
             proposer: proposer.toString(),
             proposalArchive: proposal.archive.toString(),
             attestationArchive: message.archive.toString(),
-            proposalHeader: proposal.payload.header.hash().toString(),
+            proposalHeader: proposal.checkpointHeader.hash().toString(),
             attestationHeader: message.payload.header.hash().toString(),
           },
         );

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/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/{block_proposal_validator/block_proposal_validator.ts → proposal_validator/proposal_validator.ts}

@@ -1,63 +1,60 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
 
-export class BlockProposalValidator implements P2PValidator<BlockProposal> {
-  private epochCache: EpochCacheInterface;
-  private logger: Logger;
-  private txsPermitted: boolean;
+export abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
+  protected epochCache: EpochCacheInterface;
+  protected logger: Logger;
+  protected txsPermitted: boolean;
 
-  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }) {
+  constructor(epochCache: EpochCacheInterface, opts: { txsPermitted: boolean }, loggerName: string) {
     this.epochCache = epochCache;
     this.txsPermitted = opts.txsPermitted;
-    this.logger = createLogger('p2p:block_proposal_validator');
+    this.logger = createLogger(loggerName);
   }
 
-  async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
+  public async validate(proposal: TProposal): Promise<PeerErrorSeverity | undefined> {
     try {
-      // Check signature validity first - invalid signatures are a high-severity issue
-      const proposer = block.getSender();
+      // Signature validity
+      const proposer = proposal.getSender();
       if (!proposer) {
-        this.logger.debug(`Penalizing peer for block proposal with invalid signature`);
+        this.logger.debug(`Penalizing peer for proposal with invalid signature`);
         return PeerErrorSeverity.MidToleranceError;
       }
 
-      // 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)) {
+      // Transactions permitted check
+      const embeddedTxCount = proposal.txs?.length ?? 0;
+      if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
         this.logger.debug(
-          `Penalizing peer for block proposal with ${block.txHashes.length} transaction(s) when transactions are not permitted`,
+          `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
         );
         return PeerErrorSeverity.MidToleranceError;
       }
 
-      // 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()));
+      // Embedded txs must be listed in txHashes
+      const hashSet = new Set(proposal.txHashes.map(h => h.toString()));
       const missingTxHashes =
         embeddedTxCount > 0
-          ? block.txs!.filter(tx => !hashSet.has(tx.getTxHash().toString())).map(tx => tx.getTxHash().toString())
+          ? 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: block.txHashes.length,
+          txHashesLength: proposal.txHashes.length,
           missingTxHashes,
         });
         return PeerErrorSeverity.MidToleranceError;
       }
 
+      // Slot and proposer checks
       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;
+      const slotNumber = proposal.slotNumber;
       if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
         this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
         return PeerErrorSeverity.HighToleranceError;
       }
-
-      // 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,
@@ -66,7 +63,6 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
         });
         return PeerErrorSeverity.MidToleranceError;
       }
-
       if (slotNumber === nextSlot && nextProposer !== undefined && !proposer.equals(nextProposer)) {
         this.logger.debug(`Penalizing peer for invalid proposer for next slot ${slotNumber}`, {
           currentProposer,
@@ -77,8 +73,8 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
       }
 
       // 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`, {
+      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,
         });
@@ -87,7 +83,6 @@ export class BlockProposalValidator implements P2PValidator<BlockProposal> {
 
       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;
       }

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -0,0 +1,206 @@
+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 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<PeerErrorSeverity | undefined> };
+
+    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();
+      });
+    });
+  });
+}

package/src/msg_validators/tx_validator/data_validator.ts

@@ -31,7 +31,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     if (!tx.getTxHash().equals(expected)) {
       const reason = TX_ERROR_INCORRECT_HASH;
       this.#log.verbose(
-        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx.getTxHash().toString()}.`,
+        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected hash ${expected.toString()}. Got ${tx
+          .getTxHash()
+          .toString()}.`,
       );
       return reason;
     }
@@ -52,7 +54,9 @@ export class DataTxValidator implements TxValidator<Tx> {
     if (tx.getTotalPublicCalldataCount() > MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS) {
       const reason = TX_ERROR_CALLDATA_COUNT_TOO_LARGE;
       this.#log.verbose(
-        `Rejecting tx ${tx.getTxHash().toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
+        `Rejecting tx ${tx
+          .getTxHash()
+          .toString()}. Reason: ${reason}. Expected no greater than ${MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS} fields. Got ${tx.getTotalPublicCalldataCount()}.`,
       );
       return reason;
     }
@@ -89,7 +93,9 @@ export class DataTxValidator implements TxValidator<Tx> {
         if (expectedHashes.some(h => logHash.value.equals(h))) {
           const matchingLogIndex = expectedHashes.findIndex(l => logHash.value.equals(l));
           this.#log.verbose(
-            `Rejecting tx ${tx.getTxHash().toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
+            `Rejecting tx ${tx
+              .getTxHash()
+              .toString()} because of mismatched contract class logs indices. Expected ${i} from the kernel's log hashes. Got ${matchingLogIndex} in the tx.`,
           );
           return TX_ERROR_CONTRACT_CLASS_LOG_SORTING;
         } else {
@@ -105,7 +111,9 @@ export class DataTxValidator implements TxValidator<Tx> {
       const expectedMinLength = 1 + tx.contractClassLogFields[i].fields.findLastIndex(f => !f.isZero());
       if (logHash.logHash.length < expectedMinLength) {
         this.#log.verbose(
-          `Rejecting tx ${tx.getTxHash().toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
+          `Rejecting tx ${tx
+            .getTxHash()
+            .toString()} because of incorrect contract class log length. Expected the length to be at least ${expectedMinLength}. Got ${
             logHash.logHash.length
           }.`,
         );

package/src/msg_validators/tx_validator/metadata_validator.ts

@@ -43,7 +43,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
     // This gets implicitly tested in the proof validator, but we can get a much cheaper check here by looking early at the vk.
     if (!tx.data.constants.vkTreeRoot.equals(this.values.vkTreeRoot)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect vk tree root ${tx.data.constants.vkTreeRoot.toString()} != ${this.values.vkTreeRoot.toString()}`,
       );
       return false;
     } else {
@@ -54,7 +56,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectprotocolContractsHash(tx: T): boolean {
     if (!tx.data.constants.protocolContractsHash.equals(this.values.protocolContractsHash)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect protocol contracts hash ${tx.data.constants.protocolContractsHash.toString()} != ${this.values.protocolContractsHash.toString()}`,
       );
       return false;
     }
@@ -64,7 +68,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectL1ChainId(tx: T): boolean {
     if (!tx.data.constants.txContext.chainId.equals(this.values.l1ChainId)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect L1 chain ${tx.data.constants.txContext.chainId.toNumber()} != ${this.values.l1ChainId.toNumber()}`,
       );
       return false;
     } else {
@@ -75,7 +81,9 @@ export class MetadataTxValidator<T extends AnyTx> implements TxValidator<T> {
   #hasCorrectRollupVersion(tx: T): boolean {
     if (!tx.data.constants.txContext.version.equals(this.values.rollupVersion)) {
       this.#log.verbose(
-        `Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
+        `Rejecting tx ${
+          'txHash' in tx ? tx.txHash : tx.hash
+        } because of incorrect rollup version ${tx.data.constants.txContext.version.toNumber()} != ${this.values.rollupVersion.toNumber()}`,
       );
       return false;
     } else {

package/src/msg_validators/tx_validator/timestamp_validator.ts

@@ -35,7 +35,9 @@ export class TimestampTxValidator<T extends AnyTx> implements TxValidator<T> {
         );
       }
       this.#log.verbose(
-        `Rejecting tx ${getTxHash(tx)} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
+        `Rejecting tx ${getTxHash(
+          tx,
+        )} for low expiration timestamp. Tx expiration timestamp: ${includeByTimestamp}, timestamp: ${
           this.values.timestamp
         }.`,
       );

package/src/services/dummy_service.ts

@@ -23,6 +23,7 @@ import type { GoodByeReason } from './reqresp/protocols/goodbye.js';
 import { ReqRespStatus } from './reqresp/status.js';
 import {
   type P2PBlockReceivedCallback,
+  type P2PCheckpointReceivedCallback,
   type P2PService,
   type PeerDiscoveryService,
   PeerDiscoveryState,
@@ -74,6 +75,11 @@ export class DummyP2PService implements P2PService {
    */
   public registerBlockReceivedCallback(_callback: P2PBlockReceivedCallback) {}
 
+  /**
+   * Register a callback into the validator client for when a checkpoint proposal is received
+   */
+  public registerCheckpointReceivedCallback(_callback: P2PCheckpointReceivedCallback) {}
+
   /**
    * Sends a request to a peer.
    * @param _protocol - The protocol to send the request on.

package/src/services/encoding.ts

@@ -55,10 +55,12 @@ const DefaultMaxSizesKb: Record<TopicType, number> = {
   // Tx effects should not exceed 128kb, so 512kb for the full tx obj should be sufficient
   [TopicType.tx]: 512,
   // An attestation has roughly 30 fields, which is 1kb, so 5x is plenty
-  [TopicType.block_attestation]: 5,
+  [TopicType.checkpoint_attestation]: 5,
   // Proposals may carry some tx objects, so we allow a larger size capped at 10mb
   // Note this may not be enough for carrying all tx objects in a block
   [TopicType.block_proposal]: 1024 * 10,
+  // TODO(palla/mbps): Check size for checkpoint proposal
+  [TopicType.checkpoint_proposal]: 1024 * 10,
 };
 
 /**