@aztec/stdlib 4.0.0-nightly.20260112 → 4.0.0-nightly.20260113

package/src/p2p/block_proposal.ts

@@ -1,4 +1,4 @@
-import { SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, 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';
@@ -7,16 +7,18 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { L2Block } from '../block/l2_block.js';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
+import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
-import { Tx } from '../tx/tx.js';
-import { ConsensusPayload } from './consensus_payload.js';
+import type { Tx } from '../tx/tx.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';
 
 export class BlockProposalHash extends Buffer32 {
@@ -32,10 +34,9 @@ export type BlockProposalOptions = {
 };
 
 /**
- * BlockProposal
- *
- * A block proposal is created by the leader of the chain proposing a sequence of transactions to
- * be included in the head of the chain
+ * A block proposal is created by the leader of the chain proposing a sequence of transactions
+ * to be included in a block within a checkpoint. This is used for non-last blocks in a slot.
+ * The last block is sent as part of a CheckpointProposal.
  */
 export class BlockProposal extends Gossipable {
   static override p2pTopic = TopicType.block_proposal;
@@ -43,18 +44,28 @@ export class BlockProposal extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
-    /** The payload of the message, and what the signature is over */
-    public readonly payload: ConsensusPayload,
+    /** The per-block header containing block state and global variables */
+    public readonly blockHeader: BlockHeader,
 
-    /** The signer of the BlockProposal over the header of the new block*/
-    public readonly signature: Signature,
+    // TODO(palla/mbps): Is this really needed? Can we just derive it from the indexWithinCheckpoint of the parent block and the slot number?
+    // See the block-proposal-handler, we have a lot of extra validations to check this is correct, so maybe we can avoid storing it here.
+    /** Index of this block within the checkpoint (0-indexed) */
+    public readonly indexWithinCheckpoint: number,
+
+    /** Hash of L1 to L2 messages for this checkpoint (constant across all blocks in checkpoint) */
+    public readonly inHash: Fr,
+
+    /** Archive root after this block is applied */
+    public readonly archiveRoot: Fr,
 
     /** The sequence of transactions in the block */
     public readonly txHashes: TxHash[],
 
-    // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
-    /** The transactions in the block */
-    public readonly txs?: Tx[],
+    /** The proposer's signature over the block data */
+    public readonly signature: Signature,
+
+    /** The signed transactions in the block (optional, for DA guarantees) */
+    public readonly signedTxs?: SignedTxs,
   ) {
     super();
   }
@@ -64,59 +75,123 @@ export class BlockProposal extends Gossipable {
   }
 
   get archive(): Fr {
-    return this.payload.archive;
+    return this.archiveRoot;
   }
 
   get slotNumber(): SlotNumber {
-    return this.payload.header.slotNumber;
+    return this.blockHeader.getSlot();
+  }
+
+  get blockNumber(): BlockNumber {
+    return this.blockHeader.getBlockNumber();
+  }
+
+  /** Convenience getter for txs from signedTxs */
+  get txs(): Tx[] | undefined {
+    return this.signedTxs?.txs;
   }
 
   toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
       slotNumber: this.slotNumber,
-      lastArchive: this.payload.header.lastArchiveRoot,
-      timestamp: this.payload.header.timestamp,
-      archive: this.archive,
+      lastArchive: this.blockHeader.lastArchive.root,
+      timestamp: this.blockHeader.globalVariables.timestamp,
+      archive: this.archiveRoot,
       txCount: this.txHashes.length,
     };
   }
 
