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

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/tx_start_marker.ts

@@ -0,0 +1,97 @@
+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;
+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 PRIVATE_LOGS_LENGTH_BIT_SIZE = 16n;
+const PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
+const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
+
+export interface TxStartMarker {
+  numBlobFields: number;
+  revertCode: number;
+  numNoteHashes: number;
+  numNullifiers: number;
+  numL2ToL1Msgs: number;
+  numPublicDataWrites: number;
+  numPrivateLogs: number;
+  privateLogsLength: number;
+  publicLogsLength: number;
+  contractClassLogLength: number;
+}
+
+export function encodeTxStartMarker(txStartMarker: TxStartMarker): Fr {
+  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 <<= 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;
+  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);
+}
+
+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 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));
+  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;
+
+  const prefix = value;
+  if (prefix !== TX_START_PREFIX) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid tx start marker.`);
+  }
+
+  return {
+    numBlobFields,
+    revertCode,
+    numNoteHashes,
+    numNullifiers,
+    numL2ToL1Msgs,
+    numPublicDataWrites,
+    numPrivateLogs,
+    privateLogsLength,
+    publicLogsLength,
+    contractClassLogLength,
+  };
+}

package/src/hash.ts

@@ -0,0 +1,89 @@
+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, getKzg } from './kzg_context.js';
+import { SpongeBlob } from './sponge_blob.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);
+}
+
+/**
+ * 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> {
+  const sponge = SpongeBlob.init();
+  await sponge.absorb(fields);
+  return sponge.squeeze();
+}
+
+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(getKzg().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 './batched_blob.js';
 export * from './blob.js';
 export * from './blob_batching.js';
-export * from './encoding.js';
+export * from './blob_utils.js';
+export * from './circuit_types/index.js';
+export * from './encoding/index.js';
+export * from './hash.js';
 export * from './interface.js';
-export * from './errors.js';
-export * from './blob_batching_public_inputs.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);
-  }
-}
+export * from './kzg_context.js';

package/src/interface.ts

@@ -3,6 +3,5 @@
  */
 export interface BlobJson {
   blob: string;
-  index: string;
   kzg_commitment: string;
 }

package/src/kzg_context.ts

@@ -0,0 +1,16 @@
+import { DasContextJs } from '@crate-crypto/node-eth-kzg';
+
+export * from '@crate-crypto/node-eth-kzg';
+
+let kzgInstance: DasContextJs | undefined;
+
+/**
+ * Returns the lazily-initialized KZG context.
+ * The first call takes ~3 seconds to initialize the precomputation tables.
+ */
+export function getKzg(): DasContextJs {
+  if (!kzgInstance) {
+    kzgInstance = DasContextJs.create({ usePrecomp: true });
+  }
+  return kzgInstance;
+}

package/src/sponge_blob.ts

@@ -1,6 +1,7 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, 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';
+import { poseidon2Permutation } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import {
   BufferReader,
   FieldReader,
@@ -10,30 +11,40 @@ 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 {
+  static MAX_FIELDS = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
   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,
-    /** Number of effects that will be absorbed. */
-    public readonly expectedFields: number,
+    public numAbsorbedFields: number,
   ) {}
 
+  /**
+   * Initialize the sponge blob to absorb data for a checkpoint.
+   */
+  static init(): SpongeBlob {
+    // This must match the implementation in noir-projects/noir-protocol-circuits/types/src/abis/sponge_blob.nr
+    const iv = new Fr(BigInt(SpongeBlob.MAX_FIELDS) * TWO_POW_64);
+    const sponge = Poseidon2Sponge.init(iv);
+    return new SpongeBlob(sponge, 0);
+  }
+
   static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob {
     const reader = BufferReader.asReader(buffer);
-    return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber(), reader.readNumber());
+    return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber());
   }
 
   toBuffer() {
-    return serializeToBuffer(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];
   }
 
   toFields(): Fr[] {
@@ -42,11 +53,7 @@ export class SpongeBlob {
 
   static fromFields(fields: Fr[] | FieldReader): SpongeBlob {
     const reader = FieldReader.asReader(fields);
-    return new SpongeBlob(
-      reader.readObject(Poseidon2Sponge),
-      reader.readField().toNumber(),
-      reader.readField().toNumber(),
-    );
+    return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readField().toNumber());
   }
 
   clone() {
@@ -54,30 +61,21 @@ export class SpongeBlob {
   }
 
   async absorb(fields: Fr[]) {
-    if (this.fields + fields.length > this.expectedFields) {
+    if (this.numAbsorbedFields + fields.length > SpongeBlob.MAX_FIELDS) {
       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 ${SpongeBlob.MAX_FIELDS}`,
       );
     }
     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) {
-      await this.sponge.absorb([Fr.ONE]);
-    }
-    return this.sponge.squeeze();
+    return await this.sponge.squeeze();
   }
 
   static empty(): SpongeBlob {
-    return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
-  }
-
-  static init(expectedFields: number): SpongeBlob {
-    return new SpongeBlob(Poseidon2Sponge.init(expectedFields), 0, expectedFields);
+    return new SpongeBlob(Poseidon2Sponge.empty(), 0);
   }
 }
 
