@aztec/stdlib 0.0.1-commit.0c875d939 → 0.0.1-commit.0ec55a70b

package/src/p2p/checkpoint_attestation.ts

@@ -1,7 +1,6 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { CheckpointAttestationHash, SlotNumber } from '@aztec/foundation/branded-types';
+import type { BaseBuffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
-import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
@@ -13,14 +12,10 @@ import type { ZodFor } from '../schemas/index.js';
 import { CheckpointProposal } from './checkpoint_proposal.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
-import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
+import { type CoordinationSignatureContext, recoverCoordinationSigner } from './signature_utils.js';
 import { TopicType } from './topic_type.js';
 
-export class CheckpointAttestationHash extends Buffer32 {
-  constructor(hash: Buffer) {
-    super(hash);
-  }
-}
+export type { CheckpointAttestationHash } from '@aztec/foundation/branded-types';
 
 /**
  * CheckpointAttestation
@@ -31,8 +26,8 @@ export class CheckpointAttestationHash extends Buffer32 {
 export class CheckpointAttestation extends Gossipable {
   static override p2pTopic = TopicType.checkpoint_attestation;
 
-  private sender: EthAddress | undefined;
-  private proposer: EthAddress | undefined;
+  private cachedSender: EthAddress | undefined | null = undefined;
+  private cachedProposer: EthAddress | undefined | null = undefined;
 
   constructor(
     /** The payload of the message, and what the signature is over */
@@ -57,8 +52,8 @@ export class CheckpointAttestation extends Gossipable {
       .transform(obj => new CheckpointAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new CheckpointAttestationHash(keccak256(this.signature.toBuffer())));
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(CheckpointAttestationHash.fromBuffer(keccak256(this.signature.toBuffer())));
   }
 
   get archive(): Fr {
@@ -69,22 +64,19 @@ export class CheckpointAttestation extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
+  get signatureContext(): CoordinationSignatureContext {
+    return this.payload.signatureContext;
+  }
+
   /**
    * Lazily evaluate and cache the signer of the attestation
    * @returns The signer of the attestation, or undefined if signature recovery fails
    */
   getSender(): EthAddress | undefined {
-    if (!this.sender) {
-      // Recover the sender from the attestation
-      const hashed = getHashedSignaturePayloadEthSignedMessage(
-        this.payload,
-        SignatureDomainSeparator.checkpointAttestation,
-      );
-      // Cache the sender for later use
-      this.sender = tryRecoverAddress(hashed, this.signature);
+    if (this.cachedSender === undefined) {
+      this.cachedSender = recoverCoordinationSigner(this.payload, this.signature) ?? null;
     }
-
-    return this.sender;
+    return this.cachedSender ?? undefined;
   }
 
   /**
@@ -92,7 +84,7 @@ export class CheckpointAttestation extends Gossipable {
    * @returns The proposer of the checkpoint
    */
   getProposer(): EthAddress | undefined {
-    if (!this.proposer) {
+    if (this.cachedProposer === undefined) {
       // Create a temporary CheckpointProposal to recover the proposer address.
       // We need to use CheckpointProposal because it has a different getPayloadToSign()
       // implementation than ConsensusPayload (uses serializeToBuffer vs ABI encoding).
@@ -101,16 +93,15 @@ export class CheckpointAttestation extends Gossipable {
         this.payload.archive,
         this.payload.feeAssetPriceModifier,
         this.proposerSignature,
+        this.payload.signatureContext,
       );
-      // Cache the proposer for later use
-      this.proposer = proposal.getSender();
+      this.cachedProposer = proposal.getSender() ?? null;
     }
-
-    return this.proposer;
+    return this.cachedProposer ?? undefined;
   }
 
   getPayload(): Buffer {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
+    return this.payload.getPayloadToSign();
   }
 
   toBuffer(): Buffer {

package/src/p2p/checkpoint_proposal.ts

@@ -1,15 +1,21 @@
-import { BlockNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
-import { Buffer32 } from '@aztec/foundation/buffer';
+import {
+  type CheckpointNumber,
+  CheckpointProposalHash,
+  IndexWithinCheckpoint,
+  SlotNumber,
+} from '@aztec/foundation/branded-types';
+import type { BaseBuffer32 } 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, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
-import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
+
+import type { TypedDataDefinition } from 'viem';
 
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { DutyType, type SigningContext } from '../ha-signing/index.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -17,19 +23,19 @@ import type { Tx } from '../tx/tx.js';
 import { BlockProposal } from './block_proposal.js';
 import { Gossipable } from './gossipable.js';
 import {
-  SignatureDomainSeparator,
-  getHashedSignaturePayload,
-  getHashedSignaturePayloadEthSignedMessage,
+  type CoordinationSignatureContext,
+  type CoordinationSignatureType,
+  EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+  type Signable,
+  getCoordinationSignatureTypedData,
+  readCoordinationSignatureContext,
+  recoverCoordinationSigner,
+  serializeCoordinationSignatureContext,
 } 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 { CheckpointProposalHash } from '@aztec/foundation/branded-types';
 
 export type CheckpointProposalOptions = {
   /**
@@ -69,10 +75,12 @@ export type CheckpointLastBlock = Omit<CheckpointLastBlockData, 'txs'> & {
  * 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 {
+export class CheckpointProposal extends Gossipable implements Signable {
   static override p2pTopic = TopicType.checkpoint_proposal;
 
-  private sender: EthAddress | undefined;
+  readonly primaryType: CoordinationSignatureType = 'CheckpointProposal';
+
+  private cachedSender: EthAddress | undefined | null = undefined;
 
   constructor(
     /** The aggregated checkpoint header for consensus */
@@ -87,37 +95,23 @@ export class CheckpointProposal extends Gossipable {
     /** The proposer's signature over the checkpoint payload (checkpointHeader + archive + feeAssetPriceModifier) */
     public readonly signature: Signature,
 
+    /** The signing domain (chainId + rollupAddress) the signature is bound to */
+    public readonly signatureContext: CoordinationSignatureContext,
+
     /** 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())));
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
+    return Promise.resolve(CheckpointProposalHash.fromBuffer(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
@@ -134,6 +128,7 @@ export class CheckpointProposal extends Gossipable {
       this.archive,
       this.lastBlock.txHashes,
       this.lastBlock.signature,
+      this.signatureContext,
       this.lastBlock.signedTxs,
     );
   }
@@ -165,21 +160,18 @@ export class CheckpointProposal extends Gossipable {
    * Get the payload to sign for this checkpoint proposal.
    * The signature is over the checkpoint header + archive root + feeAssetPriceModifier (for consensus).
    */
-  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
-    return serializeToBuffer([
-      domainSeparator,
-      this.checkpointHeader,
-      this.archive,
-      serializeSignedBigInt(this.feeAssetPriceModifier),
-    ]);
+  getPayloadToSign(): Buffer {
+    return serializeToBuffer([this.checkpointHeader, this.archive, serializeSignedBigInt(this.feeAssetPriceModifier)]);
   }
 
   static async createProposalFromSigner(
     checkpointHeader: CheckpointHeader,
     archiveRoot: Fr,
+    checkpointNumber: CheckpointNumber,
     feeAssetPriceModifier: bigint,
-    lastBlockInfo: CheckpointLastBlockData | undefined,
-    payloadSigner: (payload: Buffer32, context: SigningContext) => Promise<Signature>,
+    lastBlockProposal: BlockProposal | undefined,
+    signatureContext: CoordinationSignatureContext,
+    payloadSigner: (typedData: TypedDataDefinition, context: SigningContext) => Promise<Signature>,
   ): Promise<CheckpointProposal> {
     // Sign the checkpoint payload with CHECKPOINT_PROPOSAL duty type
     const tempProposal = new CheckpointProposal(
@@ -187,37 +179,25 @@ export class CheckpointProposal extends Gossipable {
       archiveRoot,
       feeAssetPriceModifier,
       Signature.empty(),
+      signatureContext,
     );
-    const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
-
     const checkpointContext: SigningContext = {
       slot: checkpointHeader.slotNumber,
-      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      checkpointNumber,
       dutyType: DutyType.CHECKPOINT_PROPOSAL,
     };
-    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
 
-    if (!lastBlockInfo) {
-      return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature);
-    }
+    const typedData = getCoordinationSignatureTypedData(tempProposal);
+    const checkpointSignature = await payloadSigner(typedData, checkpointContext);
 
-    const lastBlockProposal = await BlockProposal.createProposalFromSigner(
-      lastBlockInfo.blockHeader,
-      lastBlockInfo.indexWithinCheckpoint,
-      checkpointHeader.inHash,
+    return new CheckpointProposal(
+      checkpointHeader,
       archiveRoot,
-      lastBlockInfo.txHashes,
-      lastBlockInfo.txs,
-      payloadSigner,
+      feeAssetPriceModifier,
+      checkpointSignature,
+      signatureContext,
+      lastBlockProposal,
     );
-
-    return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature, {
-      blockHeader: lastBlockInfo.blockHeader,
-      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
-      txHashes: lastBlockInfo.txHashes,
-      signature: lastBlockProposal.signature,
-      signedTxs: lastBlockProposal.signedTxs,
-    });
   }
 
   /**
@@ -226,28 +206,26 @@ export class CheckpointProposal extends Gossipable {
    * @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 (this.cachedSender === undefined) {
+      const checkpointSender = recoverCoordinationSigner(this, 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
+          this.cachedSender = null;
+          return undefined;
         }
       }
 
-      // Cache the sender for later use
-      this.sender = checkpointSender;
+      this.cachedSender = checkpointSender ?? null;
     }
 
-    return this.sender;
+    return this.cachedSender ?? undefined;
   }
 
   getPayload() {
-    return this.getPayloadToSign(SignatureDomainSeparator.checkpointProposal);
+    return this.getPayloadToSign();
   }
 
   toBuffer(): Buffer {
@@ -256,6 +234,7 @@ export class CheckpointProposal extends Gossipable {
       this.archive,
       serializeSignedBigInt(this.feeAssetPriceModifier),
       this.signature,
+      serializeCoordinationSignatureContext(this.signatureContext),
     ];
 
     if (this.lastBlock) {
@@ -285,6 +264,7 @@ export class CheckpointProposal extends Gossipable {
     const archive = reader.readObject(Fr);
     const feeAssetPriceModifier = reader.readInt256();
     const signature = reader.readObject(Signature);
+    const signatureContext = readCoordinationSignatureContext(reader);
 
     const hasLastBlock = reader.readNumber();
 
@@ -306,7 +286,7 @@ export class CheckpointProposal extends Gossipable {
         }
       }
 
-      return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature, {
+      return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature, signatureContext, {
         blockHeader,
         indexWithinCheckpoint,
         txHashes,
@@ -315,7 +295,7 @@ export class CheckpointProposal extends Gossipable {
       });
     }
 
-    return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature);
+    return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature, signatureContext);
   }
 
   getSize(): number {
@@ -324,6 +304,8 @@ export class CheckpointProposal extends Gossipable {
       this.archive.size +
       this.signature.getSize() +
       8 /* feeAssetPriceModifier */ +
+      4 /* chainId */ +
+      20 /* rollupAddress */ +
       4; /* hasLastBlock flag */
 
     if (this.lastBlock) {
@@ -341,16 +323,29 @@ export class CheckpointProposal extends Gossipable {
   }
 
   static empty(): CheckpointProposal {
-    return new CheckpointProposal(CheckpointHeader.empty(), Fr.ZERO, 0n, Signature.empty());
+    return new CheckpointProposal(
+      CheckpointHeader.empty(),
+      Fr.ZERO,
+      0n,
+      Signature.empty(),
+      EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+    );
   }
 
   static random(): CheckpointProposal {
-    return new CheckpointProposal(CheckpointHeader.random(), Fr.random(), 0n, Signature.random(), {
-      blockHeader: BlockHeader.random(),
-      indexWithinCheckpoint: IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
-      txHashes: [TxHash.random(), TxHash.random()],
-      signature: Signature.random(),
-    });
+    return new CheckpointProposal(
+      CheckpointHeader.random(),
+      Fr.random(),
+      0n,
+      Signature.random(),
+      EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+      {
+        blockHeader: BlockHeader.random(),
+        indexWithinCheckpoint: IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
+        txHashes: [TxHash.random(), TxHash.random()],
+        signature: Signature.random(),
+      },
+    );
   }
 
   toInspect() {
@@ -359,6 +354,8 @@ export class CheckpointProposal extends Gossipable {
       archive: this.archive.toString(),
       signature: this.signature.toString(),
       feeAssetPriceModifier: this.feeAssetPriceModifier.toString(),
+      chainId: this.signatureContext.chainId,
+      rollupAddress: this.signatureContext.rollupAddress.toString(),
       lastBlock: this.lastBlock
         ? {
             blockHeader: this.lastBlock.blockHeader.toInspect(),
@@ -375,7 +372,13 @@ export class CheckpointProposal extends Gossipable {
    * Used when the lastBlock has been extracted and stored separately.
    */
   toCore(): CheckpointProposalCore {
-    return new CheckpointProposal(this.checkpointHeader, this.archive, this.feeAssetPriceModifier, this.signature);
+    return new CheckpointProposal(
+      this.checkpointHeader,
+      this.archive,
+      this.feeAssetPriceModifier,
+      this.signature,
+      this.signatureContext,
+    );
   }
 }
 

package/src/p2p/client_type.ts

@@ -1,6 +0,0 @@
-export enum P2PClientType {
-  // Full p2p clients will subscribe to all gossip topics
-  Full,
-  // Prove p2p clients will only subscribe to transaction and proving topics
-  Prover,
-}

package/src/p2p/consensus_payload.ts

@@ -10,10 +10,21 @@ import { z } from 'zod';
 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';
+import {
+  type CoordinationSignatureContext,
+  type CoordinationSignatureType,
+  EMPTY_COORDINATION_SIGNATURE_CONTEXT,
+  type Signable,
+  coordinationSignatureContextEquals,
+  coordinationSignatureContextSchema,
+  readCoordinationSignatureContext,
+  serializeCoordinationSignatureContext,
+} from './signature_utils.js';
 
 /** Checkpoint consensus payload as signed by validators and verified on L1. */
 export class ConsensusPayload implements Signable {
+  readonly primaryType: CoordinationSignatureType = 'CheckpointAttestation';
+
   private size: number | undefined;
 
   constructor(
@@ -22,7 +33,9 @@ export class ConsensusPayload implements Signable {
     /** The archive root after the block is added */
     public readonly archive: Fr,
     /** The fee asset price modifier in basis points (from oracle) */
-    public readonly feeAssetPriceModifier: bigint = 0n,
+    public readonly feeAssetPriceModifier: bigint,
+    /** The signing domain (chainId + rollupAddress) the signature is bound to */
+    public readonly signatureContext: CoordinationSignatureContext,
   ) {}
 
   static get schema() {
@@ -31,36 +44,38 @@ export class ConsensusPayload implements Signable {
         header: CheckpointHeader.schema,
         archive: schemas.Fr,
         feeAssetPriceModifier: schemas.BigInt,
+        signatureContext: coordinationSignatureContextSchema,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.feeAssetPriceModifier));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.feeAssetPriceModifier, obj.signatureContext));
   }
 
-  static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.feeAssetPriceModifier] as const;
+  static getFields(fields: Omit<FieldsOf<ConsensusPayload>, 'primaryType'>) {
+    return [fields.header, fields.archive, fields.feeAssetPriceModifier, fields.signatureContext] as const;
   }
 
-  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+  getPayloadToSign(): Buffer {
+    // Matches the L1 ProposePayload struct in ProposeLib.sol.
     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,
-      [archiveRoot, [this.feeAssetPriceModifier], headerHash],
-    ] as const);
+    const encodedData = encodeAbiParameters(abi, [[archiveRoot, [this.feeAssetPriceModifier], headerHash]] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.header, this.archive, serializeSignedBigInt(this.feeAssetPriceModifier)]);
+    return serializeToBuffer([
+      this.header,
+      this.archive,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+      serializeCoordinationSignatureContext(this.signatureContext),
+    ]);
   }
 
   public equals(other: ConsensusPayload | CheckpointProposal | CheckpointProposalCore): boolean {
@@ -69,34 +84,39 @@ export class ConsensusPayload implements Signable {
     return (
       this.header.equals(otherHeader) &&
       this.archive.equals(other.archive) &&
-      this.feeAssetPriceModifier === otherModifier
+      this.feeAssetPriceModifier === otherModifier &&
+      coordinationSignatureContextEquals(this.signatureContext, other.signatureContext)
     );
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    const payload = new ConsensusPayload(
-      reader.readObject(CheckpointHeader),
-      reader.readObject(Fr),
-      reader.readInt256(),
-    );
-    return payload;
+    const header = reader.readObject(CheckpointHeader);
+    const archive = reader.readObject(Fr);
+    const feeAssetPriceModifier = reader.readInt256();
+    const signatureContext = readCoordinationSignatureContext(reader);
+    return new ConsensusPayload(header, archive, feeAssetPriceModifier, signatureContext);
   }
 
-  static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.feeAssetPriceModifier);
+  static fromFields(fields: Omit<FieldsOf<ConsensusPayload>, 'primaryType'>): ConsensusPayload {
+    return new ConsensusPayload(fields.header, fields.archive, fields.feeAssetPriceModifier, fields.signatureContext);
   }
 
-  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
-    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root, checkpoint.feeAssetPriceModifier);
+  static fromCheckpoint(checkpoint: Checkpoint, signatureContext: CoordinationSignatureContext): ConsensusPayload {
+    return new ConsensusPayload(
+      checkpoint.header,
+      checkpoint.archive.root,
+      checkpoint.feeAssetPriceModifier,
+      signatureContext,
+    );
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, 0n);
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, 0n, EMPTY_COORDINATION_SIGNATURE_CONTEXT);
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), 0n);
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), 0n, EMPTY_COORDINATION_SIGNATURE_CONTEXT);
   }
 
   /**
@@ -117,10 +137,12 @@ export class ConsensusPayload implements Signable {
       header: this.header.toInspect(),
       archive: this.archive.toString(),
       feeAssetPriceModifier: this.feeAssetPriceModifier.toString(),
+      chainId: this.signatureContext.chainId,
+      rollupAddress: this.signatureContext.rollupAddress.toString(),
     };
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, feeAssetPriceModifier: ${this.feeAssetPriceModifier}}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, feeAssetPriceModifier: ${this.feeAssetPriceModifier}, chainId: ${this.signatureContext.chainId}, rollupAddress: ${this.signatureContext.rollupAddress.toString()}`;
   }
 }

package/src/p2p/gossipable.ts

@@ -1,4 +1,4 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { BaseBuffer32 } from '@aztec/foundation/buffer';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
@@ -46,7 +46,7 @@ export class P2PMessage {
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
-  private cachedId: Buffer32 | undefined;
+  private cachedId: BaseBuffer32 | undefined;
   /** The p2p topic identifier, this determines how the message is handled */
   static p2pTopic: TopicType;
 
@@ -54,7 +54,7 @@ export abstract class Gossipable {
    * 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.
    */
-  async p2pMessageLoggingIdentifier(): Promise<Buffer32> {
+  async p2pMessageLoggingIdentifier(): Promise<BaseBuffer32> {
     if (this.cachedId) {
       return this.cachedId;
     }
@@ -62,7 +62,7 @@ export abstract class Gossipable {
     return this.cachedId;
   }
 
-  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
+  abstract generateP2PMessageIdentifier(): Promise<BaseBuffer32>;
 
   abstract toBuffer(): Buffer;
 

package/src/p2p/index.ts

@@ -8,7 +8,6 @@ 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/peer_error.ts

@@ -15,3 +15,10 @@ export enum PeerErrorSeverity {
    */
   HighToleranceError = 'HighToleranceError',
 }
+
+/** Severities ordered from mildest to harshest. */
+export const PeerErrorSeverityByHarshness = [
+  PeerErrorSeverity.HighToleranceError,
+  PeerErrorSeverity.MidToleranceError,
+  PeerErrorSeverity.LowToleranceError,
+] as const;