@aztec-labs/blob-lib 6.0.0-nightly.20260829

package/src/encoding/tx_blob_data.ts

@@ -0,0 +1,116 @@
+import { chunk } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FieldReader } from '@aztec-labs/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-labs/constants';
+import { Fr } from '@aztec-labs/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 = BigInt(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 !== BigInt(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/errors.ts

@@ -0,0 +1,6 @@
+export class BlobDeserializationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BlobDeserializationError';
+  }
+}

package/src/hash.ts

@@ -0,0 +1,94 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { sha256, sha256ToField } from '@aztec-labs/foundation/crypto/sha256';
+import { BLS12Fr } from '@aztec-labs/foundation/curves/bls12';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import { getBytesPerBlob, getBytesPerCommitment, 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 async function computeBlobCommitment(data: Uint8Array): Promise<Buffer> {
+  if (data.length !== getBytesPerBlob()) {
+    throw new Error(`Expected ${getBytesPerBlob()} bytes per blob. Got ${data.length}.`);
+  }
+
+  return Buffer.from(await getKzg().asyncBlobToKzgCommitment(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 !== getBytesPerCommitment()) {
+    throw new Error(`Expected ${getBytesPerCommitment()} bytes for blob commitment. Got ${commitment.length}.`);
+  }
+
+  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, getBytesPerCommitment()))];
+}
+
+export async function computeChallengeZ(blobFieldsHash: Fr, commitment: Buffer): Promise<Fr> {
+  const commitmentFields = commitmentToFields(commitment);
+  return await poseidon2HashWithSeparator(
+    [blobFieldsHash, commitmentFields[0], commitmentFields[1]],
+    DomainSeparator.BLOB_CHALLENGE_Z,
+  );
+}
+
+/**
+ * Hash the u128 limbs of a BLS field's noir bignum representation under the `BLOB_HASHED_Y_LIMBS` separator.
+ * Used to commit to blob evaluation values `y_i` before folding them into the gamma accumulator; mirrors the
+ * hash accumulation performed in the rollup circuits.
+ */
+export async function hashBlobYLimbs(field: BLS12Fr): Promise<Fr> {
+  const num = field.toNoirBigNum();
+  return await poseidon2HashWithSeparator(num.limbs.map(Fr.fromHexString), DomainSeparator.BLOB_HASHED_Y_LIMBS);
+}

package/src/index.ts

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

package/src/interface.ts

@@ -0,0 +1,7 @@
+/**
+ * The relevant parts of a response from https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
+ */
+export interface BlobJson {
+  blob: string;
+  kzg_commitment: string;
+}

package/src/kzg_context.ts

@@ -0,0 +1,48 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import { elapsedSync } from '@aztec-labs/foundation/timer';
+import type { DasContextJs } from '@crate-crypto/node-eth-kzg';
+import { createRequire } from 'module';
+
+// Re-export the type only. The native module is loaded lazily to avoid
+// creating a napi-rs CustomGC handle at import time, which keeps the
+// Node.js event loop alive and can deadlock process.exit().
+export type { DasContextJs } from '@crate-crypto/node-eth-kzg';
+
+let nativeModule: typeof import('@crate-crypto/node-eth-kzg') | undefined;
+
+/** Lazily loads the @crate-crypto/node-eth-kzg native module. */
+function loadNativeModule(): typeof import('@crate-crypto/node-eth-kzg') {
+  if (!nativeModule) {
+    const require = createRequire(import.meta.url);
+    nativeModule = require('@crate-crypto/node-eth-kzg') as typeof import('@crate-crypto/node-eth-kzg');
+  }
+  return nativeModule!;
+}
+
+// Ethereum blob constants, loaded lazily from the native module.
+// Values: BYTES_PER_BLOB=131072, BYTES_PER_COMMITMENT=48
+export function getBytesPerBlob(): number {
+  return loadNativeModule().BYTES_PER_BLOB;
+}
+
+export function getBytesPerCommitment(): number {
+  return loadNativeModule().BYTES_PER_COMMITMENT;
+}
+
+let kzgInstance: DasContextJs | undefined;
+
+/**
+ * Returns the lazily-initialized KZG context. The first call synchronously builds the
+ * precomputation tables (~2s locally, blocking the event loop; longer under constrained CPU), so
+ * callers on a latency-sensitive path should warm it ahead of time. Pass a logger to record how
+ * long that first build took.
+ * @param logger - Optional logger; when provided, the initial table build is timed and logged.
+ */
+export function getKzg(logger?: Logger): DasContextJs {
+  if (!kzgInstance) {
+    const [durationMs, instance] = elapsedSync(() => loadNativeModule().DasContextJs.create({ usePrecomp: true }));
+    kzgInstance = instance;
+    logger?.verbose(`Loaded KZG trusted setup`, { durationMs });
+  }
+  return kzgInstance;
+}

package/src/sponge_blob.ts

