@aztec/stdlib 3.0.0-nightly.20250916 → 3.0.0-nightly.20250918

package/src/messaging/inbox_leaf.ts

@@ -35,4 +35,9 @@ export class InboxLeaf {
     const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     return [start, end];
   }
+
+  /** Returns the L2 block number for a given leaf index */
+  static l2BlockFromIndex(index: bigint): number {
+    return Number(index / BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)) + INITIAL_L2_BLOCK_NUM;
+  }
 }

package/src/p2p/consensus_payload.ts

@@ -8,7 +8,8 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
-import { ProposedBlockHeader, StateReference } from '../tx/index.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -16,7 +17,7 @@ export class ConsensusPayload implements Signable {
 
   constructor(
     /** The proposed block header the attestation is made over */
-    public readonly header: ProposedBlockHeader,
+    public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
     /** The state reference after the block is added */
@@ -26,7 +27,7 @@ export class ConsensusPayload implements Signable {
   static get schema() {
     return z
       .object({
-        header: ProposedBlockHeader.schema,
+        header: CheckpointHeader.schema,
         archive: schemas.Fr,
         stateReference: StateReference.schema,
       })
@@ -66,7 +67,7 @@ export class ConsensusPayload implements Signable {
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
     const payload = new ConsensusPayload(
-      reader.readObject(ProposedBlockHeader),
+      reader.readObject(CheckpointHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
     );
@@ -78,15 +79,15 @@ export class ConsensusPayload implements Signable {
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
+    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
   }
 
   static random(): ConsensusPayload {
-    return new ConsensusPayload(ProposedBlockHeader.random(), Fr.random(), StateReference.random());
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
   }
 
   /**

package/src/proofs/proof_data.ts

@@ -23,14 +23,9 @@ export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
     publicInputs: {
       fromBuffer: (reader: BufferReader) => T;
     },
-    proofLength?: PROOF_LENGTH,
   ): ProofData<T, PROOF_LENGTH> {
     const reader = BufferReader.asReader(buffer);
-    return new ProofData(
-      reader.readObject(publicInputs),
-      RecursiveProof.fromBuffer(reader, proofLength),
-      reader.readObject(VkData),
-    );
+    return new ProofData(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader), reader.readObject(VkData));
   }
 }
 

package/src/proofs/proving_request_type.ts

@@ -4,11 +4,16 @@ export enum ProvingRequestType {
   PRIVATE_BASE_ROLLUP,
   PUBLIC_BASE_ROLLUP,
   MERGE_ROLLUP,
-  EMPTY_BLOCK_ROOT_ROLLUP,
-  PADDING_BLOCK_ROOT_ROLLUP,
+  BLOCK_ROOT_FIRST_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
+  BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
   BLOCK_ROOT_ROLLUP,
-  SINGLE_TX_BLOCK_ROOT_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_ROLLUP,
   BLOCK_MERGE_ROLLUP,
+  CHECKPOINT_ROOT_ROLLUP,
+  CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
+  CHECKPOINT_PADDING_ROLLUP,
+  CHECKPOINT_MERGE_ROLLUP,
   ROOT_ROLLUP,
 
   BASE_PARITY,

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -1,4 +1,4 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';

package/src/rollup/base_rollup_hints.ts

@@ -1,6 +1,7 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { MembershipWitness } from '@aztec/foundation/trees';
@@ -127,6 +128,10 @@ export class PublicBaseRollupHints {
      * Preimages to the kernel's contractClassLogsHashes.
      */
     public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    /**
+     * Identifier of the prover.
+     */
+    public proverId: Fr,
   ) {}
 
   static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
@@ -139,6 +144,7 @@ export class PublicBaseRollupHints {
       fields.lastArchive,
       fields.archiveRootMembershipWitness,
       fields.contractClassLogsFields,
+      fields.proverId,
     ] as const;
   }
 
@@ -165,6 +171,7 @@ export class PublicBaseRollupHints {
       reader.readObject(AppendOnlyTreeSnapshot),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
+      reader.readObject(Fr),
     );
   }
 
@@ -178,6 +185,7 @@ export class PublicBaseRollupHints {
       AppendOnlyTreeSnapshot.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
+      Fr.ZERO,
     );
   }
 }

package/src/rollup/block_constant_data.ts

@@ -12,14 +12,21 @@ export class BlockConstantData {
   constructor(
     /** Archive tree snapshot at the very beginning of the entire rollup. */
     public lastArchive: AppendOnlyTreeSnapshot,
-    /** L1 to L2 message tree snapshot after this block lands. */
-    public newL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * L1-to-L2 message tree snapshot after this block lands.
+     * For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree
+     * into the last l1-to-l2 tree snapshot in `last_archive`.
+     * For subsequent blocks, this should match the snapshot of the previous block.
+     */
+    public l1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
     /** Root of the verification key tree. */
     public vkTreeRoot: Fr,
     /** Root of the protocol contract tree. */
     public protocolContractTreeRoot: Fr,
     /** Global variables for the block. */
     public globalVariables: GlobalVariables,
+    /** Identifier of the prover. */
+    public proverId: Fr,
   ) {}
 
   static from(fields: FieldsOf<BlockConstantData>): BlockConstantData {
@@ -34,16 +41,18 @@ export class BlockConstantData {
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       reader.readObject(GlobalVariables),
+      Fr.fromBuffer(reader),
     );
   }
 
   static getFields(fields: FieldsOf<BlockConstantData>) {
     return [
       fields.lastArchive,
-      fields.newL1ToL2,
+      fields.l1ToL2TreeSnapshot,
       fields.vkTreeRoot,
       fields.protocolContractTreeRoot,
       fields.globalVariables,
+      fields.proverId,
     ] as const;
   }
 
@@ -54,6 +63,7 @@ export class BlockConstantData {
       Fr.ZERO,
       Fr.ZERO,
       GlobalVariables.empty(),
+      Fr.ZERO,
     );
   }
 

