@aztec/stdlib 0.0.1-commit.c7c42ec → 0.0.1-commit.f295ac2

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

@@ -7,11 +7,12 @@ 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 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;
 
@@ -59,8 +60,9 @@ export class ConsensusPayload implements Signable {
     return serializeToBuffer([this.header, this.archive]);
   }
 
-  public equals(other: ConsensusPayload): boolean {
-    return this.header.equals(other.header) && this.archive.equals(other.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 {
@@ -73,10 +75,6 @@ export class ConsensusPayload implements Signable {
     return new ConsensusPayload(fields.header, fields.archive);
   }
 
-  static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root);
-  }
-
   static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
     return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }

package/src/p2p/gossipable.ts

@@ -7,23 +7,33 @@ export class P2PMessage {
   constructor(
     public readonly payload: Buffer,
     public readonly timestamp?: Date,
+    public readonly traceContext?: string,
   ) {}
 
-  static fromGossipable(message: Gossipable, instrumentMessages = false): P2PMessage {
-    return new P2PMessage(message.toBuffer(), instrumentMessages ? new Date() : undefined);
+  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);
-    const timestamp = instrumentMessages ? new Date(Number(reader.readUInt64())) : undefined;
+    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);
+    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);

package/src/p2p/index.ts

@@ -1,10 +1,12 @@
 export * from './attestation_utils.js';
-export * from './block_attestation.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';

package/src/p2p/signature_utils.ts

@@ -4,8 +4,10 @@ import { makeEthSignDigest } from '@aztec/foundation/crypto/secp256k1-signer';
 
 export enum SignatureDomainSeparator {
   blockProposal = 0,
-  blockAttestation = 1,
+  checkpointAttestation = 1,
   attestationsAndSigners = 2,
+  checkpointProposal = 3,
+  signedTxs = 4,
 }
 
 export interface Signable {

package/src/p2p/signed_txs.ts

@@ -0,0 +1,88 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { Tx } from '../tx/tx.js';
+import {
+  SignatureDomainSeparator,
+  getHashedSignaturePayload,
+  getHashedSignaturePayloadEthSignedMessage,
+} from './signature_utils.js';
+
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */
+export class SignedTxs {
+  private sender: EthAddress | undefined;
+
+  constructor(
+    /** The transactions */
+    public readonly txs: Tx[],
+    /** The proposer's signature over the transactions */
+    public readonly signature: Signature,
+  ) {}
+
+  /**
+   * Get the payload to sign for this signed txs.
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([domainSeparator, this.txs.length, this.txs]);
+  }
+
+  /**
+   * Lazily evaluate the sender of the signed txs; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
+   */
+  getSender(): EthAddress | undefined {
+    if (!this.sender) {
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.signedTxs);
+      this.sender = tryRecoverAddress(hashed, this.signature);
+    }
+    return this.sender;
+  }
+
+  /**
+   * Create SignedTxs from a signer function
+   */
+  static async createFromSigner(
+    txs: Tx[],
+    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+  ): Promise<SignedTxs> {
+    const tempSignedTxs = new SignedTxs(txs, Signature.empty());
+    const hashed = getHashedSignaturePayload(tempSignedTxs, SignatureDomainSeparator.signedTxs);
+    const signature = await payloadSigner(hashed);
+    return new SignedTxs(txs, signature);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.txs.length, this.txs, this.signature]);
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
+    const reader = BufferReader.asReader(buf);
+    const txCount = reader.readNumber();
+    if (txCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txs = reader.readArray(txCount, Tx);
+    const signature = reader.readObject(Signature);
+    return new SignedTxs(txs, signature);
+  }
+
+  getSize(): number {
+    return 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) + this.signature.getSize();
+  }
+
+  static empty(): SignedTxs {
+    return new SignedTxs([], Signature.empty());
+  }
+
+  static random(): SignedTxs {
+    return new SignedTxs([Tx.random(), Tx.random()], Signature.random());
+  }
+}

package/src/p2p/topic_type.ts

@@ -23,14 +23,15 @@ export function getTopicFromString(topicStr: string): TopicType | undefined {
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',
-  block_attestation = 'block_attestation',
+  checkpoint_proposal = 'checkpoint_proposal',
+  checkpoint_attestation = 'checkpoint_attestation',
 }
 
 export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
-    return Object.values(TopicType);
+    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal, TopicType.checkpoint_attestation];
   } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal];
+    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal];
   } else {
     const _: never = clientType;
     return [TopicType.tx];

package/src/proofs/chonk_proof.ts

@@ -1,4 +1,5 @@
 import { CHONK_PROOF_LENGTH } from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
@@ -31,12 +32,15 @@ export class ChonkProof {
 
   static random() {
     // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+    // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
     const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
-    const randomFields = randomBytes(CHONK_PROOF_LENGTH * reducedFrSize);
-    const proof = Array.from(
-      { length: CHONK_PROOF_LENGTH },
-      (_, i) => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize)),
-    );
+    const nonZeroFields = Math.floor((3 * CHONK_PROOF_LENGTH) / 4);
+    const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+    const proof = [
+      ...times(nonZeroFields, i => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+      ...times(CHONK_PROOF_LENGTH - nonZeroFields, () => Fr.ZERO),
+    ];
     return new ChonkProof(proof);
   }
 

package/src/rollup/block_headers_hash.ts

@@ -5,7 +5,7 @@ import type { BlockHeader } from '../tx/block_header.js';
 
 export async function computeBlockHeadersHash(blockHeaders: BlockHeader[]): Promise<Fr> {
   const blockHeaderHashes = await Promise.all(blockHeaders.map(header => header.hash()));
-  // Must match the implementation in merge_block_rollups.nr, with the **wonky** rollup structure
+  // Must match the implementation in merge_block_rollups.nr, with the **unbalanced** rollup structure
   // (see validate_consecutive_block_rollups.nr > assert_rollups_filled_greedily.nr).
   const blockHeadersHash = await computeUnbalancedPoseidonRoot(blockHeaderHashes.map(hash => hash.toBuffer()));
   return Fr.fromBuffer(blockHeadersHash);

package/src/rollup/block_rollup_public_inputs.ts

@@ -43,17 +43,13 @@ export class BlockRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * Timestamp of the first block in this block range.
+     * Timestamp of the blocks in this block range.
      */
-    public startTimestamp: UInt64,
-    /**
-     * Timestamp of the last block in this block range.
-     */
-    public endTimestamp: UInt64,
+    public timestamp: UInt64,
     /**
      * Hash of the headers of all blocks in this block range. It will be combined with the `blockHeadersHash` from
-     * other blocks in the same checkpoint to form a wonky tree. The root of that tree becomes the final hash stored in
-     * the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
+     * other blocks in the same checkpoint to form an unbalanced tree. The root of that tree becomes the final hash
+     * stored in the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers.
      */
     public blockHeadersHash: Fr,
     /**
@@ -85,7 +81,6 @@ export class BlockRollupPublicInputs {
       reader.readObject(SpongeBlob),
       reader.readObject(SpongeBlob),
       reader.readUInt64(),
-      reader.readUInt64(),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -103,8 +98,7 @@ export class BlockRollupPublicInputs {
       this.endState,
       this.startSpongeBlob,
       this.endSpongeBlob,
-      bigintToUInt64BE(this.startTimestamp),
-      bigintToUInt64BE(this.endTimestamp),
+      bigintToUInt64BE(this.timestamp),
       this.blockHeadersHash,
       this.inHash,
       this.outHash,