@aztec/blob-lib 3.0.0-nightly.20251113 → 3.0.0-nightly.20251115

package/dest/encoding/tx_blob_data.js

@@ -0,0 +1,79 @@
+import { chunk } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { BlobDeserializationError } from '../errors.js';
+import { decodeTxStartMarker, encodeTxStartMarker } from './tx_start_marker.js';
+export function encodeTxBlobData(txBlobData) {
+    return [
+        encodeTxStartMarker(txBlobData.txStartMarker),
+        txBlobData.txHash,
+        txBlobData.transactionFee,
+        ...txBlobData.noteHashes,
+        ...txBlobData.nullifiers,
+        ...txBlobData.l2ToL1Msgs,
+        ...txBlobData.publicDataWrites.flat(),
+        ...txBlobData.privateLogs.map((log)=>[
+                new Fr(log.length),
+                ...log
+            ]).flat(),
+        ...txBlobData.publicLogs,
+        ...txBlobData.contractClassLog
+    ];
+}
+export function decodeTxBlobData(fields) {
+    const reader = FieldReader.asReader(fields);
+    if (reader.isFinished()) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for tx blob data.`);
+    }
+    const txStartMarker = decodeTxStartMarker(reader.readField());
+    const checkRemainingFields = (requiredFields, type)=>{
+        if (requiredFields > reader.remainingFields()) {
+            throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for ${type}. Expected ${requiredFields} fields, only ${reader.remainingFields()} remaining.`);
+        }
+    };
+    const numTxEffectFields = txStartMarker.numBlobFields - 1; // -1 because we already read the tx start marker.
+    checkRemainingFields(numTxEffectFields, 'tx effect');
+    const txHash = reader.readField();
+    const transactionFee = reader.readField();
+    checkRemainingFields(txStartMarker.numNoteHashes, 'note hashes');
+    const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
+    checkRemainingFields(txStartMarker.numNullifiers, 'nullifiers');
+    const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
+    checkRemainingFields(txStartMarker.numL2ToL1Msgs, 'l2-to-l1 messages');
+    const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
+    checkRemainingFields(txStartMarker.numPublicDataWrites * 2, 'public data writes'); // *2 for leaf slot and value
+    const publicDataWrites = chunk(reader.readFieldArray(txStartMarker.numPublicDataWrites * 2), 2);
+    const privateLogs = Array.from({
+        length: txStartMarker.numPrivateLogs
+    }, ()=>{
+        const length = reader.readU32();
+        checkRemainingFields(length, 'private log');
+        return reader.readFieldArray(length);
+    });
+    checkRemainingFields(txStartMarker.publicLogsLength, 'public logs');
+    const publicLogs = reader.readFieldArray(txStartMarker.publicLogsLength);
+    const contractClassLogBlobDataLength = txStartMarker.contractClassLogLength > 0 ? txStartMarker.contractClassLogLength + 1 : 0; // If the log exists, +1 for the contract address
+    checkRemainingFields(contractClassLogBlobDataLength, 'contract class logs');
+    const contractClassLog = reader.readFieldArray(contractClassLogBlobDataLength);
+    return {
+        txStartMarker,
+        txHash,
+        transactionFee,
+        noteHashes,
+        nullifiers,
+        l2ToL1Msgs,
+        publicDataWrites,
+        privateLogs,
+        publicLogs,
+        contractClassLog
+    };
+}
+export function getNumTxBlobFields(txStartMarker) {
+    return 1 + // tx start marker
+    1 + // tx hash
+    1 + // transaction fee
+    txStartMarker.numNoteHashes + txStartMarker.numNullifiers + txStartMarker.numL2ToL1Msgs + txStartMarker.numPublicDataWrites * 2 + // *2 for leaf slot and value per public data write
+    txStartMarker.numPrivateLogs + // +1 length field for each private log
+    txStartMarker.privateLogsLength + txStartMarker.publicLogsLength + txStartMarker.contractClassLogLength + (txStartMarker.contractClassLogLength > 0 ? 1 : 0 // +1 for contract address of the contract class log
+    );
+}

package/dest/encoding/tx_start_marker.d.ts

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec/foundation/fields';
+export interface TxStartMarker {
+    numBlobFields: number;
+    revertCode: number;
+    numNoteHashes: number;
+    numNullifiers: number;
+    numL2ToL1Msgs: number;
+    numPublicDataWrites: number;
+    numPrivateLogs: number;
+    privateLogsLength: number;
+    publicLogsLength: number;
+    contractClassLogLength: number;
+}
+export declare function encodeTxStartMarker(txStartMarker: TxStartMarker): Fr;
+export declare function decodeTxStartMarker(field: Fr): TxStartMarker;
+//# sourceMappingURL=tx_start_marker.d.ts.map

