@aztec/blob-lib 3.0.0-devnet.2 → 3.0.0-devnet.20251212

package/src/encoding/checkpoint_blob_data.ts

@@ -0,0 +1,95 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+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 {
+  checkpointEndMarker: CheckpointEndMarker;
+  blocks: BlockBlobData[];
+}
+
+export function encodeCheckpointBlobData(checkpointBlobData: CheckpointBlobData): Fr[] {
+  return [
+    ...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);
+
+  if (reader.isFinished()) {
+    throw new BlobDeserializationError(`Cannot decode empty blob data.`);
+  }
+
+  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: unexpected non-zero field after checkpoint end marker.`,
+    );
+  }
+
+  return {
+    checkpointEndMarker,
+    blocks,
+  };
+}
+
+export function decodeCheckpointBlobDataFromBuffer(buf: Buffer): CheckpointBlobData {
+  const reader = BufferReader.asReader(buf);
+  const totalFieldsInBuffer = Math.floor(buf.length / Fr.SIZE_IN_BYTES);
+  const blobFields = reader.readArray(totalFieldsInBuffer, Fr);
+  return decodeCheckpointBlobData(blobFields);
+}
+
+export function getTotalNumBlobFieldsFromTxs(txsPerBlock: TxStartMarker[][]): number {
+  const numBlocks = txsPerBlock.length;
+  if (!numBlocks) {
+    return 0;
+  }
+
+  return (
+    (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/curves/bn254';
+
+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

@@ -0,0 +1,210 @@
+import {
+  FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PRIVATE_LOGS_PER_TX,
+  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  PRIVATE_LOG_SIZE_IN_FIELDS,
+} from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { BlockBlobData, BlockEndBlobData } from './block_blob_data.js';
+import type { BlockEndMarker } from './block_end_marker.js';
+import type { BlockEndStateField } from './block_end_state_field.js';
+import { type CheckpointBlobData, getTotalNumBlobFieldsFromTxs } from './checkpoint_blob_data.js';
+import { type TxBlobData, getNumTxBlobFields } from './tx_blob_data.js';
+import type { TxStartMarker } from './tx_start_marker.js';
+
+const fr = (seed: number) => new Fr(BigInt(seed));
+
+export function makeTxStartMarker({
+  isFullTx = false,
+  ...overrides
+}: { isFullTx?: boolean } & Partial<TxStartMarker> = {}): TxStartMarker {
+  const partialTxStartMarker = {
+    revertCode: 0,
+    numNoteHashes: isFullTx ? MAX_NOTE_HASHES_PER_TX : 1,
+    numNullifiers: isFullTx ? MAX_NULLIFIERS_PER_TX : 1,
+    numL2ToL1Msgs: isFullTx ? MAX_L2_TO_L1_MSGS_PER_TX : 1,
+    numPublicDataWrites: isFullTx ? MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX : 1,
+    numPrivateLogs: isFullTx ? MAX_PRIVATE_LOGS_PER_TX : 1,
+    privateLogsLength: isFullTx ? PRIVATE_LOG_SIZE_IN_FIELDS * MAX_PRIVATE_LOGS_PER_TX : 1,
+    publicLogsLength: isFullTx ? FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH : 1,
+    contractClassLogLength: isFullTx ? MAX_CONTRACT_CLASS_LOGS_PER_TX : 1,
+    ...overrides,
+  };
+
+  const numBlobFields = overrides.numBlobFields ?? getNumTxBlobFields(partialTxStartMarker);
+  return {
+    ...partialTxStartMarker,
+    numBlobFields,
+  };
+}
+
+export function makeTxBlobData({
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: { isFullTx?: boolean; seed?: number } & Partial<
+  Omit<TxBlobData, 'txStartMarker'> & { txStartMarker?: Partial<TxStartMarker> }
+> = {}): TxBlobData {
+  const { txStartMarker: txStartMarkerOverrides, ...txBlobDataOverrides } = overrides;
+  const txStartMarker = makeTxStartMarker({ isFullTx, ...txStartMarkerOverrides });
+
+  const noteHashes = makeTuple(txStartMarker.numNoteHashes, fr, seed);
+  const nullifiers = makeTuple(txStartMarker.numNullifiers, fr, seed + 0x100);
+  const l2ToL1Msgs = makeTuple(txStartMarker.numL2ToL1Msgs, fr, seed + 0x200);
+  const publicDataWrites = makeTuple(
+    txStartMarker.numPublicDataWrites,
+    i => [fr(seed + i * 2), fr(seed + i * 2 + 1)] satisfies [Fr, Fr],
+    seed + 0x300,
+  );
+
+  const privateLogs = [];
+  if (txStartMarker.privateLogsLength > txStartMarker.numPrivateLogs * PRIVATE_LOG_SIZE_IN_FIELDS) {
+    throw new Error('Private logs length is too large');
+  }
+  if (txStartMarker.privateLogsLength < txStartMarker.numPrivateLogs) {
+    throw new Error('Private logs length is too small');
+  }
+  let remainingNumPrivateLogs = txStartMarker.numPrivateLogs;
+  let remainingPrivateLogsLength = txStartMarker.privateLogsLength;
+  for (let i = 0; i < txStartMarker.numPrivateLogs; i++) {
+    const minLength = Math.max(
+      1,
+      remainingPrivateLogsLength - (remainingNumPrivateLogs - 1) * PRIVATE_LOG_SIZE_IN_FIELDS,
+    );
+    const length = Math.max(minLength, Math.floor(remainingPrivateLogsLength / remainingNumPrivateLogs));
+    privateLogs.push(makeTuple(length, fr, seed + 0x400 + i * PRIVATE_LOG_SIZE_IN_FIELDS));
+    remainingNumPrivateLogs -= 1;
+    remainingPrivateLogsLength -= length;
+  }
+
+  const publicLogs = makeTuple(txStartMarker.publicLogsLength, fr, seed + 0x500);
+  const contractClassLogBlobDataLength =
+    txStartMarker.contractClassLogLength > 0 ? txStartMarker.contractClassLogLength + 1 : 0; // If the log exists, +1 for the contract address
+  const contractClassLog = makeTuple(contractClassLogBlobDataLength, fr, seed + 0x600);
+
+  return {
+    txStartMarker,
+    txHash: fr(seed + 0x700),
+    transactionFee: fr(seed + 0x800),
+    noteHashes,
+    nullifiers,
+    l2ToL1Msgs,
+    publicDataWrites,
+    privateLogs,
+    publicLogs,
+    contractClassLog,
+    ...txBlobDataOverrides,
+  };
+}
+
+export function makeBlockEndMarker({
+  seed = 1,
+  ...overrides
+}: { seed?: number } & Partial<BlockEndMarker> = {}): BlockEndMarker {
+  return {
+    numTxs: seed,
+    blockNumber: BlockNumber(seed + 1),
+    timestamp: BigInt(seed + 2),
+    ...overrides,
+  };
+}
+
+export function makeBlockEndStateField({
+  seed = 1,
+  ...overrides
+}: { seed?: number } & Partial<BlockEndStateField> = {}): BlockEndStateField {
+  return {
+    l1ToL2MessageNextAvailableLeafIndex: seed,
+    noteHashNextAvailableLeafIndex: seed + 0x10,
+    nullifierNextAvailableLeafIndex: seed + 0x20,
+    publicDataNextAvailableLeafIndex: seed + 0x30,
+    totalManaUsed: BigInt(seed + 0x40),
+    ...overrides,
+  };
+}
+
+export function makeBlockEndBlobData({
+  isFirstBlock = true,
+  seed = 1,
+  ...overrides
+}: { seed?: number; isFirstBlock?: boolean } & Partial<
+  Omit<BlockEndBlobData, 'blockEndMarker' | 'blockEndStateField'>
+> & {
+    blockEndMarker?: Partial<BlockEndMarker>;
+    blockEndStateField?: Partial<BlockEndStateField>;
+  } = {}): BlockEndBlobData {
+  const {
+    blockEndMarker: blockEndMarkerOverrides,
+    blockEndStateField: blockEndStateFieldOverrides,
+    ...blockEndBlobDataOverrides
+  } = overrides;
+  return {
+    blockEndMarker: makeBlockEndMarker({ seed, ...blockEndMarkerOverrides }),
+    blockEndStateField: makeBlockEndStateField({ seed: seed + 0x100, ...blockEndStateFieldOverrides }),
+    lastArchiveRoot: fr(seed + 0x200),
+    noteHashRoot: fr(seed + 0x300),
+    nullifierRoot: fr(seed + 0x400),
+    publicDataRoot: fr(seed + 0x500),
+    l1ToL2MessageRoot: isFirstBlock ? fr(seed + 0x600) : undefined,
+    ...blockEndBlobDataOverrides,
+  };
+}
+
+export function makeBlockBlobData({
+  numTxs = 1,
+  isFirstBlock = true,
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: { numTxs?: number; isFirstBlock?: boolean; isFullTx?: boolean; seed?: number } & Partial<
+  Parameters<typeof makeBlockEndBlobData>[0]
+> = {}): BlockBlobData {
+  return {
+    txs: makeTuple(numTxs, i => makeTxBlobData({ isFullTx, seed: seed + i * 0x100 }), seed),
+    ...makeBlockEndBlobData({
+      seed: seed + 0x1000 * numTxs,
+      blockEndMarker: {
+        numTxs,
+      },
+      isFirstBlock,
+      ...overrides,
+    }),
+  };
+}
+
+export function makeCheckpointBlobData({
+  numBlocks = 1,
+  numTxsPerBlock = 1,
+  isFullTx = false,
+  seed = 1,
+  ...overrides
+}: {
+  numBlocks?: number;
+  numTxsPerBlock?: number;
+  isFullTx?: boolean;
+  seed?: number;
+} & Partial<CheckpointBlobData> = {}): CheckpointBlobData {
+  const blocks =
+    overrides.blocks ??
+    makeTuple(
+      numBlocks,
+      i => makeBlockBlobData({ numTxs: numTxsPerBlock, isFirstBlock: i === seed, isFullTx, seed: seed + i * 0x1000 }),
+      seed,
+    );
+
+  const numBlobFields =
+    overrides.checkpointEndMarker?.numBlobFields ??
+    getTotalNumBlobFieldsFromTxs(blocks.map(block => block.txs.map(tx => tx.txStartMarker)));
+
+  return {
+    blocks,
+    checkpointEndMarker: { numBlobFields },
+  };
+}

package/src/encoding/index.ts

@@ -0,0 +1,9 @@
+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';
+export { BlobDeserializationError } from '../errors.js';

package/src/encoding/tx_blob_data.ts

@@ -0,0 +1,116 @@
+import { chunk } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+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/types/src/blob_data/tx_blob_data.nr.
+
+export interface TxBlobData {
+  txStartMarker: TxStartMarker;
+  txHash: Fr;
+  transactionFee: Fr;
+  noteHashes: Fr[];
+  nullifiers: Fr[];
+  l2ToL1Msgs: Fr[];
+  publicDataWrites: [Fr, Fr][];
+  privateLogs: Fr[][];
+  publicLogs: Fr[];
+  contractClassLog: Fr[];
+}
+
+export function encodeTxBlobData(txBlobData: TxBlobData): Fr[] {
+  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: Fr[] | FieldReader): TxBlobData {
+  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: number, type: string) => {
+    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) as [Fr, Fr][];
+
+  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: Omit<TxStartMarker, 'revertCode' | 'numBlobFields'>) {
+  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/src/{encoding.ts → encoding/tx_start_marker.ts}

@@ -1,6 +1,9 @@
-import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { FieldReader } from '@aztec/foundation/serialize';
+import { TX_START_PREFIX } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// 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;
@@ -9,11 +12,11 @@ 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;
 
 export interface TxStartMarker {
-  prefix: bigint;
   numBlobFields: number;
   revertCode: number;
   numNoteHashes: number;
@@ -21,12 +24,12 @@ export interface TxStartMarker {
   numL2ToL1Msgs: number;
   numPublicDataWrites: number;
   numPrivateLogs: number;
+  privateLogsLength: number;
   publicLogsLength: number;
   contractClassLogLength: number;
 }
 
-// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
-export function encodeTxStartMarker(txStartMarker: Omit<TxStartMarker, 'prefix'>) {
+export function encodeTxStartMarker(txStartMarker: TxStartMarker): Fr {
   let value = TX_START_PREFIX;
   value <<= NUM_NOTE_HASH_BIT_SIZE;
   value += BigInt(txStartMarker.numNoteHashes);
@@ -38,6 +41,8 @@ export function encodeTxStartMarker(txStartMarker: Omit<TxStartMarker, 'prefix'>
   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;
@@ -59,6 +64,8 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
   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));
@@ -69,11 +76,13 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
   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,
@@ -81,74 +90,8 @@ export function decodeTxStartMarker(field: Fr): TxStartMarker {
     numL2ToL1Msgs,
     numPublicDataWrites,
     numPrivateLogs,
+    privateLogsLength,
     publicLogsLength,
     contractClassLogLength,
   };
 }
-
-export function getNumBlobFieldsFromTxStartMarker(field: Fr) {
-  return Number(field.toBigInt() & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
-}
-
-export function isValidTxStartMarker(txStartMarker: TxStartMarker) {
-  return txStartMarker.prefix === TX_START_PREFIX;
-}
-
-export function createBlockEndMarker(numTxs: number) {
-  // 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: Fr) {
-  return Number(field.toBigInt() & 0xffffn);
-}
-
-export function isBlockEndMarker(field: Fr) {
-  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: Fr[]) {
-  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 the loop to process the next field.
-      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/src/hash.ts

@@ -1,7 +1,10 @@
-import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
-import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { sha256, sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
-import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, kzg } from './kzg_context.js';
+import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, getKzg } from './kzg_context.js';
+import { SpongeBlob } from './sponge_blob.js';
 
 const VERSIONED_HASH_VERSION_KZG = 0x01;
 
@@ -24,12 +27,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 {
@@ -37,7 +49,7 @@ export function computeBlobCommitment(data: Uint8Array): Buffer {
     throw new Error(`Expected ${BYTES_PER_BLOB} bytes per blob. Got ${data.length}.`);
   }
 
-  return Buffer.from(kzg.blobToKzgCommitment(data));
+  return Buffer.from(getKzg().blobToKzgCommitment(data));
 }
 
 /**

package/src/index.ts

@@ -1,10 +1,10 @@
+export * from './batched_blob.js';
 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 './errors.js';
+export * from './encoding/index.js';
 export * from './hash.js';
 export * from './interface.js';
 export * from './sponge_blob.js';
+export * from './kzg_context.js';