@aztec/blob-lib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/encoding.ts

@@ -1,138 +1,154 @@
+import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { FieldReader } from '@aztec/foundation/serialize';
 
-import type { Blob as BlobBuffer } from 'c-kzg';
+const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
+const REVERT_CODE_BIT_SIZE = 8n;
+const NUM_NOTE_HASH_BIT_SIZE = 16n;
+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 PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
+const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
 
-// Note duplicated from stdlib !
-// This will appear as 0x74785f7374617274 in logs
-export const TX_START_PREFIX = 8392562855083340404n;
-// These are helper constants to decode tx effects from blob encoded fields
-export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
-// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
-export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
-export const REVERT_CODE_PREFIX = 1;
+export interface TxStartMarker {
+  prefix: bigint;
+  numBlobFields: number;
+  revertCode: number;
+  numNoteHashes: number;
+  numNullifiers: number;
+  numL2ToL1Msgs: number;
+  numPublicDataWrites: number;
+  numPrivateLogs: number;
+  publicLogsLength: number;
+  contractClassLogLength: number;
+}
 
-/**
- * Deserializes a blob buffer into an array of field elements.
- *
- * Blobs are converted into BN254 fields to perform a poseidon2 hash on them (fieldHash).
- * This method is sparse, meaning it does not include trailing zeros at the end of the blob.
- *
- * However, we cannot simply trim the zero's from the end of the blob, as some logs may include zero's
- * within them.
- * If we end on a set of zeros, such as the log below:
- * length 7: [ a, b, c, d, e, 0, 0]
- *
- * we will end up with the incorrect hash if we trim the zeros from the end.
- *
- * Each transactions logs contains a TX start prefix, which includes a string followed
- * by the length ( in field elements ) of the transaction's log.
- *
- * This function finds the end of the last transaction's logs, and returns the array up to this point.
- *
- * We search for a series of Tx Prefixes progressing the cursor in the field reader until we hit
- * a field that is not a Tx Prefix, this indicates that we have reached the end of the last transaction's logs.
- *
- * +------------------+------------------+------------------+------------------+
- * | TX1 Start Prefix | TX1 Log Fields   | TX2 Start Prefix | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                          ^
- *                                                          |
- * Function reads until here --------------------------------
- *
- * @param blob - The blob buffer to deserialize.
- * @returns An array of field elements.
- */
-export function deserializeEncodedBlobToFields(blob: BlobBuffer): Fr[] {
-  // Convert blob buffer to array of field elements
-  const reader = BufferReader.asReader(blob);
-  const array = reader.readArray(blob.length >> 5, Fr); // >> 5 = / 32 (bytes per field)
-  const fieldReader = FieldReader.asReader(array);
-
-  // Read fields until we hit zeros at the end
-  while (!fieldReader.isFinished()) {
-    const currentField = fieldReader.peekField();
-
-    // Stop when we hit a zero field
-    if (!currentField || currentField.isZero()) {
-      break;
-    }
+// 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'>) {
+  let value = TX_START_PREFIX;
+  value <<= NUM_NOTE_HASH_BIT_SIZE;
+  value += BigInt(txStartMarker.numNoteHashes);
+  value <<= NUM_NULLIFIER_BIT_SIZE;
+  value += BigInt(txStartMarker.numNullifiers);
+  value <<= NUM_L2_TO_L1_MSG_BIT_SIZE;
+  value += BigInt(txStartMarker.numL2ToL1Msgs);
+  value <<= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
+  value += BigInt(txStartMarker.numPublicDataWrites);
+  value <<= NUM_PRIVATE_LOG_BIT_SIZE;
+  value += BigInt(txStartMarker.numPrivateLogs);
+  value <<= PUBLIC_LOGS_LENGTH_BIT_SIZE;
+  value += BigInt(txStartMarker.publicLogsLength);
+  value <<= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
+  value += BigInt(txStartMarker.contractClassLogLength);
+  value <<= REVERT_CODE_BIT_SIZE;
+  value += BigInt(txStartMarker.revertCode);
+  value <<= NUM_BLOB_FIELDS_BIT_SIZE;
+  value += BigInt(txStartMarker.numBlobFields);
+  return new Fr(value);
+}
 
-    // Skip the remaining fields in this transaction
-    const len = getLengthFromFirstField(currentField);
-    fieldReader.skip(len);
-  }
+export function decodeTxStartMarker(field: Fr): TxStartMarker {
+  let value = field.toBigInt();
+  const numBlobFields = Number(value & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
+  value >>= NUM_BLOB_FIELDS_BIT_SIZE;
+  const revertCode = Number(value & (2n ** REVERT_CODE_BIT_SIZE - 1n));
+  value >>= REVERT_CODE_BIT_SIZE;
+  const contractClassLogLength = Number(value & (2n ** CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE - 1n));
+  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 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));
+  value >>= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
+  const numL2ToL1Msgs = Number(value & (2n ** NUM_L2_TO_L1_MSG_BIT_SIZE - 1n));
+  value >>= NUM_L2_TO_L1_MSG_BIT_SIZE;
+  const numNullifiers = Number(value & (2n ** NUM_NULLIFIER_BIT_SIZE - 1n));
+  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;
+  return {
+    prefix,
+    numBlobFields,
+    revertCode,
+    numNoteHashes,
+    numNullifiers,
+    numL2ToL1Msgs,
+    numPublicDataWrites,
+    numPrivateLogs,
+    publicLogsLength,
+    contractClassLogLength,
+  };
+}
 