package/dest/encoding/tx_start_marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_start_marker.d.ts","sourceRoot":"","sources":["../../src/encoding/tx_start_marker.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAiB9C,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,EAAE,CAuBpE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,EAAE,GAAG,aAAa,CAwC5D"}

package/dest/{encoding.js → encoding/tx_start_marker.js}

@@ -1,6 +1,7 @@
-import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
+import { TX_START_PREFIX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { FieldReader } from '@aztec/foundation/serialize';
+import { BlobDeserializationError } from '../errors.js';
+// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
 const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
 const REVERT_CODE_BIT_SIZE = 8n;
 const NUM_NOTE_HASH_BIT_SIZE = 16n;
@@ -8,9 +9,9 @@ const NUM_NULLIFIER_BIT_SIZE = 16n;
 const NUM_L2_TO_L1_MSG_BIT_SIZE = 16n;
 const NUM_PUBLIC_DATA_WRITE_BIT_SIZE = 16n;
 const NUM_PRIVATE_LOG_BIT_SIZE = 16n;
+const PRIVATE_LOGS_LENGTH_BIT_SIZE = 16n;
 const PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
 const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
 export function encodeTxStartMarker(txStartMarker) {
     let value = TX_START_PREFIX;
     value <<= NUM_NOTE_HASH_BIT_SIZE;
@@ -23,6 +24,8 @@ export function encodeTxStartMarker(txStartMarker) {
     value += BigInt(txStartMarker.numPublicDataWrites);
     value <<= NUM_PRIVATE_LOG_BIT_SIZE;
     value += BigInt(txStartMarker.numPrivateLogs);
+    value <<= PRIVATE_LOGS_LENGTH_BIT_SIZE;
+    value += BigInt(txStartMarker.privateLogsLength);
     value <<= PUBLIC_LOGS_LENGTH_BIT_SIZE;
     value += BigInt(txStartMarker.publicLogsLength);
     value <<= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
@@ -43,6 +46,8 @@ export function decodeTxStartMarker(field) {
     value >>= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
     const publicLogsLength = Number(value & 2n ** PUBLIC_LOGS_LENGTH_BIT_SIZE - 1n);
     value >>= PUBLIC_LOGS_LENGTH_BIT_SIZE;
+    const privateLogsLength = Number(value & 2n ** PRIVATE_LOGS_LENGTH_BIT_SIZE - 1n);
+    value >>= PRIVATE_LOGS_LENGTH_BIT_SIZE;
     const numPrivateLogs = Number(value & 2n ** NUM_PRIVATE_LOG_BIT_SIZE - 1n);
     value >>= NUM_PRIVATE_LOG_BIT_SIZE;
     const numPublicDataWrites = Number(value & 2n ** NUM_PUBLIC_DATA_WRITE_BIT_SIZE - 1n);
@@ -53,11 +58,11 @@ export function decodeTxStartMarker(field) {
     value >>= NUM_NULLIFIER_BIT_SIZE;
     const numNoteHashes = Number(value & 2n ** NUM_NOTE_HASH_BIT_SIZE - 1n);
     value >>= NUM_NOTE_HASH_BIT_SIZE;
-    // Do not throw if the prefix doesn't match.
-    // The caller function can check it by calling `isValidTxStartMarker`, and decide what to do if it's incorrect.
     const prefix = value;
+    if (prefix !== TX_START_PREFIX) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid tx start marker.`);
+    }
     return {
-        prefix,
         numBlobFields,
         revertCode,
         numNoteHashes,
@@ -65,59 +70,8 @@ export function decodeTxStartMarker(field) {
         numL2ToL1Msgs,
         numPublicDataWrites,
         numPrivateLogs,
+        privateLogsLength,
         publicLogsLength,
         contractClassLogLength
     };
 }
-export function getNumBlobFieldsFromTxStartMarker(field) {
-    return Number(field.toBigInt() & 2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n);
-}
-export function isValidTxStartMarker(txStartMarker) {
-    return txStartMarker.prefix === TX_START_PREFIX;
-}
-export function createBlockEndMarker(numTxs) {
-    // Must match the implementation in `block_rollup_public_inputs_composer.nr > create_block_end_marker`.
-    return new Fr(BLOCK_END_PREFIX * 256n * 256n + BigInt(numTxs));
-}
-export function getNumTxsFromBlockEndMarker(field) {
-    return Number(field.toBigInt() & 0xffffn);
-}
-export function isBlockEndMarker(field) {
-    const value = field.toBigInt();
-    const numTxs = value & 0xffffn;
-    return value - numTxs === BLOCK_END_PREFIX * 256n * 256n;
-}
-/**
- * Check that the fields are emitted from the circuits and conform to the encoding.
- * @param blobFields - The concatenated fields from all blobs of an L1 block.
- */ export function checkBlobFieldsEncoding(blobFields) {
-    const reader = FieldReader.asReader(blobFields);
-    const checkpointPrefix = reader.readField();
-    if (checkpointPrefix.toBigInt() !== BigInt(blobFields.length)) {
-        return false;
-    }
-    const numFieldsInCheckpoint = checkpointPrefix.toNumber();
-    let seenNumTxs = 0;
-    while(reader.cursor < numFieldsInCheckpoint){
-        const currentField = reader.readField();
-        if (isBlockEndMarker(currentField)) {
-            // Found a block end marker. Confirm that the number of txs in this block is correct.
-            const numTxs = getNumTxsFromBlockEndMarker(currentField);
-            if (numTxs !== seenNumTxs) {
-                return false;
-            }
-            seenNumTxs = 0;
-            continue;
-        }
-        // If the field is not a block end marker, it must be a tx start marker.
-        const txStartMarker = decodeTxStartMarker(currentField);
-        if (!isValidTxStartMarker(txStartMarker)) {
-            return false;
-        }
-        seenNumTxs += 1;
-        // Skip the remaining fields in this tx. -1 because we already read the tx start marker.
-        reader.skip(txStartMarker.numBlobFields - 1);
-    // TODO: Check the encoding of the tx if we want to be more strict.
-    }
-    return true;
-}

package/dest/index.d.ts

@@ -2,8 +2,7 @@ export * from './blob.js';
 export * from './blob_batching.js';
 export * from './blob_utils.js';
 export * from './circuit_types/index.js';
-export * from './deserialize.js';
-export * from './encoding.js';
+export * from './encoding/index.js';
 export * from './errors.js';
 export * from './hash.js';
 export * from './interface.js';

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}

package/dest/index.js

@@ -2,8 +2,7 @@ export * from './blob.js';
 export * from './blob_batching.js';
 export * from './blob_utils.js';
 export * from './circuit_types/index.js';
-export * from './deserialize.js';
-export * from './encoding.js';
+export * from './encoding/index.js';
 export * from './errors.js';
 export * from './hash.js';
 export * from './interface.js';

package/dest/testing.d.ts

@@ -1,7 +1,7 @@
-import { Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
 import { BatchedBlobAccumulator } from './blob_batching.js';
 import { SpongeBlob } from './sponge_blob.js';
+export * from './encoding/fixtures.js';
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
  * Note: will not verify inside the circuit.
@@ -16,18 +16,6 @@ export declare function makeSpongeBlob(seed?: number): SpongeBlob;
  * @returns A blob accumulator instance.
  */
 export declare function makeBatchedBlobAccumulator(seed?: number): BatchedBlobAccumulator;
-export declare function makeEncodedTxBlobFields(length: number): Fr[];
-export declare function makeEncodedBlockBlobFields(...lengths: number[]): Fr[];
-export declare function makeEncodedBlobFields(length: number): Fr[];
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export declare function makeEncodedBlob(length: number): Blob;
-export declare function makeEncodedBlobs(length: number): Blob[];
 /**
  * Make a blob with random fields.
  *

package/dest/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAuB,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAI5D,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,EAAE,CAoB5D;AAED,wBAAgB,0BAA0B,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAMrE;AAGD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,EAAE,CAO1D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAMpD;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,CAGvD;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,CAWnD;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

@@ -1,13 +1,10 @@
-import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { randomInt } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
 import { BatchedBlobAccumulator } from './blob_batching.js';
-import { getBlobsPerL1Block } from './blob_utils.js';
 import { FinalBlobBatchingChallenges } from './circuit_types/index.js';
-import { createBlockEndMarker, encodeTxStartMarker } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
+export * from './encoding/fixtures.js';
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
  * Note: will not verify inside the circuit.
@@ -24,62 +21,6 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
  */ export function makeBatchedBlobAccumulator(seed = 1) {
     return new BatchedBlobAccumulator(new Fr(seed), new Fr(seed + 1), new BLS12Fr(seed + 2), BLS12Point.random(), BLS12Point.random(), new Fr(seed + 3), new BLS12Fr(seed + 4), new FinalBlobBatchingChallenges(new Fr(seed + 5), new BLS12Fr(seed + 6)));
 }
-export function makeEncodedTxBlobFields(length) {
-    const txStartMarker = {
-        numBlobFields: length,
-        // The rest of the values don't matter. The test components using it do not try to deserialize everything.
-        // Only `checkBlobFieldsEncoding` is used and it only looks at `numBlobFields`. This might change in the future
-        // when we add more thorough checks to `checkBlobFieldsEncoding`.
-        revertCode: 0,
-        numNoteHashes: 0,
-        numNullifiers: 0,
-        numL2ToL1Msgs: 0,
-        numPublicDataWrites: 0,
-        numPrivateLogs: 0,
-        publicLogsLength: 0,
-        contractClassLogLength: 0
-    };
-    return [
-        encodeTxStartMarker(txStartMarker),
-        ...Array.from({
-            length: length - 1
-        }, ()=>new Fr(randomInt(Number.MAX_SAFE_INTEGER)))
-    ];
-}
-export function makeEncodedBlockBlobFields(...lengths) {
-    return [
-        ...lengths.length > 0 ? makeEncodedTxBlobFields(lengths[0] - 1) : [],
-        ...lengths.slice(1).flatMap((length)=>makeEncodedTxBlobFields(length)),
-        createBlockEndMarker(lengths.length)
-    ];
-}
-// Create blob fields for a checkpoint with a single block.
-export function makeEncodedBlobFields(length) {
-    if (length <= 2) {
-        throw new Error('Encoded blob fields length must be greater than 2');
-    }
-    const checkpointPrefix = new Fr(length);
-    return [
-        checkpointPrefix,
-        ...makeEncodedBlockBlobFields(length - 1)
-    ]; // -1 to account for the checkpoint prefix.
-}
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */ export function makeEncodedBlob(length) {
-    if (length > FIELDS_PER_BLOB) {
-        throw new Error(`A single encoded blob must be less than ${FIELDS_PER_BLOB} fields`);
-    }
-    return Blob.fromFields(makeEncodedBlobFields(length));
-}
-export function makeEncodedBlobs(length) {
-    const fields = makeEncodedBlobFields(length);
-    return getBlobsPerL1Block(fields);
-}
 /**
  * Make a blob with random fields.
  *

package/package.json

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

package/src/blob_utils.ts

@@ -2,7 +2,7 @@ import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
-import { deserializeEncodedBlobToFields } from './deserialize.js';
+import { type CheckpointBlobData, decodeCheckpointBlobDataFromBuffer } from './encoding/index.js';
 import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
 
 /**
@@ -40,16 +40,13 @@ export function getBlobsPerL1Block(fields: Fr[]): Blob[] {
 }
 
 /**
- * Get the fields from all blobs in the checkpoint. Ignoring the fields beyond the length specified by the
- * checkpoint prefix (the first field).
- *
- * @param blobs - The blobs to read fields from. Should be all the blobs in the L1 block proposing the checkpoint.
- * @param checkEncoding - Whether to check if the entire encoded blob fields are valid. If false, it will still check
- * the checkpoint prefix and throw if there's not enough fields.
- * @returns The fields added throughout the checkpoint.
+ * Get the encoded data from all blobs in the checkpoint.
+ * @param blobs - The blobs to read data from. Should be all the blobs for the L1 block proposing the checkpoint.
+ * @returns The encoded data of the checkpoint.
  */
-export function getBlobFieldsInCheckpoint(blobs: Blob[], checkEncoding = false): Fr[] {
-  return deserializeEncodedBlobToFields(Buffer.concat(blobs.map(b => b.data)), checkEncoding);
+export function decodeCheckpointBlobDataFromBlobs(blobs: Blob[]): CheckpointBlobData {
+  const buf = Buffer.concat(blobs.map(b => b.data));
+  return decodeCheckpointBlobDataFromBuffer(buf);
 }
 
 export async function computeBlobFieldsHashFromBlobs(blobs: Blob[]): Promise<Fr> {

package/src/encoding/block_blob_data.ts

@@ -0,0 +1,102 @@
+import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
+
+import { BlobDeserializationError } from '../errors.js';
+import {
+  type BlockEndMarker,
+  decodeBlockEndMarker,
+  encodeBlockEndMarker,
+  isBlockEndMarker,
+} from './block_end_marker.js';
+import {
+  type BlockEndStateField,
+  decodeBlockEndStateField,
+  encodeBlockEndStateField,
+} 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`.
+
+export interface BlockEndBlobData {
+  blockEndMarker: BlockEndMarker;
+  blockEndStateField: BlockEndStateField;
+  lastArchiveRoot: Fr;
+  noteHashRoot: Fr;
+  nullifierRoot: Fr;
+  publicDataRoot: Fr;
+  l1ToL2MessageRoot: Fr | undefined;
+}
+
+export interface BlockBlobData extends BlockEndBlobData {
+  txs: TxBlobData[];
+}
+
+export function encodeBlockEndBlobData(blockEndBlobData: BlockEndBlobData): Fr[] {
+  return [
+    encodeBlockEndMarker(blockEndBlobData.blockEndMarker),
+    encodeBlockEndStateField(blockEndBlobData.blockEndStateField),
+    blockEndBlobData.lastArchiveRoot,
+    blockEndBlobData.noteHashRoot,
+    blockEndBlobData.nullifierRoot,
+    blockEndBlobData.publicDataRoot,
+    ...(blockEndBlobData.l1ToL2MessageRoot ? [blockEndBlobData.l1ToL2MessageRoot] : []),
+  ];
+}
+
+export function decodeBlockEndBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockEndBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  const numBlockEndData = isFirstBlock ? 7 : 6;
+  if (numBlockEndData > reader.remainingFields()) {
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: not enough fields for block end data. Expected ${numBlockEndData} fields, only ${reader.remainingFields()} remaining.`,
+    );
+  }
+
+  return {
+    blockEndMarker: decodeBlockEndMarker(reader.readField()),
+    blockEndStateField: decodeBlockEndStateField(reader.readField()),
+    lastArchiveRoot: reader.readField(),
+    noteHashRoot: reader.readField(),
+    nullifierRoot: reader.readField(),
+    publicDataRoot: reader.readField(),
+    l1ToL2MessageRoot: isFirstBlock ? reader.readField() : undefined,
+  };
+}
+
+export function encodeBlockBlobData(blockBlobData: BlockBlobData): Fr[] {
+  return [...blockBlobData.txs.map(tx => encodeTxBlobData(tx)).flat(), ...encodeBlockEndBlobData(blockBlobData)];
+}
+
+export function decodeBlockBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockBlobData {
+  const reader = FieldReader.asReader(fields);
+
+  const txs: TxBlobData[] = [];
+  let hasReachedBlockEnd = false;
+  while (!hasReachedBlockEnd) {
+    if (reader.isFinished()) {
+      throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for block end marker.`);
+    }
+
+    const currentField = reader.peekField();
+    if (isBlockEndMarker(currentField)) {
+      hasReachedBlockEnd = true;
+    } else {
+      txs.push(decodeTxBlobData(reader));
+    }
+  }
+
+  const blockEndBlobData = decodeBlockEndBlobData(reader, isFirstBlock);
+
+  const blockEndMarker = blockEndBlobData.blockEndMarker;
+  if (blockEndMarker.numTxs !== txs.length) {
+    throw new BlobDeserializationError(
+      `Incorrect encoding of blob fields: expected ${blockEndMarker.numTxs} txs, but got ${txs.length}.`,
+    );
+  }
+
+  return {
+    txs,
+    ...blockEndBlobData,
+  };
+}

package/src/encoding/block_end_marker.ts

@@ -0,0 +1,54 @@
+import { BLOCK_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/rollup-lib/src/block_merge/components/block_blob_data.nr`.
+
+const BLOCK_NUMBER_BIT_SIZE = 32n;
+const TIMESTAMP_BIT_SIZE = 64n;
+const NUM_TXS_BIT_SIZE = 16n;
+
+export interface BlockEndMarker {
+  timestamp: bigint;
+  blockNumber: number;
+  numTxs: number;
+}
+
+export function encodeBlockEndMarker(blockEndMarker: BlockEndMarker) {
+  let value = BLOCK_END_PREFIX;
+  value <<= TIMESTAMP_BIT_SIZE;
+  value += blockEndMarker.timestamp;
+  value <<= BLOCK_NUMBER_BIT_SIZE;
+  value += BigInt(blockEndMarker.blockNumber);
+  value <<= NUM_TXS_BIT_SIZE;
+  value += BigInt(blockEndMarker.numTxs);
+  return new Fr(value);
+}
+
+export function decodeBlockEndMarker(field: Fr): BlockEndMarker {
+  let value = field.toBigInt();
+  const numTxs = Number(value & (2n ** NUM_TXS_BIT_SIZE - 1n));
+  value >>= NUM_TXS_BIT_SIZE;
+  const blockNumber = Number(value & (2n ** BLOCK_NUMBER_BIT_SIZE - 1n));
+  value >>= BLOCK_NUMBER_BIT_SIZE;
+  const timestamp = value & (2n ** TIMESTAMP_BIT_SIZE - 1n);
+  value >>= TIMESTAMP_BIT_SIZE;
+
+  const prefix = value;
+  if (prefix !== BLOCK_END_PREFIX) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid block end marker.`);
+  }
+
+  return {
+    blockNumber,
+    timestamp,
+    numTxs,
+  };
+}
+
+// Check if a field is a block end marker. Used before decoding to check if it has reached the end of the block.
+export function isBlockEndMarker(field: Fr): boolean {
+  const prefix = field.toBigInt() >> (NUM_TXS_BIT_SIZE + BLOCK_NUMBER_BIT_SIZE + TIMESTAMP_BIT_SIZE);
+  return prefix === BLOCK_END_PREFIX;
+}

