@aztec/blob-lib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/circuit_types/final_blob_accumulator.ts

@@ -0,0 +1,76 @@
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+
+/**
+ * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_accumulator.nr` for documentation.
+ */
+export class FinalBlobAccumulator {
+  constructor(
+    public blobCommitmentsHash: Fr,
+    public z: Fr,
+    public y: BLS12Fr,
+    public c: BLS12Point,
+  ) {}
+
+  static empty(): FinalBlobAccumulator {
+    return new FinalBlobAccumulator(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): FinalBlobAccumulator {
+    const reader = BufferReader.asReader(buffer);
+    return new FinalBlobAccumulator(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      BLS12Fr.fromBuffer(reader),
+      BLS12Point.fromBuffer(reader),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.blobCommitmentsHash, this.z, this.y, this.c);
+  }
+
+  toFields() {
+    return [
+      this.blobCommitmentsHash,
+      this.z,
+      ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
+      ...this.c.toBN254Fields(),
+    ];
+  }
+
+  // The below is used to send to L1 for proof verification
+  toString() {
+    // We prepend 32 bytes for the (unused) 'blobHash' slot. This is not read or required by getEpochProofPublicInputs() on L1, but
+    // is expected since we usually pass the full precompile inputs via verifyEpochRootProof() to getEpochProofPublicInputs() to ensure
+    // we use calldata rather than a slice in memory:
+    const buf = Buffer.concat([Buffer.alloc(32), this.z.toBuffer(), this.y.toBuffer(), this.c.compress()]);
+    return buf.toString('hex');
+  }
+
+  equals(other: FinalBlobAccumulator) {
+    return (
+      this.blobCommitmentsHash.equals(other.blobCommitmentsHash) &&
+      this.z.equals(other.z) &&
+      this.y.equals(other.y) &&
+      this.c.equals(other.c)
+    );
+  }
+
+  // Creates a random instance. Used for testing only - will not prove/verify.
+  static random() {
+    return new FinalBlobAccumulator(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
+  }
+
+  [inspect.custom]() {
+    return `FinalBlobAccumulator {
+      blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
+      z: ${inspect(this.z)},
+      y: ${inspect(this.y)},
+      c: ${inspect(this.c)},
+    }`;
+  }
+}

package/src/circuit_types/final_blob_batching_challenges.ts

@@ -0,0 +1,30 @@
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+/**
+ * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_batching_challenges.nr` for documentation.
+ */
+export class FinalBlobBatchingChallenges {
+  constructor(
+    public readonly z: Fr,
+    public readonly gamma: BLS12Fr,
+  ) {}
+
+  equals(other: FinalBlobBatchingChallenges) {
+    return this.z.equals(other.z) && this.gamma.equals(other.gamma);
+  }
+
+  static empty(): FinalBlobBatchingChallenges {
+    return new FinalBlobBatchingChallenges(Fr.ZERO, BLS12Fr.ZERO);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): FinalBlobBatchingChallenges {
+    const reader = BufferReader.asReader(buffer);
+    return new FinalBlobBatchingChallenges(Fr.fromBuffer(reader), reader.readObject(BLS12Fr));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.z, this.gamma);
+  }
+}

package/src/circuit_types/index.ts

@@ -0,0 +1,4 @@
+/// Types used in the protocol circuits.
+export * from './blob_accumulator.js';
+export * from './final_blob_accumulator.js';
+export * from './final_blob_batching_challenges.js';

package/src/encoding/block_blob_data.ts

@@ -0,0 +1,102 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+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/types/src/blob_data/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,55 @@
+import { BLOCK_END_PREFIX } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+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/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: BlockNumber;
+  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 = 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/curves/bn254';
+
+import { BlobDeserializationError } from '../errors.js';
+
+// 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;
+
+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,
+  };
+}

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';