-  // Return array up to last non-zero field
-  return array.slice(0, fieldReader.cursor);
+export function getNumBlobFieldsFromTxStartMarker(field: Fr) {
+  return Number(field.toBigInt() & (2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n));
 }
 
-/**
- * Get the length of the transaction from the first field.
- *
- * @param firstField - The first field of the transaction.
- * @returns The length of the transaction.
- *
- * @throws If the first field does not include the correct prefix - encoding invalid.
- */
-export function getLengthFromFirstField(firstField: Fr): number {
-  // Check that the first field includes the correct prefix
-  if (!isValidFirstField(firstField)) {
-    throw new Error('Invalid prefix');
-  }
-  const buf = firstField.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-  return new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber();
+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;
 }
 
 /**
- * Determines whether a field is the first field of a tx effect
+ * 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 isValidFirstField(field: Fr): boolean {
-  const buf = field.toBuffer();
-  if (
-    !buf
-      .subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH)
-      .equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))
-  ) {
-    return false;
-  }
-  const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-  if (
-    // Checking we start with the correct prefix...
-    !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) ||
-    // ...and include the revert code prefix..
-    sliced[sliced.length - 3] !== REVERT_CODE_PREFIX ||
-    // ...and the following revert code is valid.
-    sliced[sliced.length - 1] > 4
-  ) {
+export function checkBlobFieldsEncoding(blobFields: Fr[]) {
+  const reader = FieldReader.asReader(blobFields);
+
+  const checkpointPrefix = reader.readField();
+  if (checkpointPrefix.toBigInt() !== BigInt(blobFields.length)) {
     return false;
   }
-  return true;
-}
 
-/**
- * Extract the fields from a blob buffer, but do not take into account encoding
- * that will include trailing zeros.
- *
- * +------------------+------------------+------------------+------------------+
- * |                  |                  |                  | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                ^
- *                                                |
- * Function reads until here ----------------------
- */
-export function extractBlobFieldsFromBuffer(blob: BlobBuffer): Fr[] {
-  const reader = BufferReader.asReader(blob);
-  const array = reader.readArray(blob.length >> 5, Fr);
-
-  // Find the index of the last non-zero field
-  let lastNonZeroIndex = array.length - 1;
-  while (lastNonZeroIndex >= 0 && array[lastNonZeroIndex].isZero()) {
-    lastNonZeroIndex--;
+  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 the trimmed array
-  return array.slice(0, lastNonZeroIndex + 1);
+  return true;
 }

package/src/hash.ts

@@ -0,0 +1,77 @@
+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';
+
+const VERSIONED_HASH_VERSION_KZG = 0x01;
+
+/**
+ * Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+ */
+export function computeEthVersionedBlobHash(commitment: Buffer): Buffer {
+  const hash = sha256(commitment);
+  hash[0] = VERSIONED_HASH_VERSION_KZG;
+  return hash;
+}
+
+// TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
+// - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
+// - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+//   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
+// We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
+export function computeBlobsHash(evmVersionedBlobHashes: Buffer[]): Fr {
+  return sha256ToField(evmVersionedBlobHashes);
+}
+
+/**
+ * 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.
+ */
+export async function computeBlobFieldsHash(fields: Fr[]): Promise<Fr> {
+  return await poseidon2Hash(fields);
+}
+
+export function computeBlobCommitment(data: Uint8Array): Buffer {
+  if (data.length !== BYTES_PER_BLOB) {
+    throw new Error(`Expected ${BYTES_PER_BLOB} bytes per blob. Got ${data.length}.`);
+  }
+
+  return Buffer.from(kzg.blobToKzgCommitment(data));
+}
+
+/**
+ * Get the commitment fields of the blob, to compute the challenge z.
+ *
+ * The 48-byte commitment is encoded into two field elements:
+ * +-------------------+------------------------+
+ * |      31 bytes     |         17 bytes       |
+ * +-------------------+------------------------+
+ * |  Field Element 1  |     Field Element 2    |
+ * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+ * +-------------------+------------------------+
+ *
+ * @param commitment - The commitment to convert to fields. Computed from `computeBlobCommitment`.
+ * @returns The fields representing the commitment buffer.
+ */
+export function commitmentToFields(commitment: Buffer): [Fr, Fr] {
+  if (commitment.length !== BYTES_PER_COMMITMENT) {
+    throw new Error(`Expected ${BYTES_PER_COMMITMENT} bytes for blob commitment. Got ${commitment.length}.`);
+  }
+
+  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, BYTES_PER_COMMITMENT))];
+}
+
+export async function computeChallengeZ(blobFieldsHash: Fr, commitment: Buffer): Promise<Fr> {
+  const commitmentFields = commitmentToFields(commitment);
+  return await poseidon2Hash([blobFieldsHash, commitmentFields[0], commitmentFields[1]]);
+}
+
+/**
+ * Hash each u128 limb of the noir bignum struct representing the BLS field, to mimic the hash accumulation in the
+ * rollup circuits.
+ */
+export async function hashNoirBigNumLimbs(field: BLS12Fr): Promise<Fr> {
+  const num = field.toNoirBigNum();
+  return await poseidon2Hash(num.limbs.map(Fr.fromHexString));
+}

