@aztec/blob-lib 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/dest/blob.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import cKzg from 'c-kzg';
 import type { Blob as BlobBuffer } from 'c-kzg';
 import type { BlobJson } from './interface.js';
 export declare const VERSIONED_HASH_VERSION_KZG = 1;
+/** Versioned blob hash for an empty blob */
+export declare const EMPTY_BLOB_VERSIONED_HASH: Buffer<ArrayBuffer>;
 /**
  * A class to create, manage, and prove EVM blobs.
  */
@@ -14,27 +14,19 @@ export declare class Blob {
     readonly data: BlobBuffer;
     /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
     readonly fieldsHash: Fr;
-    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts). */
     readonly challengeZ: Fr;
-    /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
-    readonly evaluationY: Buffer;
     /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
     readonly commitment: Buffer;
-    /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
-    readonly proof: Buffer;
     constructor(
     /** The blob to be broadcast on L1 in bytes form. */
     data: BlobBuffer, 
     /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
     fieldsHash: Fr, 
-    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts). */
     challengeZ: Fr, 
-    /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
-    evaluationY: Buffer, 
     /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
-    commitment: Buffer, 
-    /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
-    proof: Buffer);
+    commitment: Buffer);
     /**
      * The encoded version of the blob will determine the end of the blob based on the transaction encoding.
      * This is required when the fieldsHash of a blob will contain trailing zeros.
@@ -77,7 +69,7 @@ export declare class Blob {
      * @param index - optional - The index of the blob in the block.
      * @returns The JSON representation of the blob.
      */
-    toJson(index?: number): BlobJson;
+    toJson(index: number): BlobJson;
     /**
      * Get the fields from the blob.
      *
@@ -119,6 +111,19 @@ export declare class Blob {
     commitmentToFields(): [Fr, Fr];
     getEthVersionedBlobHash(): Buffer;
     static getEthVersionedBlobHash(commitment: Buffer): Buffer;
+    /**
+     * Evaluate the blob at a given challenge and return the evaluation and KZG proof.
+     *
+     * @param challengeZ - The challenge z at which to evaluate the blob. If not given, assume we want to evaluate at the individual blob's z.
+     *
+     * @returns -
+     *  y: Buffer -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts
+     *  proof: Buffer - KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes).
+     */
+    evaluate(challengeZ?: Fr): {
+        y: Buffer<ArrayBuffer>;
+        proof: Buffer<ArrayBuffer>;
+    };
     /**
      * Get the buffer representation of the ENTIRE blob.
      *
@@ -141,22 +146,22 @@ export declare class Blob {
      */
     getSize(): number;
     /**
-     * Returns a proof of opening of the blob to verify on L1 using the point evaluation precompile:
-     *
-     * input[:32]     - versioned_hash
-     * input[32:64]   - z
-     * input[64:96]   - y
-     * input[96:144]  - commitment C
-     * input[144:192] - proof (a commitment to the quotient polynomial q(X))
-     *
-     * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+     * @param blobs - The blobs to emit
+     * @returns The blobs' compressed commitments in hex prefixed by the number of blobs
+     * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs:
+     * One byte for the number blobs + 48 bytes per blob commitment
      */
-    getEthBlobEvaluationInputs(): `0x${string}`;
-    static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}`;
+    static getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}`;
     static getViemKzgInstance(): {
         blobToKzgCommitment: typeof cKzg.blobToKzgCommitment;
         computeBlobKzgProof: typeof cKzg.computeBlobKzgProof;
+        computeCellsAndKzgProofs: typeof cKzg.computeCellsAndKzgProofs;
     };
-    static getBlobs(fields: Fr[]): Promise<Blob[]>;
+    /**
+     * @param fields - Fields to broadcast in the blob(s)
+     * @returns As many blobs as we require to broadcast the given fields for a block
+     * @dev Assumes we share the fields hash between all blobs which can only be done for ONE BLOCK because the hash is calculated in block root.
+     */
+    static getBlobsPerBlock(fields: Fr[]): Promise<Blob[]>;
 }
 //# sourceMappingURL=blob.d.ts.map