@@ -0,0 +1,175 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, TWO_POW_64 } from '@aztec-labs/constants';
+import { type FieldsOf, makeTuple } from '@aztec-labs/foundation/array';
+import { poseidon2Permutation } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import {
+  BufferReader,
+  FieldReader,
+  type Tuple,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec-labs/foundation/serialize';
+
+/**
+ * A Poseidon2 sponge used to accumulate data that will be added to blobs.
+ * See noir-projects/fnd/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr.
+ */
+export class SpongeBlob {
+  static MAX_FIELDS = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+
+  constructor(
+    /** Sponge with absorbed fields that will go into one or more blobs. */
+    public readonly sponge: Poseidon2Sponge,
+    /** Number of effects absorbed so far. */
+    public numAbsorbedFields: number,
+  ) {}
+
+  /**
+   * Initialize the sponge blob to absorb data for a checkpoint.
+   */
+  static init(): SpongeBlob {
+    // This must match the implementation in noir-projects/fnd/noir-protocol-circuits/crates/types/src/blob_data/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());
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...SpongeBlob.getFields(this));
+  }
+
+  static getFields(fields: FieldsOf<SpongeBlob>) {
+    return [fields.sponge, fields.numAbsorbedFields];
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...SpongeBlob.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): SpongeBlob {
+    const reader = FieldReader.asReader(fields);
+    return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readField().toNumber());
+  }
+
+  clone() {
+    return SpongeBlob.fromBuffer(this.toBuffer());
+  }
+
+  async absorb(fields: Fr[]) {
+    if (this.numAbsorbedFields + fields.length > SpongeBlob.MAX_FIELDS) {
+      throw new Error(
+        `Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${SpongeBlob.MAX_FIELDS}`,
+      );
+    }
+    await this.sponge.absorb(fields);
+    this.numAbsorbedFields += fields.length;
+  }
+
+  async squeeze(): Promise<Fr> {
+    return await this.sponge.squeeze();
+  }
+
+  static empty(): SpongeBlob {
+    return new SpongeBlob(Poseidon2Sponge.empty(), 0);
+  }
+}
+
+// This is just noir's stdlib version of the poseidon2 sponge. We use it for a blob-specific implmentation of the hasher.
+export class Poseidon2Sponge {
+  constructor(
+    public cache: Tuple<Fr, 3>,
+    public state: Tuple<Fr, 4>,
+    public cacheSize: number,
+    public squeezeMode: boolean,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): Poseidon2Sponge {
+    const reader = BufferReader.asReader(buffer);
+    return new Poseidon2Sponge(
+      reader.readArray(3, Fr),
+      reader.readArray(4, Fr),
+      reader.readNumber(),
+      reader.readBoolean(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.cache, this.state, this.cacheSize, this.squeezeMode);
+  }
+
+  static getFields(fields: FieldsOf<Poseidon2Sponge>) {
+    return [fields.cache, fields.state, fields.cacheSize, fields.squeezeMode];
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...Poseidon2Sponge.getFields(this));
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): Poseidon2Sponge {
+    const reader = FieldReader.asReader(fields);
+    return new Poseidon2Sponge(
+      reader.readFieldArray(3),
+      reader.readFieldArray(4),
+      reader.readField().toNumber(),
+      reader.readBoolean(),
+    );
+  }
+
+  static empty(): Poseidon2Sponge {
+    return new Poseidon2Sponge(
+      makeTuple(3, () => Fr.ZERO),
+      makeTuple(4, () => Fr.ZERO),
+      0,
+      false,
+    );
+  }
+
+  static init(iv: Fr): Poseidon2Sponge {
+    const sponge = Poseidon2Sponge.empty();
+    sponge.state[3] = iv;
+    return sponge;
+  }
+
+  // Note: there isn't currently an impl in ts that allows for a custom aborption via an
+  // existing sponge.
+  // A custom blob-based impl of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr
+  async performDuplex() {
+    for (let i = 0; i < this.cache.length; i++) {
+      if (i < this.cacheSize) {
+        this.state[i] = this.state[i].add(this.cache[i]);
+      }
+    }
+    const perm = await poseidon2Permutation(this.state);
+    // ts doesn't understand that the above always gives 4
+    this.state = [perm[0], perm[1], perm[2], perm[3]];
+  }
+
+  async absorb(fields: Fr[]) {
+    if (this.squeezeMode) {
+      throw new Error(`Poseidon sponge is not able to absorb more inputs.`);
+    }
+    for (const field of fields) {
+      if (this.cacheSize == this.cache.length) {
+        await this.performDuplex();
+        this.cache[0] = field;
+        this.cacheSize = 1;
+      } else {
+        this.cache[this.cacheSize++] = field;
+      }
+    }
+  }
+
+  async squeeze(): Promise<Fr> {
+    if (this.squeezeMode) {
+      throw new Error(`Poseidon sponge has already been squeezed.`);
+    }
+    await this.performDuplex();
+    this.squeezeMode = true;
+    return this.state[0];
+  }
+}

package/src/testing.ts

@@ -0,0 +1,94 @@
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { BLS12Fq, BLS12Fr, BLS12Point, BLSPointNotOnCurveError } from '@aztec-labs/foundation/curves/bls12';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import { Blob } from './blob.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.
+ * @param seed - The seed to use for generating the sponge.
+ * @returns A sponge blob instance.
+ */
+export function makeSpongeBlob(seed = 1): SpongeBlob {
+  return new SpongeBlob(
+    new Poseidon2Sponge(
+      makeTuple(3, i => new Fr(i)),
+      makeTuple(4, i => new Fr(i)),
+      1,
+      false,
+    ),
+    seed,
+  );
+}
+
+/**
+ * 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.
+ */
+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 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.
+ */
+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),
+  );
+}
+
+export function makeFinalBlobAccumulator(seed = 1) {
+  return new FinalBlobAccumulator(
+    new Fr(seed),
+    new Fr(seed + 0x10),
+    new BLS12Fr(seed + 0x20),
+    makeBLS12Point(seed + 0x30),
+  );
+}
+
+export function makeFinalBlobBatchingChallenges(seed = 1) {
+  return new FinalBlobBatchingChallenges(new Fr(seed), new BLS12Fr(seed + 0x10));
+}
+
+/**
+ * Make a blob with random fields.
+ *
+ * This will fail deserialisation in the archiver
+ * @param length
+ * @returns
+ */
+export function makeRandomBlob(length: number): Promise<Blob> {
+  return Blob.fromFields([...Array.from({ length: length }, () => Fr.random())]);
+}