package/src/index.ts

@@ -1,23 +1,10 @@
-import cKzg from 'c-kzg';
-
-const { loadTrustedSetup } = cKzg;
-
 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 './interface.js';
 export * from './errors.js';
-export * from './blob_batching_public_inputs.js';
+export * from './hash.js';
+export * from './interface.js';
 export * from './sponge_blob.js';
-
-try {
-  loadTrustedSetup();
-} catch (error: any) {
-  if (error.message.includes('trusted setup is already loaded')) {
-    // NB: The c-kzg lib has no way of checking whether the setup is loaded or not,
-    // and it throws an error if it's already loaded, even though nothing is wrong.
-    // This is a rudimentary way of ensuring we load the trusted setup if we need it.
-  } else {
-    throw new Error(error);
-  }
-}

package/src/kzg_context.ts

@@ -0,0 +1,5 @@
+import { DasContextJs } from '@crate-crypto/node-eth-kzg';
+
+export * from '@crate-crypto/node-eth-kzg';
+
+export const kzg = DasContextJs.create({ usePrecomp: true });

package/src/sponge_blob.ts

@@ -1,3 +1,4 @@
+import { TWO_POW_64 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { poseidon2Permutation } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
@@ -10,17 +11,17 @@ import {
 } from '@aztec/foundation/serialize';
 
 /**
- * A Poseidon2 sponge used to accumulate data that will be added to a blob.
+ * A Poseidon2 sponge used to accumulate data that will be added to blobs.
  * See noir-projects/noir-protocol-circuits/crates/types/src/abis/sponge_blob.nr.
  */
 export class SpongeBlob {
   constructor(
-    /** Sponge with absorbed tx effects that will go into a blob. */
+    /** Sponge with absorbed fields that will go into one or more blobs. */
     public readonly sponge: Poseidon2Sponge,
     /** Number of effects absorbed so far. */
-    public fields: number,
+    public numAbsorbedFields: number,
     /** Number of effects that will be absorbed. */
-    public readonly expectedFields: number,
+    public readonly numExpectedFields: number,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob {
@@ -29,11 +30,11 @@ export class SpongeBlob {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.sponge, this.fields, this.expectedFields);
+    return serializeToBuffer(...SpongeBlob.getFields(this));
   }
 
   static getFields(fields: FieldsOf<SpongeBlob>) {
-    return [fields.sponge, fields.fields, fields.expectedFields];
+    return [fields.sponge, fields.numAbsorbedFields, fields.numExpectedFields];
   }
 
   toFields(): Fr[] {
@@ -54,19 +55,19 @@ export class SpongeBlob {
   }
 
   async absorb(fields: Fr[]) {
-    if (this.fields + fields.length > this.expectedFields) {
+    if (this.numAbsorbedFields + fields.length > this.numExpectedFields) {
       throw new Error(
-        `Attempted to fill spongeblob with ${this.fields + fields.length}, but it has a max of ${this.expectedFields}`,
+        `Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${this.numExpectedFields}`,
       );
     }
     await this.sponge.absorb(fields);
-    this.fields += fields.length;
+    this.numAbsorbedFields += fields.length;
   }
 
   async squeeze(): Promise<Fr> {
     // 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.fields != this.expectedFields) {
+    if (this.numAbsorbedFields != this.numExpectedFields) {
       await this.sponge.absorb([Fr.ONE]);
     }
     return this.sponge.squeeze();
@@ -76,8 +77,17 @@ export class SpongeBlob {
     return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
   }
 
-  static init(expectedFields: number): SpongeBlob {
-    return new SpongeBlob(Poseidon2Sponge.init(expectedFields), 0, expectedFields);
+  /**
+   * 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: number): Promise<SpongeBlob> {
+    // 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);
   }
 }
 
@@ -131,8 +141,8 @@ export class Poseidon2Sponge {
     );
   }
 
-  static init(expectedFields: number): Poseidon2Sponge {
-    const iv = new Fr(expectedFields).mul(new Fr(BigInt('18446744073709551616')));
+  static init(numExpectedFields: number): Poseidon2Sponge {
+    const iv = new Fr(numExpectedFields).mul(new Fr(TWO_POW_64));
     const sponge = Poseidon2Sponge.empty();
     sponge.state[3] = iv;
     return sponge;

package/src/testing.ts

@@ -1,11 +1,13 @@
+import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { randomInt } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
-import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-import { BlobAccumulatorPublicInputs, BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
-import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.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';
 
 /**
@@ -46,36 +48,44 @@ export function makeBatchedBlobAccumulator(seed = 1): BatchedBlobAccumulator {
   );
 }
 
-/**
- * Makes arbitrary block blob public inputs.
- * Note: will not verify inside the circuit.
- * @param seed - The seed to use for generating the blob inputs.
- * @returns A block blob public inputs instance.
- */
-export function makeBlockBlobPublicInputs(seed = 1): BlockBlobPublicInputs {
-  const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
-  return new BlockBlobPublicInputs(
-    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(startBlobAccumulator),
-    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 1)),
-    startBlobAccumulator.finalBlobChallenges,
-  );
+export function makeEncodedTxBlobFields(length: number): Fr[] {
+  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))), // -1 to account for the tx start marker.
+  ];
 }
 
-// TODO: copied form stdlib tx effect
-function encodeFirstField(length: number): Fr {
-  const lengthBuf = Buffer.alloc(2);
-  lengthBuf.writeUInt16BE(length, 0);
-  return new Fr(
-    Buffer.concat([
-      toBufferBE(TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH),
-      Buffer.alloc(1),
-      lengthBuf,
-      Buffer.alloc(1),
-      Buffer.from([1]),
-      Buffer.alloc(1),
-      Buffer.alloc(1),
-    ]),
-  );
+export function makeEncodedBlockBlobFields(...lengths: number[]): Fr[] {
+  return [
+    ...(lengths.length > 0 ? makeEncodedTxBlobFields(lengths[0] - 1) : []), // -1 to account for the block end marker.
+    ...lengths.slice(1).flatMap(length => makeEncodedTxBlobFields(length)),
+    createBlockEndMarker(lengths.length),
+  ];
+}
+
+// Create blob fields for a checkpoint with a single block.
+export function makeEncodedBlobFields(length: number): Fr[] {
+  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.
 }
 
 /**
@@ -85,21 +95,26 @@ function encodeFirstField(length: number): Fr {
  * @param length
  * @returns
  */
-export function makeEncodedBlob(length: number): Promise<Blob> {
-  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
+export function makeEncodedBlob(length: number): Blob {
+  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: number): Blob[] {
+  const fields = makeEncodedBlobFields(length);
+  return getBlobsPerL1Block(fields);
 }
 
 /**
- * Make an unencoded blob with the given length
+ * Make a blob with random fields.
  *
  * This will fail deserialisation in the archiver
  * @param length
  * @returns
  */
-export function makeUnencodedBlob(length: number): Promise<Blob> {
+export function makeRandomBlob(length: number): Blob {
   return Blob.fromFields([...Array.from({ length: length }, () => Fr.random())]);
 }
-
-export function makeEncodedBlobFields(fields: Fr[]): Promise<Blob> {
-  return Blob.fromFields([encodeFirstField(fields.length + 1), ...fields]);
-}

package/src/types.ts

@@ -0,0 +1,16 @@
+export * from './circuit_types/index.js';
+export * from './interface.js';
+export * from './sponge_blob.js';
+
+/**
+ * Type definition for the KZG instance returned by Blob.getViemKzgInstance().
+ * Contains the cryptographic functions needed for blob commitment and proof generation.
+ */
+export interface BlobKzgInstance {
+  /** Function to compute KZG commitment from blob data */
+  blobToKzgCommitment(blob: Uint8Array): Uint8Array;
+  /** Function to compute KZG proof for blob data */
+  computeBlobKzgProof(blob: Uint8Array, commitment: Uint8Array): Uint8Array;
+  /** Function to compute both blob data cells and their corresponding KZG proofs for EIP7594 */
+  computeCellsAndKzgProofs(blob: Uint8Array): [Uint8Array[], Uint8Array[]];
+}