package/src/encoding/block_end_state_field.ts

@@ -0,0 +1,59 @@
+import {
+  L1_TO_L2_MSG_TREE_HEIGHT,
+  NOTE_HASH_TREE_HEIGHT,
+  NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+} from '@aztec/constants';
+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`.
+
+export const TOTAL_MANA_USED_BIT_SIZE = 48n;
+
+export interface BlockEndStateField {
+  l1ToL2MessageNextAvailableLeafIndex: number;
+  noteHashNextAvailableLeafIndex: number;
+  nullifierNextAvailableLeafIndex: number;
+  publicDataNextAvailableLeafIndex: number;
+  totalManaUsed: bigint;
+}
+
+export function encodeBlockEndStateField(blockEndStateField: BlockEndStateField) {
+  let value = BigInt(blockEndStateField.l1ToL2MessageNextAvailableLeafIndex);
+  value <<= BigInt(NOTE_HASH_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.noteHashNextAvailableLeafIndex);
+  value <<= BigInt(NULLIFIER_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.nullifierNextAvailableLeafIndex);
+  value <<= BigInt(PUBLIC_DATA_TREE_HEIGHT);
+  value += BigInt(blockEndStateField.publicDataNextAvailableLeafIndex);
+  value <<= BigInt(TOTAL_MANA_USED_BIT_SIZE);
+  value += BigInt(blockEndStateField.totalManaUsed);
+  return new Fr(value);
+}
+
+export function decodeBlockEndStateField(field: Fr): BlockEndStateField {
+  let value = field.toBigInt();
+  const totalManaUsed = value & (2n ** TOTAL_MANA_USED_BIT_SIZE - 1n);
+  value >>= TOTAL_MANA_USED_BIT_SIZE;
+  const publicDataNextAvailableLeafIndex = Number(value & (2n ** BigInt(PUBLIC_DATA_TREE_HEIGHT) - 1n));
+  value >>= BigInt(PUBLIC_DATA_TREE_HEIGHT);
+  const nullifierNextAvailableLeafIndex = Number(value & (2n ** BigInt(NULLIFIER_TREE_HEIGHT) - 1n));
+  value >>= BigInt(NULLIFIER_TREE_HEIGHT);
+  const noteHashNextAvailableLeafIndex = Number(value & (2n ** BigInt(NOTE_HASH_TREE_HEIGHT) - 1n));
+  value >>= BigInt(NOTE_HASH_TREE_HEIGHT);
+
+  if (value > 2n ** BigInt(L1_TO_L2_MSG_TREE_HEIGHT) - 1n) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid block end state field.`);
+  }
+  const l1ToL2MessageNextAvailableLeafIndex = Number(value);
+
+  return {
+    l1ToL2MessageNextAvailableLeafIndex,
+    noteHashNextAvailableLeafIndex,
+    nullifierNextAvailableLeafIndex,
+    publicDataNextAvailableLeafIndex,
+    totalManaUsed,
+  };
+}