+  /**
+   * Get the payload to sign for this block proposal.
+   * The signature is over: blockHeader + indexWithinCheckpoint + inHash + archiveRoot + txHashes
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([
+      domainSeparator,
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.txHashes.length,
+      this.txHashes,
+    ]);
+  }
+
   static async createProposalFromSigner(
-    payload: ConsensusPayload,
+    blockHeader: BlockHeader,
+    indexWithinCheckpoint: number,
+    inHash: Fr,
+    archiveRoot: Fr,
     txHashes: TxHash[],
-    // Note(md): Provided separately to tx hashes such that this function can be optional
     txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
-  ) {
-    const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
+  ): Promise<BlockProposal> {
+    // Create a temporary proposal to get the payload to sign
+    const tempProposal = new BlockProposal(
+      blockHeader,
+      indexWithinCheckpoint,
+      inHash,
+      archiveRoot,
+      txHashes,
+      Signature.empty(),
+    );
+
+    const hashed = getHashedSignaturePayload(tempProposal, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(payload, sig, txHashes, txs);
+    // If txs are provided, sign them as well
+    let signedTxs: SignedTxs | undefined;
+    if (txs) {
+      signedTxs = await SignedTxs.createFromSigner(txs, payloadSigner);
+    }
+
+    return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, sig, signedTxs);
   }
 
-  /**Get Sender
-   * Lazily evaluate the sender of the proposal; result is cached
-   * @returns The sender address, or undefined if signature recovery fails
+  /**
+   * Lazily evaluate the sender of the proposal; result is cached.
+   * If there's signedTxs, also verifies the signedTxs sender matches the block proposal 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.payload, SignatureDomainSeparator.blockProposal);
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.blockProposal);
+      const blockSender = tryRecoverAddress(hashed, this.signature);
+
+      // If there's signedTxs, verify the sender matches
+      if (blockSender && this.signedTxs) {
+        const txsSender = this.signedTxs.getSender();
+        if (!txsSender || !txsSender.equals(blockSender)) {
+          return undefined; // Sender mismatch - fail
+        }
+      }
+
       // Cache the sender for later use
-      this.sender = tryRecoverAddress(hashed, this.signature);
+      this.sender = blockSender;
     }
 
     return this.sender;
   }
 
   getPayload() {
-    return this.payload.getPayloadToSign(SignatureDomainSeparator.blockProposal);
+    return this.getPayloadToSign(SignatureDomainSeparator.blockProposal);
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
-    if (this.txs) {
-      buffer.push(this.txs.length);
-      buffer.push(this.txs);
+    const buffer: any[] = [
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.signature,
+      this.txHashes.length,
+      this.txHashes,
+    ];
+    if (this.signedTxs) {
+      buffer.push(1); // hasSignedTxs = true
+      buffer.push(this.signedTxs.toBuffer());
+    } else {
+      buffer.push(0); // hasSignedTxs = false
     }
     return serializeToBuffer(buffer);
   }
@@ -124,25 +199,94 @@ export class BlockProposal extends Gossipable {
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
 
-    const payload = reader.readObject(ConsensusPayload);
-    const sig = reader.readObject(Signature);
+    const blockHeader = reader.readObject(BlockHeader);
+    const indexWithinCheckpoint = reader.readNumber();
+    const inHash = reader.readObject(Fr);
+    const archiveRoot = reader.readObject(Fr);
+    const signature = reader.readObject(Signature);
     const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
-      const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(payload, sig, txHashes, txs);
+      const hasSignedTxs = reader.readNumber();
+      if (hasSignedTxs) {
+        const signedTxs = SignedTxs.fromBuffer(reader);
+        return new BlockProposal(
+          blockHeader,
+          indexWithinCheckpoint,
+          inHash,
+          archiveRoot,
+          txHashes,
+          signature,
+          signedTxs,
+        );
+      }
     }
 
-    return new BlockProposal(payload, sig, txHashes);
+    return new BlockProposal(blockHeader, indexWithinCheckpoint, inHash, archiveRoot, txHashes, signature);
   }
 
   getSize(): number {
     return (
-      this.payload.getSize() +
+      this.blockHeader.getSize() +
+      4 /* indexWithinCheckpoint */ +
+      this.inHash.size +
+      this.archiveRoot.size +
       this.signature.getSize() +
       4 /* txHashes.length */ +
       this.txHashes.length * TxHash.SIZE +
-      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+      4 /* hasSignedTxs flag */ +
+      (this.signedTxs ? this.signedTxs.getSize() : 0)
+    );
+  }
+
+  static empty(): BlockProposal {
+    return new BlockProposal(BlockHeader.empty(), 0, Fr.ZERO, Fr.ZERO, [], Signature.empty());
+  }
+
+  static random(): BlockProposal {
+    return new BlockProposal(
+      BlockHeader.random(),
+      Math.floor(Math.random() * 5),
+      Fr.random(),
+      Fr.random(),
+      [TxHash.random(), TxHash.random()],
+      Signature.random(),
+    );
+  }
+
+  toInspect() {
+    return {
+      blockHeader: this.blockHeader.toInspect(),
+      indexWithinCheckpoint: this.indexWithinCheckpoint,
+      inHash: this.inHash.toString(),
+      archiveRoot: this.archiveRoot.toString(),
+      signature: this.signature.toString(),
+      txHashes: this.txHashes.map(h => h.toString()),
+    };
+  }
+
+  /**
+   * Check if this proposal matches the given block.
+   * Compares the archive root and block header.
+   * @param block - The L2Block to compare against
+   * @returns True if the proposal matches the block
+   */
+  matchesBlock(block: L2Block): boolean {
+    return this.archiveRoot.equals(block.archive.root) && this.blockHeader.equals(block.getBlockHeader());
+  }
+
+  /**
+   * Returns a copy of this proposal without signedTxs.
+   * Used when storing proposals in attestation pool to avoid storing full tx data.
+   */
+  withoutSignedTxs(): BlockProposal {
+    return new BlockProposal(
+      this.blockHeader,
+      this.indexWithinCheckpoint,
+      this.inHash,
+      this.archiveRoot,
+      this.txHashes,
+      this.signature,
     );
   }
 }

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

@@ -2,7 +2,7 @@ import { 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 { 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';
@@ -10,25 +10,26 @@ 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;
@@ -37,27 +38,27 @@ 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 {
@@ -75,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);
     }
@@ -84,43 +88,45 @@ 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.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 {