package/dest/blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,IAAI,MAAM,OAAO,CAAC;AACzB,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,OAAO,CAAC;AAIhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAM/C,eAAO,MAAM,0BAA0B,IAAO,CAAC;AAE/C;;GAEG;AACH,qBAAa,IAAI;IAEb,oDAAoD;aACpC,IAAI,EAAE,UAAU;IAChC,6IAA6I;aAC7H,UAAU,EAAE,EAAE;IAC9B,sFAAsF;aACtE,UAAU,EAAE,EAAE;IAC9B,sHAAsH;aACtG,WAAW,EAAE,MAAM;IACnC,kFAAkF;aAClE,UAAU,EAAE,MAAM;IAClC,iIAAiI;aACjH,KAAK,EAAE,MAAM;;IAX7B,oDAAoD;IACpC,IAAI,EAAE,UAAU;IAChC,6IAA6I;IAC7H,UAAU,EAAE,EAAE;IAC9B,sFAAsF;IACtE,UAAU,EAAE,EAAE;IAC9B,sHAAsH;IACtG,WAAW,EAAE,MAAM;IACnC,kFAAkF;IAClE,UAAU,EAAE,MAAM;IAClC,iIAAiI;IACjH,KAAK,EAAE,MAAM;IAG/B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,mBAAmB,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvF;;;;;;OAMG;WACU,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,mBAAmB,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB9E;;;;;;;;;;;OAWG;WACU,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAepD;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ;IAWhC;;;;;;OAMG;IACH,QAAQ,IAAI,EAAE,EAAE;IAIhB;;;;;;;;OAQG;IACH,eAAe,IAAI,EAAE,EAAE;IAUvB;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;IAU3C;;;;;;;;;;;OAWG;IACH,kBAAkB,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAK9B,uBAAuB,IAAI,MAAM;IAMjC,MAAM,CAAC,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAM1D;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM;IAiBlB;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAYnD;;OAEG;IACH,OAAO;IAIP;;;;;;;;;;OAUG;IACH,0BAA0B,IAAI,KAAK,MAAM,EAAE;IAW3C,MAAM,CAAC,0BAA0B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE;IAmB/D,MAAM,CAAC,kBAAkB;;;;WASZ,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;CAUrD"}
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,IAAI,MAAM,OAAO,CAAC;AACzB,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,OAAO,CAAC;AAIhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAK/C,eAAO,MAAM,0BAA0B,IAAO,CAAC;AAE/C,4CAA4C;AAC5C,eAAO,MAAM,yBAAyB,qBAGrC,CAAC;AAEF;;GAEG;AACH,qBAAa,IAAI;IAEb,oDAAoD;aACpC,IAAI,EAAE,UAAU;IAChC,6IAA6I;aAC7H,UAAU,EAAE,EAAE;IAC9B,0JAA0J;aAC1I,UAAU,EAAE,EAAE;IAC9B,kFAAkF;aAClE,UAAU,EAAE,MAAM;;IAPlC,oDAAoD;IACpC,IAAI,EAAE,UAAU;IAChC,6IAA6I;IAC7H,UAAU,EAAE,EAAE;IAC9B,0JAA0J;IAC1I,UAAU,EAAE,EAAE;IAC9B,kFAAkF;IAClE,UAAU,EAAE,MAAM;IAGpC;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,mBAAmB,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWvF;;;;;;OAMG;WACU,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,mBAAmB,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB9E;;;;;;;;;;;OAWG;WACU,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAepD;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IAS/B;;;;;;OAMG;IACH,QAAQ,IAAI,EAAE,EAAE;IAIhB;;;;;;;;OAQG;IACH,eAAe,IAAI,EAAE,EAAE;IAUvB;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;IAU3C;;;;;;;;;;;OAWG;IACH,kBAAkB,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC;IAK9B,uBAAuB,IAAI,MAAM;IAMjC,MAAM,CAAC,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAM1D;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,EAAE;;;;IAWxB;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM;IAalB;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAKnD;;OAEG;IACH,OAAO;IAIP;;;;;OAKG;IACH,MAAM,CAAC,6BAA6B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE;IAYlE,MAAM,CAAC,kBAAkB;;;;;IAQzB;;;;OAIG;WACU,gBAAgB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;CAU7D"}