@@ -131,8 +129,7 @@ export class Poseidon2Sponge {
     );
   }
 
-  static init(expectedFields: number): Poseidon2Sponge {
-    const iv = new Fr(expectedFields).mul(new Fr(BigInt('18446744073709551616')));
+  static init(iv: Fr): Poseidon2Sponge {
     const sponge = Poseidon2Sponge.empty();
     sponge.state[3] = iv;
     return sponge;

package/src/testing.ts

@@ -1,13 +1,15 @@
 import { makeTuple } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fq, BLS12Fr, BLS12Point, BLSPointNotOnCurveError } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 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 { BlobAccumulator } from './circuit_types/blob_accumulator.js';
+import { FinalBlobAccumulator } from './circuit_types/final_blob_accumulator.js';
+import { FinalBlobBatchingChallenges } from './circuit_types/final_blob_batching_challenges.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.
@@ -23,83 +25,70 @@ export function makeSpongeBlob(seed = 1): SpongeBlob {
       false,
     ),
     seed,
-    seed + 1,
   );
 }
 
 /**
- * Makes arbitrary blob public accumulator.
- * Note: will not verify inside the circuit.
- * @param seed - The seed to use for generating the blob accumulator.
- * @returns A blob accumulator instance.
+ * Makes an arbitrary but valid BLS12 point. The value is deterministic for a given seed.
+ * @param seed - The seed to use for generating the point.
+ * @returns A BLS12 point instance.
  */
-export function makeBatchedBlobAccumulator(seed = 1): BatchedBlobAccumulator {
-  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)),
-  );
+function makeBLS12Point(seed = 1): BLS12Point {
+  let accum = 0;
+  while (true) {
+    try {
+      const x = new BLS12Fq(seed + accum);
+      const y = BLS12Point.YFromX(x);
+      if (y) {
+        return new BLS12Point(x, y, false);
+      }
+      accum++;
+    } catch (e: any) {
+      if (!(e instanceof BLSPointNotOnCurveError)) {
+        throw e;
+      }
+      // The point is not on the curve - try again
+    }
+  }
 }
 
 /**
- * Makes arbitrary block blob public inputs.
+ * Makes arbitrary blob public accumulator.
  * 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.
+ * @param seed - The seed to use for generating the blob accumulator.
+ * @returns A blob accumulator 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 makeBlobAccumulator(seed = 1): BlobAccumulator {
+  return new BlobAccumulator(
+    new Fr(seed),
+    new Fr(seed + 0x10),
+    new BLS12Fr(seed + 0x20),
+    makeBLS12Point(seed + 0x30),
+    new Fr(seed + 0x50),
+    new BLS12Fr(seed + 0x60),
   );
 }
 
-// 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 makeFinalBlobAccumulator(seed = 1) {
+  return new FinalBlobAccumulator(
+    new Fr(seed),
+    new Fr(seed + 0x10),
+    new BLS12Fr(seed + 0x20),
+    makeBLS12Point(seed + 0x30),
   );
 }
 
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export function makeEncodedBlob(length: number): Promise<Blob> {
-  return Blob.fromFields([encodeFirstField(length + 1), ...Array.from({ length: length }, () => Fr.random())]);
+export function makeFinalBlobBatchingChallenges(seed = 1) {
+  return new FinalBlobBatchingChallenges(new Fr(seed), new BLS12Fr(seed + 0x10));
 }
 
 /**
- * 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,17 @@
+export * from './batched_blob.js';
+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[]];
+}