@aztec/blob-lib 0.0.0-test.0 → 0.0.1-commit.21caa21

package/src/hash.ts

@@ -0,0 +1,87 @@
+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';
+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(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,9 @@
-import cKzg from 'c-kzg';
-
-/* eslint-disable import/no-named-as-default-member */
-const { loadTrustedSetup } = cKzg;
-
+export * from './batched_blob.js';
 export * from './blob.js';
-export * from './encoding.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 './errors.js';
-export * from './blob_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);
-  }
-}

package/src/interface.ts

@@ -3,9 +3,6 @@
  */
 export interface BlobJson {
   blob: string;
-  index?: number;
-  // eslint-disable-next-line camelcase
+  index: string;
   kzg_commitment: string;
-  // eslint-disable-next-line camelcase
-  kzg_proof: string;
 }

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 { 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';
@@ -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,14 @@
-import { BLOBS_PER_BLOCK } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
-import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { BLS12Fq, BLS12Fr, BLS12Point, BLSPointNotOnCurveError, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
-import { BlobPublicInputs, BlockBlobPublicInputs } from './blob_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,73 +24,70 @@ export function makeSpongeBlob(seed = 1): SpongeBlob {
       false,
     ),
     seed,
-    seed + 1,
   );
 }
 
 /**
- * Makes arbitrary blob public inputs.
- * Note: will not verify inside the circuit.
- * @param seed - The seed to use for generating the blob inputs.
- * @returns A blob public inputs 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 makeBlobPublicInputs(seed = 1): BlobPublicInputs {
-  return new BlobPublicInputs(
-    new Fr(seed),
-    BigInt(seed + 1),
-    makeTuple(2, i => new Fr(i)),
-  );
+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 {
-  return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, () => makeBlobPublicInputs(seed)));
+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]);
-}