package/dest/blob.js

@@ -1,29 +1,26 @@
 import { poseidon2Hash, sha256 } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
+// Importing directly from 'c-kzg' does not work:
 import cKzg from 'c-kzg';
 import { deserializeEncodedBlobToFields, extractBlobFieldsFromBuffer } from './encoding.js';
 import { BlobDeserializationError } from './errors.js';
-/* eslint-disable import/no-named-as-default-member */ const { BYTES_PER_BLOB, FIELD_ELEMENTS_PER_BLOB, blobToKzgCommitment, computeKzgProof, verifyKzgProof } = cKzg;
+const { BYTES_PER_BLOB, FIELD_ELEMENTS_PER_BLOB, blobToKzgCommitment, computeKzgProof, verifyKzgProof } = cKzg;
 // The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
 export const VERSIONED_HASH_VERSION_KZG = 0x01;
+/** Versioned blob hash for an empty blob */ export const EMPTY_BLOB_VERSIONED_HASH = Buffer.from(`010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014`, 'hex');
 /**
  * A class to create, manage, and prove EVM blobs.
  */ export class Blob {
     data;
     fieldsHash;
     challengeZ;
-    evaluationY;
     commitment;
-    proof;
-    constructor(/** The blob to be broadcast on L1 in bytes form. */ data, /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */ fieldsHash, /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */ challengeZ, /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */ evaluationY, /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */ commitment, /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */ proof){
+    constructor(/** The blob to be broadcast on L1 in bytes form. */ data, /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */ fieldsHash, /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts). */ challengeZ, /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */ commitment){
         this.data = data;
         this.fieldsHash = fieldsHash;
         this.challengeZ = challengeZ;
-        this.evaluationY = evaluationY;
         this.commitment = commitment;
-        this.proof = proof;
     }
     /**
    * The encoded version of the blob will determine the end of the blob based on the transaction encoding.
@@ -41,7 +38,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
         try {
             const fields = deserializeEncodedBlobToFields(blob);
             return Blob.fromFields(fields, multiBlobFieldsHash);
-        } catch (err) {
+        } catch  {
             throw new BlobDeserializationError(`Failed to create Blob from encoded blob buffer, this blob was likely not created by us`);
         }
     }
@@ -65,13 +62,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
             fieldsHash,
             ...commitmentToFields(commitment)
         ]);
-        const res = computeKzgProof(data, challengeZ.toBuffer());
-        if (!verifyKzgProof(commitment, challengeZ.toBuffer(), res[1], res[0])) {
-            throw new Error(`KZG proof did not verify.`);
-        }
-        const proof = Buffer.from(res[0]);
-        const evaluationY = Buffer.from(res[1]);
-        return new Blob(data, fieldsHash, challengeZ, evaluationY, commitment, proof);
+        return new Blob(data, fieldsHash, challengeZ, commitment);
     }
     /**
    * Create a Blob from a JSON object.
@@ -103,11 +94,9 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
    */ toJson(index) {
         return {
             blob: `0x${Buffer.from(this.data).toString('hex')}`,
-            index,
+            index: index.toString(),
             // eslint-disable-next-line camelcase
-            kzg_commitment: `0x${this.commitment.toString('hex')}`,
-            // eslint-disable-next-line camelcase
-            kzg_proof: `0x${this.proof.toString('hex')}`
+            kzg_commitment: `0x${this.commitment.toString('hex')}`
         };
     }
     /**
@@ -130,7 +119,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
    */ toEncodedFields() {
         try {
             return deserializeEncodedBlobToFields(this.data);
-        } catch (err) {
+        } catch  {
             throw new BlobDeserializationError(`Failed to deserialize encoded blob fields, this blob was likely not created by us`);
         }
     }
@@ -143,7 +132,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
    */ static toEncodedFields(blobs) {
         try {
             return deserializeEncodedBlobToFields(Buffer.concat(blobs.map((b)=>b.data)));
-        } catch (err) {
+        } catch  {
             throw new BlobDeserializationError(`Failed to deserialize encoded blob fields, this blob was likely not created by us`);
         }
     }
@@ -173,13 +162,34 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
         return hash;
     }
     /**
+   * Evaluate the blob at a given challenge and return the evaluation and KZG proof.
+   *
+   * @param challengeZ - The challenge z at which to evaluate the blob. If not given, assume we want to evaluate at the individual blob's z.
+   *
+   * @returns -
+   *  y: Buffer -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts
+   *  proof: Buffer - KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes).
+   */ evaluate(challengeZ) {
+        const z = challengeZ || this.challengeZ;
+        const res = computeKzgProof(this.data, z.toBuffer());
+        if (!verifyKzgProof(this.commitment, z.toBuffer(), res[1], res[0])) {
+            throw new Error(`KZG proof did not verify.`);
+        }
+        const proof = Buffer.from(res[0]);
+        const y = Buffer.from(res[1]);
+        return {
+            y,
+            proof
+        };
+    }
+    /**
    * Get the buffer representation of the ENTIRE blob.
    *
    * @dev WARNING: this buffer contains all metadata aswell as the data itself
    *
    * @returns The buffer representation of the blob.
    */ toBuffer() {
-        return Buffer.from(serializeToBuffer(this.data.length, this.data, this.fieldsHash, this.challengeZ, this.evaluationY.length, this.evaluationY, this.commitment.length, this.commitment, this.proof.length, this.proof));
+        return Buffer.from(serializeToBuffer(this.data.length, this.data, this.fieldsHash, this.challengeZ, this.commitment.length, this.commitment));
     }
     /**
    * Create a Blob from a buffer.
@@ -190,7 +200,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
    * @returns A Blob created from the buffer.
    */ static fromBuffer(buf) {
         const reader = BufferReader.asReader(buf);
-        return new Blob(reader.readUint8Array(), reader.readObject(Fr), reader.readObject(Fr), reader.readBuffer(), reader.readBuffer(), reader.readBuffer());
+        return new Blob(reader.readUint8Array(), reader.readObject(Fr), reader.readObject(Fr), reader.readBuffer());
     }
     /**
    * Get the size of the blob in bytes
@@ -198,38 +208,19 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
         return this.data.length;
     }
     /**
-   * Returns a proof of opening of the blob to verify on L1 using the point evaluation precompile:
-   *
-   * input[:32]     - versioned_hash
-   * input[32:64]   - z
-   * input[64:96]   - y
-   * input[96:144]  - commitment C
-   * input[144:192] - proof (a commitment to the quotient polynomial q(X))
-   *
-   * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
-   */ getEthBlobEvaluationInputs() {
-        const buf = Buffer.concat([
-            this.getEthVersionedBlobHash(),
-            this.challengeZ.toBuffer(),
-            this.evaluationY,
-            this.commitment,
-            this.proof
-        ]);
-        return `0x${buf.toString('hex')}`;
-    }
-    static getEthBlobEvaluationInputs(blobs) {
+   * @param blobs - The blobs to emit
+   * @returns The blobs' compressed commitments in hex prefixed by the number of blobs
+   * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs:
+   * One byte for the number blobs + 48 bytes per blob commitment
+   */ static getPrefixedEthBlobCommitments(blobs) {
         let buf = Buffer.alloc(0);
         blobs.forEach((blob)=>{
             buf = Buffer.concat([
                 buf,
-                blob.getEthVersionedBlobHash(),
-                blob.challengeZ.toBuffer(),
-                blob.evaluationY,
-                blob.commitment,
-                blob.proof
+                blob.commitment
             ]);
         });
-        // For multiple blobs, we prefix the number of blobs:
+        // We prefix the number of blobs:
         const lenBuf = Buffer.alloc(1);
         lenBuf.writeUint8(blobs.length);
         buf = Buffer.concat([
@@ -241,12 +232,15 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
     static getViemKzgInstance() {
         return {
             blobToKzgCommitment: cKzg.blobToKzgCommitment,
-            computeBlobKzgProof: cKzg.computeBlobKzgProof
+            computeBlobKzgProof: cKzg.computeBlobKzgProof,
+            computeCellsAndKzgProofs: cKzg.computeCellsAndKzgProofs
         };
     }
-    // Returns as many blobs as we require to broadcast the given fields
-    // Assumes we share the fields hash between all blobs
-    static async getBlobs(fields) {
+    /**
+   * @param fields - Fields to broadcast in the blob(s)
+   * @returns As many blobs as we require to broadcast the given fields for a block
+   * @dev Assumes we share the fields hash between all blobs which can only be done for ONE BLOCK because the hash is calculated in block root.
+   */ static async getBlobsPerBlock(fields) {
         const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
         const multiBlobFieldsHash = await poseidon2Hash(fields);
         const res = [];

package/dest/blob_batching.d.ts

@@ -0,0 +1,188 @@
+import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Blob } from './blob.js';
+/**
+ * A class to create, manage, and prove batched EVM blobs.
+ */
+export declare class BatchedBlob {
+    /** Hash of Cs (to link to L1 blob hashes). */
+    readonly blobCommitmentsHash: Fr;
+    /** Challenge point z such that p_i(z) = y_i. */
+    readonly z: Fr;
+    /** Evaluation y, linear combination of all evaluations y_i = p_i(z) with gamma. */
+    readonly y: BLS12Fr;
+    /** Commitment C, linear combination of all commitments C_i = [p_i] with gamma. */
+    readonly commitment: BLS12Point;
+    /** KZG opening 'proof' Q (commitment to the quotient poly.), linear combination of all blob kzg 'proofs' Q_i with gamma. */
+    readonly q: BLS12Point;
+    constructor(
+    /** Hash of Cs (to link to L1 blob hashes). */
+    blobCommitmentsHash: Fr, 
+    /** Challenge point z such that p_i(z) = y_i. */
+    z: Fr, 
+    /** Evaluation y, linear combination of all evaluations y_i = p_i(z) with gamma. */
+    y: BLS12Fr, 
+    /** Commitment C, linear combination of all commitments C_i = [p_i] with gamma. */
+    commitment: BLS12Point, 
+    /** KZG opening 'proof' Q (commitment to the quotient poly.), linear combination of all blob kzg 'proofs' Q_i with gamma. */
+    q: BLS12Point);
+    /**
+     * Get the final batched opening proof from multiple blobs.
+     * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
+     *      beforehand from ALL blobs.
+     *
+     * @returns A batched blob.
+     */
+    static batch(blobs: Blob[]): Promise<BatchedBlob>;
+    /**
+     * Returns an empty BatchedBlobAccumulator with precomputed challenges from all blobs in the epoch.
+     * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
+     *      beforehand from ALL blobs.
+     */
+    static newAccumulator(blobs: Blob[]): Promise<BatchedBlobAccumulator>;
+    /**
+     * Gets the final challenges based on all blobs and their elements to perform a multi opening proof.
+     * Used in BatchedBlobAccumulator as 'finalZ' and finalGamma':
+     *  - z = H(...H(H(z_0, z_1) z_2)..z_n)
+     *    - where z_i = H(H(fields of blob_i), C_i) = Blob.challengeZ,
+     *    - used such that p_i(z) = y_i = Blob.evaluationY for all n blob polynomials p_i().
+     *  - gamma = H(H(...H(H(y_0, y_1) y_2)..y_n), z)
+     *    - used such that y = sum_i { gamma^i * y_i }, and C = sum_i { gamma^i * C_i }, for all blob evaluations y_i (see above) and commitments C_i.
+     * @returns Challenges z and gamma.
+     */
+    static precomputeBatchedBlobChallenges(blobs: Blob[]): Promise<FinalBlobBatchingChallenges>;
+    static precomputeEmptyBatchedBlobChallenges(): Promise<FinalBlobBatchingChallenges>;
+    getEthVersionedBlobHash(): Buffer;
+    static getEthVersionedBlobHash(commitment: Buffer): Buffer;
+    /**
+     * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
+     *
+     * input[:32]     - versioned_hash
+     * input[32:64]   - z
+     * input[64:96]   - y
+     * input[96:144]  - commitment C
+     * input[144:192] - commitment Q (a 'proof' committing to the quotient polynomial q(X))
+     *
+     * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+     */
+    getEthBlobEvaluationInputs(): `0x${string}`;
+}
+/**
+ * Final values z and gamma are injected into each block root circuit. We ensure they are correct by:
+ * - Checking equality in each block merge circuit and propagating up
+ * - Checking final z_acc == z in root circuit
+ * - Checking final gamma_acc == gamma in root circuit
+ *
+ *  - z = H(...H(H(z_0, z_1) z_2)..z_n)
+ *    - where z_i = H(H(fields of blob_i), C_i),
+ *    - used such that p_i(z) = y_i = Blob.evaluationY for all n blob polynomials p_i().
+ *  - gamma = H(H(...H(H(y_0, y_1) y_2)..y_n), z)
+ *    - used such that y = sum_i { gamma^i * y_i }, and C = sum_i { gamma^i * C_i }
+ *      for all blob evaluations y_i (see above) and commitments C_i.
+ *
+ * Iteratively calculated by BlobAccumulatorPublicInputs.accumulate() in nr. See also precomputeBatchedBlobChallenges() above.
+ */
+export declare class FinalBlobBatchingChallenges {
+    readonly z: Fr;
+    readonly gamma: BLS12Fr;
+    constructor(z: Fr, gamma: BLS12Fr);
+    equals(other: FinalBlobBatchingChallenges): boolean;
+    static empty(): FinalBlobBatchingChallenges;
+    static fromBuffer(buffer: Buffer | BufferReader): FinalBlobBatchingChallenges;
+    toBuffer(): Buffer<ArrayBufferLike>;
+}
+/**
+ * See noir-projects/noir-protocol-circuits/crates/blob/src/blob_batching_public_inputs.nr -> BlobAccumulatorPublicInputs
+ */
+export declare class BatchedBlobAccumulator {
+    /** Hash of Cs (to link to L1 blob hashes). */
+    readonly blobCommitmentsHashAcc: Fr;
+    /** Challenge point z_acc. Final value used such that p_i(z) = y_i. */
+    readonly zAcc: Fr;
+    /** Evaluation y_acc. Final value is is linear combination of all evaluations y_i = p_i(z) with gamma. */
+    readonly yAcc: BLS12Fr;
+    /** Commitment c_acc. Final value is linear combination of all commitments C_i = [p_i] with gamma. */
+    readonly cAcc: BLS12Point;
+    /** KZG opening q_acc. Final value is linear combination of all blob kzg 'proofs' Q_i with gamma. */
+    readonly qAcc: BLS12Point;
+    /**
+     * Challenge point gamma_acc for multi opening. Used with y, C, and kzg 'proof' Q above.
+     * TODO(#13608): We calculate this by hashing natively in the circuit (hence Fr representation), but it's actually used
+     * as a BLS12Fr field elt. Is this safe? Is there a skew?
+     */
+    readonly gammaAcc: Fr;
+    /** Simply gamma^(i + 1) at blob i. Used for calculating the i'th element of the above linear comb.s */
+    readonly gammaPow: BLS12Fr;
+    /** Final challenge values used in evaluation. Optimistically input and checked in the final acc. */
+    readonly finalBlobChallenges: FinalBlobBatchingChallenges;
+    constructor(
+    /** Hash of Cs (to link to L1 blob hashes). */
+    blobCommitmentsHashAcc: Fr, 
+    /** Challenge point z_acc. Final value used such that p_i(z) = y_i. */
+    zAcc: Fr, 
+    /** Evaluation y_acc. Final value is is linear combination of all evaluations y_i = p_i(z) with gamma. */
+    yAcc: BLS12Fr, 
+    /** Commitment c_acc. Final value is linear combination of all commitments C_i = [p_i] with gamma. */
+    cAcc: BLS12Point, 
+    /** KZG opening q_acc. Final value is linear combination of all blob kzg 'proofs' Q_i with gamma. */
+    qAcc: BLS12Point, 
+    /**
+     * Challenge point gamma_acc for multi opening. Used with y, C, and kzg 'proof' Q above.
+     * TODO(#13608): We calculate this by hashing natively in the circuit (hence Fr representation), but it's actually used
+     * as a BLS12Fr field elt. Is this safe? Is there a skew?
+     */
+    gammaAcc: Fr, 
+    /** Simply gamma^(i + 1) at blob i. Used for calculating the i'th element of the above linear comb.s */
+    gammaPow: BLS12Fr, 
+    /** Final challenge values used in evaluation. Optimistically input and checked in the final acc. */
+    finalBlobChallenges: FinalBlobBatchingChallenges);
+    /**
+     * Init the first accumulation state of the epoch.
+     * We assume the input blob has not been evaluated at z.
+     *
+     * First state of the accumulator:
+     * - v_acc := sha256(C_0)
+     * - z_acc := z_0
+     * - y_acc := gamma^0 * y_0 = y_0
+     * - c_acc := gamma^0 * c_0 = c_0
+     * - gamma_acc := poseidon2(y_0.limbs)
+     * - gamma^(i + 1) = gamma^1 = gamma // denoted gamma_pow_acc
+     *
+     * @returns An initial blob accumulator.
+     */
+    static initialize(blob: Blob, finalBlobChallenges: FinalBlobBatchingChallenges): Promise<BatchedBlobAccumulator>;
+    /**
+     * Create the empty accumulation state of the epoch.
+     * @returns An empty blob accumulator with challenges.
+     */
+    static newWithChallenges(finalBlobChallenges: FinalBlobBatchingChallenges): BatchedBlobAccumulator;
+    /**
+     * Given blob i, accumulate all state.
+     * We assume the input blob has not been evaluated at z.
+     * @returns An updated blob accumulator.
+     */
+    accumulate(blob: Blob): Promise<BatchedBlobAccumulator>;
+    /**
+     * Given blobs, accumulate all state.
+     * We assume the input blobs have not been evaluated at z.
+     * @returns An updated blob accumulator.
+     */
+    accumulateBlobs(blobs: Blob[]): Promise<BatchedBlobAccumulator>;
+    /**
+     * Finalize accumulation state of the epoch.
+     * We assume ALL blobs in the epoch have been accumulated.
+     *
+     * Final accumulated values:
+     * - v := v_acc (hash of all commitments (C_i s) to be checked on L1)
+     * - z := z_acc (final challenge, at which all blobs are evaluated)
+     * - y := y_acc (final opening to be checked on L1)
+     * - c := c_acc (final commitment to be checked on L1)
+     * - gamma := poseidon2(gamma_acc, z) (challenge for linear combination of y and C, above)
+     *
+     * @returns A batched blob.
+     */
+    finalize(): Promise<BatchedBlob>;
+    isEmptyState(): boolean;
+    clone(): BatchedBlobAccumulator;
+}
+//# sourceMappingURL=blob_batching.d.ts.map

package/dest/blob_batching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_batching.d.ts","sourceRoot":"","sources":["../src/blob_batching.ts"],"names":[],"mappings":"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"}