package/src/rollup/block_merge_rollup.ts

@@ -2,17 +2,19 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
+import { ProofData } from '../proofs/index.js';
+import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
+import type { RollupProofData } from './rollup_proof_data.js';
 
 /**
  * Represents inputs of the block merge rollup circuit.
  */
-export class BlockMergeRollupInputs {
+export class BlockMergeRollupPrivateInputs {
   constructor(
     /**
      * Previous rollup data from the 2 block merge or block root rollup circuits that preceded this merge rollup circuit.
      */
-    public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
+    public previousRollups: [RollupProofData<BlockRollupPublicInputs>, RollupProofData<BlockRollupPublicInputs>],
   ) {}
 
   /**
@@ -20,7 +22,7 @@ export class BlockMergeRollupInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousRollupData);
+    return serializeToBuffer(this.previousRollups);
   }
 
   /**
@@ -34,23 +36,23 @@ export class BlockMergeRollupInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new BlockMergeRollupInputs instance.
+   * @returns A new BlockMergeRollupPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BlockMergeRollupInputs([
-      reader.readObject(PreviousRollupBlockData),
-      reader.readObject(PreviousRollupBlockData),
+    return new BlockMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, BlockRollupPublicInputs),
+      ProofData.fromBuffer(reader, BlockRollupPublicInputs),
     ]);
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new BlockMergeRollupInputs instance.
+   * @returns A new BlockMergeRollupPrivateInputs instance.
    */
   static fromString(str: string) {
-    return BlockMergeRollupInputs.fromBuffer(hexToBuffer(str));
+    return BlockMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a hex representation for JSON serialization. */
@@ -60,6 +62,6 @@ export class BlockMergeRollupInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BlockMergeRollupInputs);
+    return bufferSchemaFor(BlockMergeRollupPrivateInputs);
   }
 }

package/src/rollup/block_rollup_public_inputs.ts

@@ -0,0 +1,123 @@
+import { SpongeBlob } from '@aztec/blob-lib/types';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { StateReference } from '../tx/state_reference.js';
+import type { UInt64 } from '../types/shared.js';
+import { CheckpointConstantData } from './checkpoint_constant_data.js';
+
+/**
+ * Output of the block root and block merge rollup circuits.
+ */
+export class BlockRollupPublicInputs {
+  constructor(
+    /**
+     * Constants for the entire checkpoint.
+     */
+    public constants: CheckpointConstantData,
+    /**
+     * Archive tree immediately before this block range.
+     */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    /**
+     * Archive tree after applying this block range.
+     */
+    public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * State reference immediately before this block range.
+     */
+    public startState: StateReference,
+    /**
+     * State reference after applying this block range.
+     */
+    public endState: StateReference,
+    /**
+     * Sponge state to absorb blob inputs at the start of this block range.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Sponge state to absorb blob inputs at the end of this block range.
+     */
+    public endSpongeBlob: SpongeBlob,
+    /**
+     * Timestamp of the first block in this block range.
+     */
+    public startTimestamp: UInt64,
+    /**
+     * Timestamp of the last block in this block range.
+     */
+    public endTimestamp: UInt64,
+    /**
+     * SHA256 hash of l1 to l2 messages.
+     */
+    public inHash: Fr,
+    /**
+     * SHA256 hash of L2 to L1 messages created in this block range.
+     */
+    public outHash: Fr,
+    /**
+     * The summed transaction fees of all the txs in this block range.
+     */
+    public accumulatedFees: Fr,
+    /**
+     * The summed mana used of all the txs in this block range.
+     */
+    public accumulatedManaUsed: Fr,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRollupPublicInputs(
+      reader.readObject(CheckpointConstantData),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(StateReference),
+      reader.readObject(StateReference),
+      reader.readObject(SpongeBlob),
+      reader.readObject(SpongeBlob),
+      reader.readUInt64(),
+      reader.readUInt64(),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.constants,
+      this.previousArchive,
+      this.newArchive,
+      this.startState,
+      this.endState,
+      this.startSpongeBlob,
+      this.endSpongeBlob,
+      bigintToUInt64BE(this.startTimestamp),
+      bigintToUInt64BE(this.endTimestamp),
+      this.inHash,
+      this.outHash,
+      this.accumulatedFees,
+      this.accumulatedManaUsed,
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return BlockRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRollupPublicInputs);
+  }
+}