@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.0b941701

package/src/p2p/checkpoint_proposal.ts

@@ -0,0 +1,348 @@
+import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
+
+import type { L2BlockInfo } from '../block/l2_block_info.js';
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { TxHash } from '../tx/index.js';
+import type { Tx } from '../tx/tx.js';
+import { BlockProposal } from './block_proposal.js';
+import { Gossipable } from './gossipable.js';
+import {
+  SignatureDomainSeparator,
+  getHashedSignaturePayload,
+  getHashedSignaturePayloadEthSignedMessage,
+} from './signature_utils.js';
+import { SignedTxs } from './signed_txs.js';
+import { TopicType } from './topic_type.js';
+
+// REFACTOR(palla): Use a branded type instead of a subclass of Buffer32
+export class CheckpointProposalHash extends Buffer32 {
+  constructor(hash: Buffer) {
+    super(hash);
+  }
+}
+
+export type CheckpointProposalOptions = {
+  publishFullTxs: boolean;
+  /** Whether to generate an invalid checkpoint proposal for broadcasting. Use only for testing. */
+  broadcastInvalidCheckpointProposal?: boolean;
+};
+
+/** Data for the last block included in a checkpoint proposal */
+export type CheckpointLastBlockData = {
+  /** The per-block header for the last block in the checkpoint */
+  blockHeader: BlockHeader;
+  /** Index of this block within the checkpoint (should be the last index, e.g., numBlocks - 1) */
+  indexWithinCheckpoint: IndexWithinCheckpoint;
+  /** The sequence of transactions in the last block */
+  txHashes: TxHash[];
+  /** The tx in the last block (optional, for DA guarantees) */
+  txs?: Tx[];
+};
+
+/** Last block included in a checkpoint proposal */
+export type CheckpointLastBlock = Omit<CheckpointLastBlockData, 'txs'> & {
+  /** The proposer's signature over the block data (separate from checkpoint signature) */
+  signature: Signature;
+  /** The signed transactions in the last block (optional, for DA guarantees) */
+  signedTxs?: SignedTxs;
+};
+
+/**
+ * A checkpoint proposal is created by the leader of the chain for the last block in a checkpoint.
+ * It includes the aggregated checkpoint header that validators will attest to, plus optionally
+ * the last block's info for nodes to re-execute. This marks the completion of a slot's worth of blocks.
+ */
+export class CheckpointProposal extends Gossipable {
+  static override p2pTopic = TopicType.checkpoint_proposal;
+
+  private sender: EthAddress | undefined;
+
+  constructor(
+    /** The aggregated checkpoint header for consensus */
+    public readonly checkpointHeader: CheckpointHeader,
+
+    /** Archive root after this checkpoint is applied */
+    public readonly archive: Fr,
+
+    /** The proposer's signature over the checkpoint payload (checkpointHeader + archive) */
+    public readonly signature: Signature,
+
+    /** Optional last block info, including its own signature for BlockProposal extraction */
+    public readonly lastBlock?: CheckpointLastBlock,
+  ) {
+    super();
+  }
+
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+    return Promise.resolve(new CheckpointProposalHash(keccak256(this.signature.toBuffer())));
+  }
+
+  get slotNumber(): SlotNumber {
+    return this.checkpointHeader.slotNumber;
+  }
+
+  get blockNumber(): BlockNumber {
+    if (!this.lastBlock) {
+      throw new Error('Cannot get blockNumber without lastBlock');
+    }
+    return this.lastBlock.blockHeader.getBlockNumber();
+  }
+
+  /** Convenience getter for txHashes from lastBlock */
+  get txHashes(): TxHash[] {
+    return this.lastBlock?.txHashes ?? [];
+  }
+
+  /** Convenience getter for txs from lastBlock */
+  get txs(): Tx[] | undefined {
+    return this.lastBlock?.signedTxs?.txs;
+  }
+
+  /**
+   * Extract a BlockProposal from the last block info.
+   * Uses inHash from checkpointHeader.contentCommitment.inHash
+   */
+  getBlockProposal(): BlockProposal | undefined {
+    if (!this.lastBlock) {
+      return undefined;
+    }
+
+    return new BlockProposal(
+      this.lastBlock.blockHeader,
+      this.lastBlock.indexWithinCheckpoint,
+      this.checkpointHeader.inHash,
+      this.archive,
+      this.lastBlock.txHashes,
+      this.lastBlock.signature,
+      this.lastBlock.signedTxs,
+    );
+  }
+
+  toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
+    if (!this.lastBlock) {
+      throw new Error('Cannot get blockInfo without lastBlock');
+    }
+    return {
+      slotNumber: this.slotNumber,
+      lastArchive: this.lastBlock.blockHeader.lastArchive.root,
+      timestamp: this.lastBlock.blockHeader.globalVariables.timestamp,
+      archive: this.archive,
+      txCount: this.lastBlock.txHashes.length,
+    };
+  }
+
+  /**
+   * Get the payload to sign for this checkpoint proposal.
+   * The signature is over the checkpoint header + archive root (for consensus).
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([domainSeparator, this.checkpointHeader, this.archive]);
+  }
+
+  static async createProposalFromSigner(
+    checkpointHeader: CheckpointHeader,
+    archiveRoot: Fr,
+    lastBlockInfo: CheckpointLastBlockData | undefined,
+    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
+  ): Promise<CheckpointProposal> {
+    // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
+    const tempProposal = new CheckpointProposal(checkpointHeader, archiveRoot, Signature.empty(), undefined);
+    const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
+
+    const checkpointContext: SigningContext = {
+      slot: checkpointHeader.slotNumber,
+      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      dutyType: DutyType.CHECKPOINT_PROPOSAL,
+    };
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
+
+    if (!lastBlockInfo) {
+      return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature);
+    }
+
+    const lastBlockProposal = await BlockProposal.createProposalFromSigner(
+      lastBlockInfo.blockHeader,
+      lastBlockInfo.indexWithinCheckpoint,
+      checkpointHeader.inHash,
+      archiveRoot,
+      lastBlockInfo.txHashes,
+      lastBlockInfo.txs,
+      payloadSigner,
+    );
+
+    return new CheckpointProposal(checkpointHeader, archiveRoot, checkpointSignature, {
+      blockHeader: lastBlockInfo.blockHeader,
+      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+      txHashes: lastBlockInfo.txHashes,
+      signature: lastBlockProposal.signature,
+      signedTxs: lastBlockProposal.signedTxs,
+    });
+  }
+
+  /**
+   * Lazily evaluate the sender of the proposal; result is cached.
+   * If there's a lastBlock, also verifies the block proposal sender matches the checkpoint sender.
+   * @returns The sender address, or undefined if signature recovery fails or senders don't match
+   */
+  getSender(): EthAddress | undefined {
+    if (!this.sender) {
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.checkpointProposal);
+      const checkpointSender = tryRecoverAddress(hashed, this.signature);
+
+      // If there's a lastBlock, verify the block proposal sender matches
+      if (checkpointSender && this.lastBlock) {
+        const blockProposal = this.getBlockProposal();
+        const blockSender = blockProposal?.getSender();
+        if (!blockSender || !blockSender.equals(checkpointSender)) {
+          return undefined; // Sender mismatch - fail
+        }
+      }
+
+      // Cache the sender for later use
+      this.sender = checkpointSender;
+    }
+
+    return this.sender;
+  }
+
+  getPayload() {
+    return this.getPayloadToSign(SignatureDomainSeparator.checkpointProposal);
+  }
+
+  toBuffer(): Buffer {
+    const buffer: any[] = [this.checkpointHeader, this.archive, this.signature];
+
+    if (this.lastBlock) {
+      buffer.push(1); // hasLastBlock = true
+      buffer.push(this.lastBlock.blockHeader);
+      buffer.push(this.lastBlock.indexWithinCheckpoint);
+      buffer.push(this.lastBlock.signature);
+      buffer.push(this.lastBlock.txHashes.length);
+      buffer.push(this.lastBlock.txHashes);
+      if (this.lastBlock.signedTxs) {
+        buffer.push(1); // hasSignedTxs = true
+        buffer.push(this.lastBlock.signedTxs.toBuffer());
+      } else {
+        buffer.push(0); // hasSignedTxs = false
+      }
+    } else {
+      buffer.push(0); // hasLastBlock = false
+    }
+
+    return serializeToBuffer(buffer);
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): CheckpointProposal {
+    const reader = BufferReader.asReader(buf);
+
+    const checkpointHeader = reader.readObject(CheckpointHeader);
+    const archive = reader.readObject(Fr);
+    const signature = reader.readObject(Signature);
+
+    const hasLastBlock = reader.readNumber();
+
+    if (hasLastBlock) {
+      const blockHeader = reader.readObject(BlockHeader);
+      const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
+      const blockSignature = reader.readObject(Signature);
+      const txHashCount = reader.readNumber();
+      if (txHashCount > MAX_TXS_PER_BLOCK) {
+        throw new Error(`txHashes count ${txHashCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+      }
+      const txHashes = reader.readArray(txHashCount, TxHash);
+
+      let signedTxs: SignedTxs | undefined;
+      if (!reader.isEmpty()) {
+        const hasSignedTxs = reader.readNumber();
+        if (hasSignedTxs) {
+          signedTxs = SignedTxs.fromBuffer(reader);
+        }
+      }
+
+      return new CheckpointProposal(checkpointHeader, archive, signature, {
+        blockHeader,
+        indexWithinCheckpoint,
+        txHashes,
+        signature: blockSignature,
+        signedTxs,
+      });
+    }
+
+    return new CheckpointProposal(checkpointHeader, archive, signature);
+  }
+
+  getSize(): number {
+    let size =
+      this.checkpointHeader.toBuffer().length +
+      this.archive.size +
+      this.signature.getSize() +
+      4; /* hasLastBlock flag */
+
+    if (this.lastBlock) {
+      size +=
+        this.lastBlock.blockHeader.getSize() +
+        4 /* indexWithinCheckpoint */ +
+        this.lastBlock.signature.getSize() +
+        4 /* txHashes.length */ +
+        this.lastBlock.txHashes.length * TxHash.SIZE +
+        4 /* hasSignedTxs flag */ +
+        (this.lastBlock.signedTxs ? this.lastBlock.signedTxs.getSize() : 0);
+    }
+
+    return size;
+  }
+
+  static empty(): CheckpointProposal {
+    return new CheckpointProposal(CheckpointHeader.empty(), Fr.ZERO, Signature.empty());
+  }
+
+  static random(): CheckpointProposal {
+    return new CheckpointProposal(CheckpointHeader.random(), Fr.random(), Signature.random(), {
+      blockHeader: BlockHeader.random(),
+      indexWithinCheckpoint: IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
+      txHashes: [TxHash.random(), TxHash.random()],
+      signature: Signature.random(),
+    });
+  }
+
+  toInspect() {
+    return {
+      checkpointHeader: this.checkpointHeader.toInspect(),
+      archive: this.archive.toString(),
+      signature: this.signature.toString(),
+      lastBlock: this.lastBlock
+        ? {
+            blockHeader: this.lastBlock.blockHeader.toInspect(),
+            indexWithinCheckpoint: this.lastBlock.indexWithinCheckpoint,
+            txHashes: this.lastBlock.txHashes.map(h => h.toString()),
+            signature: this.lastBlock.signature.toString(),
+          }
+        : undefined,
+    };
+  }
+
+  /**
+   * Returns a copy of this proposal without lastBlock info, as a CheckpointProposalCore.
+   * Used when the lastBlock has been extracted and stored separately.
+   */
+  toCore(): CheckpointProposalCore {
+    return new CheckpointProposal(this.checkpointHeader, this.archive, this.signature);
+  }
+}
+
+/**
+ * A checkpoint proposal without the lastBlock info.
+ * Used when the lastBlock has been extracted and handled separately as a BlockProposal.
+ * This type makes it clear that lastBlock and getBlockProposal() are not available.
+ */
+export type CheckpointProposalCore = Omit<CheckpointProposal, 'lastBlock' | 'getBlockProposal' | 'toCore'>;

package/src/p2p/consensus_payload.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
@@ -7,74 +7,84 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import type { CheckpointProposal, CheckpointProposalCore } from './checkpoint_proposal.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
+/** Checkpoint consensus payload as signed by validators and verified on L1. */
 export class ConsensusPayload implements Signable {
   private size: number | undefined;
 
   constructor(
-    /** The block header the attestation is made over */
-    public readonly header: BlockHeader,
-    // TODO(https://github.com/AztecProtocol/aztec-packages/pull/7727#discussion_r1713670830): temporary
+    /** The proposed block header the attestation is made over */
+    public readonly header: CheckpointHeader,
+    /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The sequence of transactions in the block */
-    public readonly txHashes: TxHash[],
   ) {}
 
   static get schema() {
     return z
       .object({
-        header: BlockHeader.schema,
+        header: CheckpointHeader.schema,
         archive: schemas.Fr,
-        txHashes: z.array(TxHash.schema),
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.txHashes] as const;
+    return [fields.header, fields.archive] as const;
   }
 
-  async getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer> {
-    const abi = parseAbiParameters('uint8, (bytes32, bytes32, (uint256), bytes, bytes32[])');
-    const txArray = this.txHashes.map(tx => tx.toString());
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters(
+      'uint8, ' + //domainSeperator
+        '(' +
+        'bytes32, ' + // archive
+        '(int256), ' + // oracleInput
+        'bytes32' + // headerHash
+        ')',
+    );
+    const archiveRoot = this.archive.toString();
+
+    const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [
-        this.archive.toString(),
-        (await this.header.hash()).toString(),
-        [0n] /* @todo See #9963 */,
-        this.header.toString(),
-        txArray,
-      ],
+      [archiveRoot, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.txHashes.length, this.txHashes]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive]);
+  }
+
+  public equals(other: ConsensusPayload | CheckpointProposal | CheckpointProposalCore): boolean {
+    const otherHeader = 'checkpointHeader' in other ? other.checkpointHeader : other.header;
+    return this.header.equals(otherHeader) && this.archive.equals(other.archive);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
-      reader.readObject(BlockHeader),
-      reader.readObject(Fr),
-      reader.readArray(reader.readNumber(), TxHash),
-    );
+    const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr));
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+    return new ConsensusPayload(fields.header, fields.archive);
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO);
+  }
+
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random());
   }
 
   /**
@@ -89,4 +99,15 @@ export class ConsensusPayload implements Signable {
     this.size = this.toBuffer().length;
     return this.size;
   }
+
+  toInspect() {
+    return {
+      header: this.header.toInspect(),
+      archive: this.archive.toString(),
+    };
+  }
+
+  toString() {
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}}`;
+  }
 }

package/src/p2p/constants.ts

@@ -0,0 +1,3 @@
+export const MAX_TX_SIZE_KB: number = 512;
+
+export const MAX_MESSAGE_SIZE_KB: number = 10 * 1024;

package/src/p2p/gossipable.ts

@@ -1,4 +1,44 @@
-import type { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import type { TopicType } from './topic_type.js';
+
+export class P2PMessage {
+  constructor(
+    public readonly payload: Buffer,
+    public readonly timestamp?: Date,
+    public readonly traceContext?: string,
+  ) {}
+
+  static fromGossipable(message: Gossipable, instrumentMessages = false, traceContext?: string): P2PMessage {
+    if (!instrumentMessages) {
+      return new P2PMessage(message.toBuffer());
+    }
+    return new P2PMessage(message.toBuffer(), new Date(), traceContext);
+  }
+
+  static fromMessageData(messageData: Buffer, instrumentMessages = false): P2PMessage {
+    const reader = new BufferReader(messageData);
+    let timestamp: Date | undefined;
+    let traceContext: string | undefined;
+    if (instrumentMessages) {
+      timestamp = new Date(Number(reader.readUInt64()));
+      traceContext = reader.readString();
+    }
+    const payload = reader.readBuffer();
+    return new P2PMessage(payload, timestamp, traceContext);
+  }
+
+  toMessageData(): Buffer {
+    const arr: Buffer[] = [];
+    if (this.timestamp) {
+      arr.push(bigintToUInt64BE(BigInt(this.timestamp.getTime())));
+      arr.push(serializeToBuffer(this.traceContext ?? ''));
+    }
+    arr.push(serializeToBuffer(this.payload.length, this.payload));
+    return serializeToBuffer(arr);
+  }
+}
 
 /**
  * Gossipable
@@ -6,27 +46,32 @@ import type { Buffer32 } from '@aztec/foundation/buffer';
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
-  /** p2p Topic
-   *
-   * - The p2p topic identifier, this determines how the message is handled
-   */
-  static p2pTopic: string;
+  private cachedId: Buffer32 | undefined;
+  /** The p2p topic identifier, this determines how the message is handled */
+  static p2pTopic: TopicType;
 
-  /** p2p Message Identifier
-   *
-   *  - A digest of the message information, this key is used for deduplication
+  /**
+   * A digest of the message information **used for logging only**.
+   * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
    */
-  abstract p2pMessageIdentifier(): Promise<Buffer32>;
+  async p2pMessageLoggingIdentifier(): Promise<Buffer32> {
+    if (this.cachedId) {
+      return this.cachedId;
+    }
+    this.cachedId = await this.generateP2PMessageIdentifier();
+    return this.cachedId;
+  }
+
+  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
-  /** To Buffer
-   *
-   * - Serialization method
-   */
   abstract toBuffer(): Buffer;
 
+  toMessage(): Buffer {
+    return this.toBuffer();
+  }
+
   /**
    * Get the size of the gossipable object.
-   *
    * This is used for metrics recording.
    */
   abstract getSize(): number;

package/src/p2p/index.ts

@@ -1,10 +1,14 @@
-export * from './block_attestation.js';
+export * from './attestation_utils.js';
 export * from './block_proposal.js';
+export * from './checkpoint_attestation.js';
+export * from './checkpoint_proposal.js';
 export * from './consensus_payload.js';
 export * from './gossipable.js';
 export * from './interface.js';
 export * from './signature_utils.js';
+export * from './signed_txs.js';
 export * from './topic_type.js';
 export * from './client_type.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
+export * from './constants.js';

package/src/p2p/interface.ts

@@ -1,28 +1,4 @@
-import { Tx } from '../tx/tx.js';
-import { BlockAttestation } from './block_attestation.js';
-import { BlockProposal } from './block_proposal.js';
-import type { Gossipable } from './gossipable.js';
-import { TopicType } from './topic_type.js';
-
 export interface RawGossipMessage {
   topic: string;
   data: Uint8Array;
 }
-
-// Force casts as we know that each field here extends Gossipable, and we just want types from Gossipable
-export const TopicTypeMap: Record<string, typeof Gossipable> = {
-  [TopicType.tx]: Tx as unknown as typeof Gossipable,
-  [TopicType.block_proposal]: BlockProposal as unknown as typeof Gossipable,
-  [TopicType.block_attestation]: BlockAttestation as unknown as typeof Gossipable,
-};
-
-/**
- * Map from topic to deserialiser
- *
- * Used in msgIdFn libp2p to get the p2pMessageIdentifier from a message
- */
-export const TopicToDeserializer = {
-  [Tx.p2pTopic]: Tx.fromBuffer,
-  [BlockProposal.p2pTopic]: BlockProposal.fromBuffer,
-  [BlockAttestation.p2pTopic]: BlockAttestation.fromBuffer,
-};

package/src/p2p/message_validator.ts

@@ -1,10 +1,22 @@
 import type { PeerErrorSeverity } from './peer_error.js';
 
+/**
+ * Result of validating a P2P message.
+ * - 'accept': Message is valid and should be accepted and processed
+ * - 'ignore': Message should be ignored (not propagated or processed, but sender not penalized)
+ * - 'reject': Message is invalid (rejected and sender penalized)
+ */
+export type ValidationResult =
+  | { result: 'accept' }
+  | { result: 'ignore' }
+  | { result: 'reject'; severity: PeerErrorSeverity };
+
 /**
  * P2PValidator
  *
- * A validator for P2P messages, which returns a severity of error to be applied to the peer
+ * A validator for P2P messages, which returns a ValidationResult indicating
+ * whether to accept, ignore, or reject the message
  */
 export interface P2PValidator<T> {
-  validate(message: T): Promise<PeerErrorSeverity | undefined>;
+  validate(message: T): Promise<ValidationResult>;
 }