@aztec/blob-lib 3.0.0-nightly.20251120 → 3.0.0-nightly.20251122

package/dest/sponge_blob.js

@@ -1,4 +1,4 @@
-import { TWO_POW_64 } from '@aztec/constants';
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, TWO_POW_64 } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { poseidon2Permutation } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
@@ -9,15 +9,22 @@ import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from
  */ export class SpongeBlob {
     sponge;
     numAbsorbedFields;
-    numExpectedFields;
-    constructor(/** Sponge with absorbed fields that will go into one or more blobs. */ sponge, /** Number of effects absorbed so far. */ numAbsorbedFields, /** Number of effects that will be absorbed. */ numExpectedFields){
+    static MAX_FIELDS = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+    constructor(/** Sponge with absorbed fields that will go into one or more blobs. */ sponge, /** Number of effects absorbed so far. */ numAbsorbedFields){
         this.sponge = sponge;
         this.numAbsorbedFields = numAbsorbedFields;
-        this.numExpectedFields = numExpectedFields;
+    }
+    /**
+   * Initialize the sponge blob to absorb data for a checkpoint.
+   */ static init() {
+        // This must match the implementation in noir-projects/noir-protocol-circuits/types/src/abis/sponge_blob.nr
+        const iv = new Fr(BigInt(SpongeBlob.MAX_FIELDS) * TWO_POW_64);
+        const sponge = Poseidon2Sponge.init(iv);
+        return new SpongeBlob(sponge, 0);
     }
     static fromBuffer(buffer) {
         const reader = BufferReader.asReader(buffer);
-        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber(), reader.readNumber());
+        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber());
     }
     toBuffer() {
         return serializeToBuffer(...SpongeBlob.getFields(this));
@@ -25,8 +32,7 @@ import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from
     static getFields(fields) {
         return [
             fields.sponge,
-            fields.numAbsorbedFields,
-            fields.numExpectedFields
+            fields.numAbsorbedFields
         ];
     }
     toFields() {
@@ -34,43 +40,23 @@ import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from
     }
     static fromFields(fields) {
         const reader = FieldReader.asReader(fields);
-        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readField().toNumber(), reader.readField().toNumber());
+        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readField().toNumber());
     }
     clone() {
         return SpongeBlob.fromBuffer(this.toBuffer());
     }
     async absorb(fields) {
-        if (this.numAbsorbedFields + fields.length > this.numExpectedFields) {
-            throw new Error(`Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${this.numExpectedFields}`);
+        if (this.numAbsorbedFields + fields.length > SpongeBlob.MAX_FIELDS) {
+            throw new Error(`Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${SpongeBlob.MAX_FIELDS}`);
         }
         await this.sponge.absorb(fields);
         this.numAbsorbedFields += fields.length;
     }
     async squeeze() {
-        // If the blob sponge is not 'full', we append 1 to match Poseidon2::hash_internal()
-        // NB: There is currently no use case in which we don't 'fill' a blob sponge, but adding for completeness
-        if (this.numAbsorbedFields != this.numExpectedFields) {
-            await this.sponge.absorb([
-                Fr.ONE
-            ]);
-        }
-        return this.sponge.squeeze();
+        return await this.sponge.squeeze();
     }
     static empty() {
-        return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
-    }
-    /**
-   * Initialize the sponge blob with the number of expected fields in the checkpoint and absorb it as the first field.
-   * Note: `numExpectedFields` includes the first field absorbed in this method.
-   */ static async init(numExpectedFields) {
-        // This must match what the checkpoint root rollup circuit expects.
-        // See noir-projects/noir-protocol-circuits/types/src/abis/sponge_blob.nr -> init_for_checkpoint.
-        const sponge = Poseidon2Sponge.init(numExpectedFields);
-        await sponge.absorb([
-            new Fr(numExpectedFields)
-        ]);
-        const numAbsorbedFields = 1;
-        return new SpongeBlob(sponge, numAbsorbedFields, numExpectedFields);
+        return new SpongeBlob(Poseidon2Sponge.empty(), 0);
     }
 }
 // This is just noir's stdlib version of the poseidon2 sponge. We use it for a blob-specific implmentation of the hasher.
