@aztec/stdlib 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/src/p2p/{block_attestation.ts → checkpoint_attestation.ts}

@@ -1,32 +1,35 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
+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';
-import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
 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 { TopicType } from './topic_type.js';
 
-export class BlockAttestationHash extends Buffer32 {
+export class CheckpointAttestationHash extends Buffer32 {
   constructor(hash: Buffer) {
     super(hash);
   }
 }
 
 /**
- * BlockAttestation
+ * CheckpointAttestation
  *
- * A validator that has attested to seeing the contents of a block
- * will produce a block attestation over the header of the block
+ * A validator that has attested to seeing all blocks in a checkpoint
+ * will produce a checkpoint attestation over the checkpoint header.
  */
-export class BlockAttestation extends Gossipable {
-  static override p2pTopic = TopicType.block_attestation;
+export class CheckpointAttestation extends Gossipable {
+  static override p2pTopic = TopicType.checkpoint_attestation;
 
   private sender: EthAddress | undefined;
   private proposer: EthAddress | undefined;
@@ -35,34 +38,34 @@ export class BlockAttestation extends Gossipable {
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
-    /** The signature of the block attester */
+    /** The signature of the checkpoint attester */
     public readonly signature: Signature,
 
-    /** The signature from the block proposer */
+    /** The signature from the checkpoint proposer */
     public readonly proposerSignature: Signature,
   ) {
     super();
   }
 
-  static get schema(): ZodFor<BlockAttestation> {
+  static get schema(): ZodFor<CheckpointAttestation> {
     return z
       .object({
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
         proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
+      .transform(obj => new CheckpointAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
   override generateP2PMessageIdentifier(): Promise<Buffer32> {
-    return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
+    return Promise.resolve(new CheckpointAttestationHash(keccak256(this.signature.toBuffer())));
   }
 
   get archive(): Fr {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
+  get slotNumber(): SlotNumber {
     return this.payload.header.slotNumber;
   }
 
@@ -73,7 +76,10 @@ export class BlockAttestation extends Gossipable {
   getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
+      const hashed = getHashedSignaturePayloadEthSignedMessage(
+        this.payload,
+        SignatureDomainSeparator.checkpointAttestation,
+      );
       // Cache the sender for later use
       this.sender = tryRecoverAddress(hashed, this.signature);
     }
@@ -82,43 +88,50 @@ export class BlockAttestation extends Gossipable {
   }
 
   /**
-   * Lazily evaluate and cache the proposer of the block
-   * @returns The proposer of the block
+   * Lazily evaluate and cache the proposer of the checkpoint
+   * @returns The proposer of the checkpoint
    */
   getProposer(): EthAddress | undefined {
     if (!this.proposer) {
-      // Recover the proposer from the proposal signature
-      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      // 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).
+      const proposal = new CheckpointProposal(
+        this.payload.header,
+        this.payload.archive,
+        this.payload.feeAssetPriceModifier,
+        this.proposerSignature,
+      );
       // Cache the proposer for later use
-      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
+      this.proposer = proposal.getSender();
     }
 
     return this.proposer;
   }
 
   getPayload(): Buffer {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
+    return this.payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation);
   }
 
   toBuffer(): Buffer {
     return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
   }
 
-  static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
+  static fromBuffer(buf: Buffer | BufferReader): CheckpointAttestation {
     const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(
+    return new CheckpointAttestation(
       reader.readObject(ConsensusPayload),
       reader.readObject(Signature),
       reader.readObject(Signature),
     );
   }
 
-  static empty(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
+  static empty(): CheckpointAttestation {
+    return new CheckpointAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
   }
 
-  static random(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
+  static random(): CheckpointAttestation {
+    return new CheckpointAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
   }
 
   getSize(): number {

package/src/p2p/checkpoint_proposal.ts

@@ -0,0 +1,373 @@
+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, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
+
+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';
+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 = {
+  /**
+   * Whether to include the tx objects along with the block proposal.
+   * Dramatically increases size of the payload but eliminates failed reexecutions due to missing txs.
+   */
+  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 fee asset price modifier in basis points (from oracle) */
+    public readonly feeAssetPriceModifier: bigint,
+
+    /** The proposer's signature over the checkpoint payload (checkpointHeader + archive + feeAssetPriceModifier) */
+    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;
+  }
+
+  /**
+   * 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,
+    };
+  }
+
+  toCheckpointInfo() {
+    return {
+      slotNumber: this.slotNumber,
+      archive: this.archive,
+      lastBlockNumber: this.lastBlock?.blockHeader.getBlockNumber(),
+      lastBlockIndex: this.lastBlock?.indexWithinCheckpoint,
+      blockHeadersHash: this.checkpointHeader.blockHeadersHash,
+    };
+  }
+
+  /**
+   * 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),
+    ]);
+  }
+
+  static async createProposalFromSigner(
+    checkpointHeader: CheckpointHeader,
+    archiveRoot: Fr,
+    feeAssetPriceModifier: bigint,
+    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,
+      feeAssetPriceModifier,
+      Signature.empty(),
+    );
+    const checkpointHash = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.checkpointProposal);
+
+    const checkpointContext: SigningContext = {
+      slot: checkpointHeader.slotNumber,
+      blockNumber: lastBlockInfo?.blockHeader?.globalVariables.blockNumber ?? BlockNumber(0),
+      dutyType: DutyType.CHECKPOINT_PROPOSAL,
+    };
+
+    if (lastBlockInfo) {
+      // Sign block proposal before signing checkpoint proposal to ensure HA protection
+      const lastBlockProposal = await BlockProposal.createProposalFromSigner(
+        lastBlockInfo.blockHeader,
+        lastBlockInfo.indexWithinCheckpoint,
+        checkpointHeader.inHash,
+        archiveRoot,
+        lastBlockInfo.txHashes,
+        lastBlockInfo.txs,
+        payloadSigner,
+      );
+
+      const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
+
+      return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature, {
+        blockHeader: lastBlockInfo.blockHeader,
+        indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+        txHashes: lastBlockInfo.txHashes,
+        signature: lastBlockProposal.signature,
+        signedTxs: lastBlockProposal.signedTxs,
+      });
+    }
+
+    const checkpointSignature = await payloadSigner(checkpointHash, checkpointContext);
+    return new CheckpointProposal(checkpointHeader, archiveRoot, feeAssetPriceModifier, checkpointSignature);
+  }
+
+  /**
+   * 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,
+      serializeSignedBigInt(this.feeAssetPriceModifier),
+      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 feeAssetPriceModifier = reader.readInt256();
+    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, feeAssetPriceModifier, signature, {
+        blockHeader,
+        indexWithinCheckpoint,
+        txHashes,
+        signature: blockSignature,
+        signedTxs,
+      });
+    }
+
+    return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature);
+  }
+
+  getSize(): number {
+    let size =
+      this.checkpointHeader.toBuffer().length +
+      this.archive.size +
+      this.signature.getSize() +
+      8 /* feeAssetPriceModifier */ +
+      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, 0n, Signature.empty());
+  }
+
+  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(),
+    });
+  }
+
+  toInspect() {
+    return {
+      checkpointHeader: this.checkpointHeader.toInspect(),
+      archive: this.archive.toString(),
+      signature: this.signature.toString(),
+      feeAssetPriceModifier: this.feeAssetPriceModifier.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.feeAssetPriceModifier, 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/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

@@ -1,17 +1,18 @@
-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 { BufferReader, serializeSignedBigInt, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
-import type { L2Block } from '../block/l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
-import { StateReference } from '../tx/state_reference.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;
 
@@ -20,8 +21,8 @@ export class ConsensusPayload implements Signable {
     public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The state reference after the block is added */
-    public readonly stateReference: StateReference,
+    /** The fee asset price modifier in basis points (from oracle) */
+    public readonly feeAssetPriceModifier: bigint = 0n,
   ) {}
 
   static get schema() {
@@ -29,13 +30,13 @@ export class ConsensusPayload implements Signable {
       .object({
         header: CheckpointHeader.schema,
         archive: schemas.Fr,
-        stateReference: StateReference.schema,
+        feeAssetPriceModifier: schemas.BigInt,
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.feeAssetPriceModifier));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.stateReference] as const;
+    return [fields.header, fields.archive, fields.feeAssetPriceModifier] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
@@ -43,32 +44,32 @@ export class ConsensusPayload implements Signable {
       'uint8, ' + //domainSeperator
         '(' +
         'bytes32, ' + // archive
-        '((bytes32,uint32),((bytes32,uint32),(bytes32,uint32),(bytes32,uint32))), ' + // stateReference
         '(int256), ' + // oracleInput
         'bytes32' + // headerHash
         ')',
     );
     const archiveRoot = this.archive.toString();
-    const stateReference = this.stateReference.toAbi();
 
     const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash],
+      [archiveRoot, [this.feeAssetPriceModifier], headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.header, this.archive, this.stateReference]);
+    return serializeToBuffer([this.header, this.archive, serializeSignedBigInt(this.feeAssetPriceModifier)]);
   }
 
-  public equals(other: ConsensusPayload): boolean {
+  public equals(other: ConsensusPayload | CheckpointProposal | CheckpointProposalCore): boolean {
+    const otherHeader = 'checkpointHeader' in other ? other.checkpointHeader : other.header;
+    const otherModifier = 'feeAssetPriceModifier' in other ? other.feeAssetPriceModifier : 0n;
     return (
-      this.header.equals(other.header) &&
+      this.header.equals(otherHeader) &&
       this.archive.equals(other.archive) &&
-      this.stateReference.equals(other.stateReference)
+      this.feeAssetPriceModifier === otherModifier
     );
   }
 
@@ -77,25 +78,25 @@ export class ConsensusPayload implements Signable {
     const payload = new ConsensusPayload(
       reader.readObject(CheckpointHeader),
       reader.readObject(Fr),
-      reader.readObject(StateReference),
+      reader.readInt256(),
     );
     return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference);
+    return new ConsensusPayload(fields.header, fields.archive, fields.feeAssetPriceModifier);
   }
 
-  static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root, checkpoint.feeAssetPriceModifier);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, 0n);
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), 0n);
   }
 
   /**
@@ -115,11 +116,11 @@ export class ConsensusPayload implements Signable {
     return {
       header: this.header.toInspect(),
       archive: this.archive.toString(),
-      stateReference: this.stateReference.toInspect(),
+      feeAssetPriceModifier: this.feeAssetPriceModifier.toString(),
     };
   }
 
   toString() {
-    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, feeAssetPriceModifier: ${this.feeAssetPriceModifier}}`;
   }
 }

package/src/p2p/constants.ts

@@ -0,0 +1,6 @@
+export const MAX_TX_SIZE_KB: number = 512;
+
+export const MAX_MESSAGE_SIZE_KB: number = 10 * 1024;
+
+/** Maximum size for L2Block response (contains TxEffects, not full Txs with proofs) */
+export const MAX_L2_BLOCK_SIZE_KB: number = 3 * 1024; // 3 MB