@@ -110,8 +96,7 @@ export class Poseidon2Sponge {
     static empty() {
         return new Poseidon2Sponge(makeTuple(3, ()=>Fr.ZERO), makeTuple(4, ()=>Fr.ZERO), 0, false);
     }
-    static init(numExpectedFields) {
-        const iv = new Fr(numExpectedFields).mul(new Fr(TWO_POW_64));
+    static init(iv) {
         const sponge = Poseidon2Sponge.empty();
         sponge.state[3] = iv;
         return sponge;

package/dest/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D,cAAc,wBAAwB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEnD"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D,cAAc,wBAAwB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAUnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEnD"}

package/dest/testing.js

@@ -11,7 +11,7 @@ export * from './encoding/fixtures.js';
  * @param seed - The seed to use for generating the sponge.
  * @returns A sponge blob instance.
  */ export function makeSpongeBlob(seed = 1) {
-    return new SpongeBlob(new Poseidon2Sponge(makeTuple(3, (i)=>new Fr(i)), makeTuple(4, (i)=>new Fr(i)), 1, false), seed, seed + 1);
+    return new SpongeBlob(new Poseidon2Sponge(makeTuple(3, (i)=>new Fr(i)), makeTuple(4, (i)=>new Fr(i)), 1, false), seed);
 }
 /**
  * Makes arbitrary blob public accumulator.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/blob-lib",
-  "version": "3.0.0-nightly.20251120",
+  "version": "3.0.0-nightly.20251122",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -27,8 +27,8 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/constants": "3.0.0-nightly.20251120",
-    "@aztec/foundation": "3.0.0-nightly.20251120",
+    "@aztec/constants": "3.0.0-nightly.20251122",
+    "@aztec/foundation": "3.0.0-nightly.20251122",
     "@crate-crypto/node-eth-kzg": "^0.10.0",
     "tslib": "^2.4.0"
   },

package/src/blob_batching.ts

@@ -3,9 +3,9 @@ import { poseidon2Hash, sha256ToField } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
-import { computeBlobFieldsHashFromBlobs } from './blob_utils.js';
+import { getBlobsPerL1Block } from './blob_utils.js';
 import { BlobAccumulator, FinalBlobAccumulator, FinalBlobBatchingChallenges } from './circuit_types/index.js';
-import { computeEthVersionedBlobHash, hashNoirBigNumLimbs } from './hash.js';
+import { computeBlobFieldsHash, computeEthVersionedBlobHash, hashNoirBigNumLimbs } from './hash.js';
 import { kzg } from './kzg_context.js';
 
 /**
@@ -32,18 +32,19 @@ export class BatchedBlob {
    *
    * @returns A batched blob.
    */
-  static async batch(blobs: Blob[][]): Promise<BatchedBlob> {
-    if (blobs.length > AZTEC_MAX_EPOCH_DURATION) {
+  static async batch(blobFieldsPerCheckpoint: Fr[][]): Promise<BatchedBlob> {
+    const numCheckpoints = blobFieldsPerCheckpoint.length;
+    if (numCheckpoints > AZTEC_MAX_EPOCH_DURATION) {
       throw new Error(
-        `Too many blocks sent to batch(). The maximum is ${AZTEC_MAX_EPOCH_DURATION}. Got ${blobs.length}.`,
+        `Too many checkpoints sent to batch(). The maximum is ${AZTEC_MAX_EPOCH_DURATION}. Got ${numCheckpoints}.`,
       );
     }
 
     // Precalculate the values (z and gamma) and initialize the accumulator:
-    let acc = await this.newAccumulator(blobs);
+    let acc = await this.newAccumulator(blobFieldsPerCheckpoint);
     // Now we can create a multi opening proof of all input blobs:
-    for (const blockBlobs of blobs) {
-      acc = await acc.accumulateBlobs(blockBlobs);
+    for (const blobFields of blobFieldsPerCheckpoint) {
+      acc = await acc.accumulateFields(blobFields);
     }
     return await acc.finalize();
   }
@@ -53,8 +54,8 @@ export class BatchedBlob {
    * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
    *      beforehand from ALL blobs.
    */
-  static async newAccumulator(blobs: Blob[][]): Promise<BatchedBlobAccumulator> {
-    const finalBlobChallenges = await this.precomputeBatchedBlobChallenges(blobs);
+  static async newAccumulator(blobFieldsPerCheckpoint: Fr[][]): Promise<BatchedBlobAccumulator> {
+    const finalBlobChallenges = await this.precomputeBatchedBlobChallenges(blobFieldsPerCheckpoint);
     return BatchedBlobAccumulator.newWithChallenges(finalBlobChallenges);
   }
 
@@ -70,13 +71,15 @@ export class BatchedBlob {
    * @param blobs - The blobs to precompute the challenges for. Each sub-array is the blobs for an L1 block.
    * @returns Challenges z and gamma.
    */
-  static async precomputeBatchedBlobChallenges(blobs: Blob[][]): Promise<FinalBlobBatchingChallenges> {
+  static async precomputeBatchedBlobChallenges(blobFieldsPerCheckpoint: Fr[][]): Promise<FinalBlobBatchingChallenges> {
     // Compute the final challenge z to evaluate the blobs.
     let z: Fr | undefined;
-    for (const blockBlobs of blobs) {
+    const allBlobs = [];
+    for (const blobFields of blobFieldsPerCheckpoint) {
       // Compute the hash of all the fields in the block.
-      const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blockBlobs);
-      for (const blob of blockBlobs) {
+      const blobFieldsHash = await computeBlobFieldsHash(blobFields);
+      const blobs = getBlobsPerL1Block(blobFields);
+      for (const blob of blobs) {
         // Compute the challenge z for each blob and accumulate it.
         const challengeZ = await blob.computeChallengeZ(blobFieldsHash);
         if (!z) {
@@ -85,13 +88,13 @@ export class BatchedBlob {
           z = await poseidon2Hash([z, challengeZ]);
         }
       }
+      allBlobs.push(...blobs);
     }
     if (!z) {
       throw new Error('No blobs to precompute challenges for.');
     }
 
     // Now we have a shared challenge for all blobs, evaluate them...
-    const allBlobs = blobs.flat();
     const proofObjects = allBlobs.map(b => b.evaluate(z));
     const evaluations = await Promise.all(proofObjects.map(({ y }) => hashNoirBigNumLimbs(y)));
     // ...and find the challenge for the linear combination of blobs.
@@ -190,7 +193,7 @@ export class BatchedBlobAccumulator {
    * We assume the input blob has not been evaluated at z.
    * @returns An updated blob accumulator.
    */
-  private async accumulate(blob: Blob, blobFieldsHash: Fr) {
+  async accumulateBlob(blob: Blob, blobFieldsHash: Fr) {
     const { proof, y: thisY } = blob.evaluate(this.finalBlobChallenges.z);
     const thisC = BLS12Point.decompress(blob.commitment);
     const thisQ = BLS12Point.decompress(proof);
@@ -234,10 +237,12 @@ export class BatchedBlobAccumulator {
   /**
    * Given blobs, accumulate all state.
    * We assume the input blobs have not been evaluated at z.
-   * @param blobs - The blobs to accumulate. They should be for the same checkpoint.
+   * @param blobFields - The blob fields of a checkpoint to accumulate.
    * @returns An updated blob accumulator.
    */
-  async accumulateBlobs(blobs: Blob[]) {
+  async accumulateFields(blobFields: Fr[]) {
+    const blobs = getBlobsPerL1Block(blobFields);
+
     if (blobs.length > BLOBS_PER_CHECKPOINT) {
       throw new Error(
         `Too many blobs to accumulate. The maximum is ${BLOBS_PER_CHECKPOINT} per checkpoint. Got ${blobs.length}.`,
@@ -245,12 +250,12 @@ export class BatchedBlobAccumulator {
     }
 
     // Compute the hash of all the fields in the block.
-    const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blobs);
+    const blobFieldsHash = await computeBlobFieldsHash(blobFields);
 
     // Initialize the acc to iterate over:
     let acc: BatchedBlobAccumulator = this.clone();
     for (const blob of blobs) {
-      acc = await acc.accumulate(blob, blobFieldsHash);
+      acc = await acc.accumulateBlob(blob, blobFieldsHash);
     }
     return acc;
   }

package/src/blob_utils.ts

@@ -3,7 +3,7 @@ import { BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
 import { type CheckpointBlobData, decodeCheckpointBlobDataFromBuffer } from './encoding/index.js';
-import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
+import { computeBlobsHash } from './hash.js';
 
 /**
  * @param blobs - The blobs to emit.
@@ -49,16 +49,6 @@ export function decodeCheckpointBlobDataFromBlobs(blobs: Blob[]): CheckpointBlob
   return decodeCheckpointBlobDataFromBuffer(buf);
 }
 
-export async function computeBlobFieldsHashFromBlobs(blobs: Blob[]): Promise<Fr> {
-  const fields = blobs.map(b => b.toFields()).flat();
-  const numBlobFields = fields[0].toNumber();
-  if (numBlobFields > fields.length) {
-    throw new Error(`The prefix indicates ${numBlobFields} fields. Got ${fields.length}.`);
-  }
-
-  return await computeBlobFieldsHash(fields.slice(0, numBlobFields));
-}
-
 export function computeBlobsHashFromBlobs(blobs: Blob[]): Fr {
   return computeBlobsHash(blobs.map(b => b.getEthVersionedBlobHash()));
 }

package/src/encoding/block_blob_data.ts

@@ -15,7 +15,7 @@ import {
 } from './block_end_state_field.js';
 import { type TxBlobData, decodeTxBlobData, encodeTxBlobData } from './tx_blob_data.js';
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/block_merge/components/block_blob_data.nr`.
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
 
 export interface BlockEndBlobData {
   blockEndMarker: BlockEndMarker;

package/src/encoding/block_end_marker.ts

@@ -3,7 +3,7 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { BlobDeserializationError } from '../errors.js';
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/block_merge/components/block_blob_data.nr`.
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
 
 const BLOCK_NUMBER_BIT_SIZE = 32n;
 const TIMESTAMP_BIT_SIZE = 64n;

package/src/encoding/block_end_state_field.ts

@@ -8,7 +8,7 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { BlobDeserializationError } from '../errors.js';
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/block_merge/components/block_blob_data.nr`.
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
 
 export const TOTAL_MANA_USED_BIT_SIZE = 48n;
 

package/src/encoding/checkpoint_blob_data.ts

@@ -3,20 +3,32 @@ import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 
 import { BlobDeserializationError } from '../errors.js';
 import { type BlockBlobData, decodeBlockBlobData, encodeBlockBlobData } from './block_blob_data.js';
+import {
+  type CheckpointEndMarker,
+  decodeCheckpointEndMarker,
+  encodeCheckpointEndMarker,
+  isCheckpointEndMarker,
+} from './checkpoint_end_marker.js';
 import type { TxStartMarker } from './tx_start_marker.js';
 
 export interface CheckpointBlobData {
-  totalNumBlobFields: number;
+  checkpointEndMarker: CheckpointEndMarker;
   blocks: BlockBlobData[];
 }
 
 export function encodeCheckpointBlobData(checkpointBlobData: CheckpointBlobData): Fr[] {
   return [
-    new Fr(checkpointBlobData.totalNumBlobFields),
     ...checkpointBlobData.blocks.map(block => encodeBlockBlobData(block)).flat(),
+    encodeCheckpointEndMarker(checkpointBlobData.checkpointEndMarker),
   ];
 }
 
+export function encodeCheckpointBlobDataFromBlocks(blocks: BlockBlobData[]): Fr[] {
+  const blocksBlobFields = blocks.map(block => encodeBlockBlobData(block)).flat();
+  const numBlobFields = blocksBlobFields.length + 1; // +1 for the checkpoint end marker.
+  return blocksBlobFields.concat(encodeCheckpointEndMarker({ numBlobFields }));
+}
+
 export function decodeCheckpointBlobData(fields: Fr[] | FieldReader): CheckpointBlobData {
   const reader = FieldReader.asReader(fields);
 
@@ -24,52 +36,60 @@ export function decodeCheckpointBlobData(fields: Fr[] | FieldReader): Checkpoint
     throw new BlobDeserializationError(`Cannot decode empty blob data.`);
   }
 
-  const firstField = reader.readField();
-  // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error if the first field is
-  // larger than a javascript integer.
-  const totalNumBlobFields = firstField.toBigInt();
-  if (totalNumBlobFields > BigInt(reader.remainingFields() + 1)) {
-    // +1 because we already read the first field.
+  const blocks = [];
+  let checkpointEndMarker: CheckpointEndMarker | undefined;
+  while (!reader.isFinished() && !checkpointEndMarker) {
+    blocks.push(decodeBlockBlobData(reader, blocks.length === 0 /* isFirstBlock */));
+
+    // After reading a block, the next item must be either a checkpoint end marker or another block.
+    // The first field of a block is always a tx start marker. So if the provided fields are valid, it's not possible to
+    // misinterpret a tx start marker as checkpoint end marker, or vice versa.
+    const nextField = reader.peekField();
+    if (isCheckpointEndMarker(nextField)) {
+      checkpointEndMarker = decodeCheckpointEndMarker(reader.readField());
+      const numFieldsRead = reader.cursor;
+      if (numFieldsRead !== checkpointEndMarker.numBlobFields) {
+        throw new BlobDeserializationError(
+          `Incorrect encoding of blob fields: mismatch number of blob fields. Expected ${checkpointEndMarker.numBlobFields} fields, got ${numFieldsRead}.`,
+        );
+      }
+    }
+  }
+
+  if (!checkpointEndMarker) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: checkpoint end marker does not exist.`);
+  }
+
+  const remainingFields = reader.readFieldArray(reader.remainingFields());
+  if (!remainingFields.every(f => f.isZero())) {
     throw new BlobDeserializationError(
-      `Incorrect encoding of blob fields: not enough fields for checkpoint blob data. Expected ${totalNumBlobFields} fields, got ${reader.remainingFields() + 1}.`,
+      `Incorrect encoding of blob fields: unexpected non-zero field after checkpoint end marker.`,
     );
   }
 
-  const blocks = [];
-  while (reader.cursor < totalNumBlobFields) {
-    blocks.push(decodeBlockBlobData(reader, blocks.length === 0 /* isFirstBlock */));
-  }
   return {
-    totalNumBlobFields: Number(totalNumBlobFields),
+    checkpointEndMarker,
     blocks,
   };
 }
 
 export function decodeCheckpointBlobDataFromBuffer(buf: Buffer): CheckpointBlobData {
   const reader = BufferReader.asReader(buf);
-  const firstField = reader.readObject(Fr);
-
-  // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error if the first field is
-  // larger than a javascript integer.
-  const numFields = firstField.toBigInt();
-  const totalFieldsInBuffer = BigInt(buf.length / Fr.SIZE_IN_BYTES);
-  if (numFields > totalFieldsInBuffer) {
-    throw new BlobDeserializationError(
-      `Failed to deserialize blob buffer: not enough fields for checkpoint blob data. Expected ${numFields} fields, got ${totalFieldsInBuffer}.`,
-    );
-  }
-
-  const numFieldsWithoutPrefix = Number(numFields) - 1;
-  const blobFields = [firstField].concat(reader.readArray(numFieldsWithoutPrefix, Fr));
-
+  const totalFieldsInBuffer = Math.floor(buf.length / Fr.SIZE_IN_BYTES);
+  const blobFields = reader.readArray(totalFieldsInBuffer, Fr);
   return decodeCheckpointBlobData(blobFields);
 }
 
-export function getTotalNumBlobFieldsFromTxs(txs: TxStartMarker[][]): number {
+export function getTotalNumBlobFieldsFromTxs(txsPerBlock: TxStartMarker[][]): number {
+  const numBlocks = txsPerBlock.length;
+  if (!numBlocks) {
+    return 0;
+  }
+
   return (
-    1 + // totalNumBlobFields
-    (txs.length ? 1 : 0) + // l1ToL2Messages root in the first block
-    txs.length * 6 + // 6 fields for each block end blob data.
-    txs.reduce((total, txs) => total + txs.reduce((total, tx) => total + tx.numBlobFields, 0), 0)
+    (numBlocks ? 1 : 0) + // l1ToL2Messages root in the first block
+    numBlocks * 6 + // 6 fields for each block end blob data.
+    txsPerBlock.reduce((total, txs) => total + txs.reduce((total, tx) => total + tx.numBlobFields, 0), 0) +
+    1 // checkpoint end marker
   );
 }

package/src/encoding/checkpoint_end_marker.ts

@@ -0,0 +1,40 @@
+import { CHECKPOINT_END_PREFIX } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/checkpoint_blob_data.nr`.
+
+const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
+
+export interface CheckpointEndMarker {
+  numBlobFields: number;
+}
+
+export function encodeCheckpointEndMarker(checkpointEndMarker: CheckpointEndMarker) {
+  let value = CHECKPOINT_END_PREFIX;
+  value <<= NUM_BLOB_FIELDS_BIT_SIZE;
+  value += BigInt(checkpointEndMarker.numBlobFields);
+  return new Fr(value);
+}
+
+export function decodeCheckpointEndMarker(field: Fr): CheckpointEndMarker {
+  let value = field.toBigInt();
+  const numBlobFields = Number(value & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
+  value >>= NUM_BLOB_FIELDS_BIT_SIZE;
+
+  const prefix = value;
+  if (prefix !== CHECKPOINT_END_PREFIX) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid checkpoint end marker.`);
+  }
+
+  return {
+    numBlobFields,
+  };
+}
+
+// Check if a field is a checkpoint end marker. Used to check if it has reached the end of the blob fields.
+export function isCheckpointEndMarker(field: Fr): boolean {
+  const prefix = field.toBigInt() >> NUM_BLOB_FIELDS_BIT_SIZE;
+  return prefix === CHECKPOINT_END_PREFIX;
+}

package/src/encoding/fixtures.ts

@@ -198,12 +198,12 @@ export function makeCheckpointBlobData({
       seed,
     );
 
-  const totalNumBlobFields =
-    overrides.totalNumBlobFields ??
+  const numBlobFields =
+    overrides.checkpointEndMarker?.numBlobFields ??
     getTotalNumBlobFieldsFromTxs(blocks.map(block => block.txs.map(tx => tx.txStartMarker)));
 
   return {
-    totalNumBlobFields,
     blocks,
+    checkpointEndMarker: { numBlobFields },
   };
 }

package/src/encoding/index.ts

@@ -2,6 +2,7 @@ export * from './block_blob_data.js';
 export * from './block_end_marker.js';
 export * from './block_end_state_field.js';
 export * from './checkpoint_blob_data.js';
+export * from './checkpoint_end_marker.js';
 export * from './fixtures.js';
 export * from './tx_blob_data.js';
 export * from './tx_start_marker.js';

package/src/encoding/tx_blob_data.ts

@@ -5,7 +5,7 @@ import { FieldReader } from '@aztec/foundation/serialize';
 import { BlobDeserializationError } from '../errors.js';
 import { type TxStartMarker, decodeTxStartMarker, encodeTxStartMarker } from './tx_start_marker.js';
 
-// Must match the implementation in noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr.
+// Must match the implementation in noir-protocol-circuits/crates/types/src/blob_data/tx_blob_data.nr.
 
 export interface TxBlobData {
   txStartMarker: TxStartMarker;

package/src/encoding/tx_start_marker.ts

@@ -3,7 +3,7 @@ import { Fr } from '@aztec/foundation/fields';
 
 import { BlobDeserializationError } from '../errors.js';
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/tx_blob_data.nr`.
 
 const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
 const REVERT_CODE_BIT_SIZE = 8n;

package/src/hash.ts

@@ -2,6 +2,7 @@ import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
 import { BLS12Fr, Fr } from '@aztec/foundation/fields';
 
 import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, kzg } from './kzg_context.js';
+import { SpongeBlob } from './sponge_blob.js';
 
 const VERSIONED_HASH_VERSION_KZG = 0x01;
 
@@ -24,12 +25,21 @@ export function computeBlobsHash(evmVersionedBlobHashes: Buffer[]): Fr {
 }
 
 /**
- * The hash of the fields added throughout the checkpoint. The exact number of fields is specified by the checkpoint
- * prefix (the first field). It's verified in the circuit against the fields absorbed into the sponge blob.
- * This hash is used in generating the challenge z for all blobs in the same checkpoint.
+ * Computes a non-standard Poseidon2 hash over the provided fields.
+ *
+ * This function is used to compute:
+ * - `blobFieldsHash` of a checkpoint:
+ *   Verified in the circuit against all fields absorbed into the blob sponge over the entire checkpoint.
+ *   The exact number of fields is encoded in the checkpoint end marker (the last field).
+ *   This hash is used when generating the challenge `z` for all blobs in the checkpoint.
+ * - `spongeBlobHash` of a block:
+ *   Computed from the block's tx effects, its end-state, and the blob fields of all prior blocks in the same checkpoint.
+ *   This hash is included in the block header.
  */
 export async function computeBlobFieldsHash(fields: Fr[]): Promise<Fr> {
-  return await poseidon2Hash(fields);
+  const sponge = SpongeBlob.init();
+  await sponge.absorb(fields);
+  return sponge.squeeze();
 }
 
 export function computeBlobCommitment(data: Uint8Array): Buffer {