@aztec/blob-lib 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/dest/blob_batching.d.ts

@@ -1,6 +1,6 @@
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
 import { Blob } from './blob.js';
-import { BlobAccumulator, FinalBlobAccumulator, FinalBlobBatchingChallenges } from './circuit_types/index.js';
 /**
  * A class to create, manage, and prove batched EVM blobs.
  */
@@ -33,13 +33,13 @@ export declare class BatchedBlob {
      *
      * @returns A batched blob.
      */
-    static batch(blobs: Blob[][]): Promise<BatchedBlob>;
+    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>;
+    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':
@@ -48,13 +48,12 @@ export declare class BatchedBlob {
      *    - 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.
-     *
-     * @param blobs - The blobs to precompute the challenges for. Each sub-array is the blobs for an L1 block.
      * @returns Challenges z and gamma.
      */
-    static precomputeBatchedBlobChallenges(blobs: Blob[][]): Promise<FinalBlobBatchingChallenges>;
-    verify(): boolean;
+    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:
      *
@@ -67,10 +66,33 @@ export declare class BatchedBlob {
      * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
      */
     getEthBlobEvaluationInputs(): `0x${string}`;
-    toFinalBlobAccumulator(): FinalBlobAccumulator;
 }
 /**
- * See noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr
+ * 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). */
@@ -114,6 +136,21 @@ export declare class BatchedBlobAccumulator {
     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.
@@ -124,11 +161,10 @@ export declare class BatchedBlobAccumulator {
      * We assume the input blob has not been evaluated at z.
      * @returns An updated blob accumulator.
      */
-    private accumulate;
+    accumulate(blob: Blob): Promise<BatchedBlobAccumulator>;
     /**
      * Given blobs, accumulate all state.
      * We assume the input blobs have not been evaluated at z.
-     * @param blobs - The blobs to accumulate. They should be in the same L1 block.
      * @returns An updated blob accumulator.
      */
     accumulateBlobs(blobs: Blob[]): Promise<BatchedBlobAccumulator>;
@@ -143,13 +179,10 @@ export declare class BatchedBlobAccumulator {
      * - c := c_acc (final commitment to be checked on L1)
      * - gamma := poseidon2(gamma_acc, z) (challenge for linear combination of y and C, above)
      *
-     * @param verifyProof - Whether to verify the KZG proof.
      * @returns A batched blob.
      */
-    finalize(verifyProof?: boolean): Promise<BatchedBlob>;
+    finalize(): Promise<BatchedBlob>;
     isEmptyState(): boolean;
     clone(): BatchedBlobAccumulator;
-    toBlobAccumulator(): BlobAccumulator;
-    toFinalBlobAccumulator(): FinalBlobAccumulator;
 }
 //# sourceMappingURL=blob_batching.d.ts.map

package/dest/blob_batching.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob_batching.d.ts","sourceRoot":"","sources":["../src/blob_batching.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAI9G;;GAEG;AACH,qBAAa,WAAW;IAEpB,8CAA8C;aAC9B,mBAAmB,EAAE,EAAE;IACvC,gDAAgD;aAChC,CAAC,EAAE,EAAE;IACrB,mFAAmF;aACnE,CAAC,EAAE,OAAO;IAC1B,kFAAkF;aAClE,UAAU,EAAE,UAAU;IACtC,4HAA4H;aAC5G,CAAC,EAAE,UAAU;;IAT7B,8CAA8C;IAC9B,mBAAmB,EAAE,EAAE;IACvC,gDAAgD;IAChC,CAAC,EAAE,EAAE;IACrB,mFAAmF;IACnE,CAAC,EAAE,OAAO;IAC1B,kFAAkF;IAClE,UAAU,EAAE,UAAU;IACtC,4HAA4H;IAC5G,CAAC,EAAE,UAAU;IAG/B;;;;;;OAMG;WACU,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAgBzD;;;;OAIG;WACU,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAK7E;;;;;;;;;;;OAWG;WACU,+BAA+B,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAmCnG,MAAM;IAKN,uBAAuB,IAAI,MAAM;IAIjC;;;;;;;;;;OAUG;IACH,0BAA0B,IAAI,KAAK,MAAM,EAAE;IAW3C,sBAAsB;CAGvB;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAE/B,8CAA8C;aAC9B,sBAAsB,EAAE,EAAE;IAC1C,sEAAsE;aACtD,IAAI,EAAE,EAAE;IACxB,yGAAyG;aACzF,IAAI,EAAE,OAAO;IAC7B,qGAAqG;aACrF,IAAI,EAAE,UAAU;IAChC,oGAAoG;aACpF,IAAI,EAAE,UAAU;IAChC;;;;OAIG;aACa,QAAQ,EAAE,EAAE;IAC5B,uGAAuG;aACvF,QAAQ,EAAE,OAAO;IACjC,oGAAoG;aACpF,mBAAmB,EAAE,2BAA2B;;IAnBhE,8CAA8C;IAC9B,sBAAsB,EAAE,EAAE;IAC1C,sEAAsE;IACtD,IAAI,EAAE,EAAE;IACxB,yGAAyG;IACzF,IAAI,EAAE,OAAO;IAC7B,qGAAqG;IACrF,IAAI,EAAE,UAAU;IAChC,oGAAoG;IACpF,IAAI,EAAE,UAAU;IAChC;;;;OAIG;IACa,QAAQ,EAAE,EAAE;IAC5B,uGAAuG;IACvF,QAAQ,EAAE,OAAO;IACjC,oGAAoG;IACpF,mBAAmB,EAAE,2BAA2B;IAGlE;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,2BAA2B,GAAG,sBAAsB;IAalG;;;;OAIG;YACW,UAAU;IAyCxB;;;;;OAKG;IACG,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE;IAkBnC;;;;;;;;;;;;;OAaG;IACG,QAAQ,CAAC,WAAW,UAAQ,GAAG,OAAO,CAAC,WAAW,CAAC;IAwBzD,YAAY;IAYZ,KAAK;IAaL,iBAAiB;IAWjB,sBAAsB;CAGvB"}
+{"version":3,"file":"blob_batching.d.ts","sourceRoot":"","sources":["../src/blob_batching.ts"],"names":[],"mappings":"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"}

package/dest/blob_batching.js

@@ -1,10 +1,11 @@
 import { AZTEC_MAX_EPOCH_DURATION, BLOBS_PER_BLOCK } from '@aztec/constants';
-import { poseidon2Hash, sha256ToField } from '@aztec/foundation/crypto';
+import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { computeBlobFieldsHashFromBlobs } from './blob_utils.js';
-import { BlobAccumulator, FinalBlobAccumulator, FinalBlobBatchingChallenges } from './circuit_types/index.js';
-import { computeEthVersionedBlobHash, hashNoirBigNumLimbs } from './hash.js';
-import { kzg } from './kzg_context.js';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+// Importing directly from 'c-kzg' does not work:
+import cKzg from 'c-kzg';
+import { Blob, VERSIONED_HASH_VERSION_KZG } from './blob.js';
+const { computeKzgProof, verifyKzgProof } = cKzg;
 /**
  * A class to create, manage, and prove batched EVM blobs.
  */ export class BatchedBlob {
@@ -27,15 +28,14 @@ import { kzg } from './kzg_context.js';
    *
    * @returns A batched blob.
    */ static async batch(blobs) {
-        if (blobs.length > AZTEC_MAX_EPOCH_DURATION) {
-            throw new Error(`Too many blocks sent to batch(). The maximum is ${AZTEC_MAX_EPOCH_DURATION}. Got ${blobs.length}.`);
+        const numBlobs = blobs.length;
+        if (numBlobs > BLOBS_PER_BLOCK * AZTEC_MAX_EPOCH_DURATION) {
+            throw new Error(`Too many blobs (${numBlobs}) sent to batch(). The maximum is ${BLOBS_PER_BLOCK * AZTEC_MAX_EPOCH_DURATION}.`);
         }
         // Precalculate the values (z and gamma) and initialize the accumulator:
         let acc = await this.newAccumulator(blobs);
         // Now we can create a multi opening proof of all input blobs:
-        for (const blockBlobs of blobs){
-            acc = await acc.accumulateBlobs(blockBlobs);
-        }
+        acc = await acc.accumulateBlobs(blobs);
         return await acc.finalize();
     }
     /**
@@ -54,42 +54,27 @@ import { kzg } from './kzg_context.js';
    *    - 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.
-   *
-   * @param blobs - The blobs to precompute the challenges for. Each sub-array is the blobs for an L1 block.
    * @returns Challenges z and gamma.
    */ static async precomputeBatchedBlobChallenges(blobs) {
-        // Compute the final challenge z to evaluate the blobs.
-        let z;
-        for (const blockBlobs of blobs){
-            // Compute the hash of all the fields in the block.
-            const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blockBlobs);
-            for (const blob of blockBlobs){
-                // Compute the challenge z for each blob and accumulate it.
-                const challengeZ = await blob.computeChallengeZ(blobFieldsHash);
-                if (!z) {
-                    z = challengeZ;
-                } else {
-                    z = await poseidon2Hash([
-                        z,
-                        challengeZ
-                    ]);
-                }
-            }
-        }
-        if (!z) {
-            throw new Error('No blobs to precompute challenges for.');
+        // We need to precompute the final challenge values to evaluate the blobs.
+        let z = blobs[0].challengeZ;
+        // We start at i = 1, because z is initialized as the first blob's challenge.
+        for(let i = 1; i < blobs.length; i++){
+            z = await poseidon2Hash([
+                z,
+                blobs[i].challengeZ
+            ]);
         }
         // Now we have a shared challenge for all blobs, evaluate them...
-        const allBlobs = blobs.flat();
-        const proofObjects = allBlobs.map((b)=>b.evaluate(z));
-        const evaluations = await Promise.all(proofObjects.map(({ y })=>hashNoirBigNumLimbs(y)));
+        const proofObjects = blobs.map((b)=>computeKzgProof(b.data, z.toBuffer()));
+        const evaluations = proofObjects.map(([_, evaluation])=>BLS12Fr.fromBuffer(Buffer.from(evaluation)));
         // ...and find the challenge for the linear combination of blobs.
-        let gamma = evaluations[0];
+        let gamma = await hashNoirBigNumLimbs(evaluations[0]);
         // We start at i = 1, because gamma is initialized as the first blob's evaluation.
-        for(let i = 1; i < allBlobs.length; i++){
+        for(let i = 1; i < blobs.length; i++){
             gamma = await poseidon2Hash([
                 gamma,
-                evaluations[i]
+                await hashNoirBigNumLimbs(evaluations[i])
             ]);
         }
         gamma = await poseidon2Hash([
@@ -98,12 +83,33 @@ import { kzg } from './kzg_context.js';
         ]);
         return new FinalBlobBatchingChallenges(z, BLS12Fr.fromBN254Fr(gamma));
     }
-    verify() {
-        return kzg.verifyKzgProof(this.commitment.compress(), this.z.toBuffer(), this.y.toBuffer(), this.q.compress());
+    static async precomputeEmptyBatchedBlobChallenges() {
+        const blobs = [
+            await Blob.fromFields([])
+        ];
+        // We need to precompute the final challenge values to evaluate the blobs.
+        const z = blobs[0].challengeZ;
+        // Now we have a shared challenge for all blobs, evaluate them...
+        const proofObjects = blobs.map((b)=>computeKzgProof(b.data, z.toBuffer()));
+        const evaluations = proofObjects.map(([_, evaluation])=>BLS12Fr.fromBuffer(Buffer.from(evaluation)));
+        // ...and find the challenge for the linear combination of blobs.
+        let gamma = await hashNoirBigNumLimbs(evaluations[0]);
+        gamma = await poseidon2Hash([
+            gamma,
+            z
+        ]);
+        return new FinalBlobBatchingChallenges(z, BLS12Fr.fromBN254Fr(gamma));
     }
     // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
     getEthVersionedBlobHash() {
-        return computeEthVersionedBlobHash(this.commitment.compress());
+        const hash = sha256(this.commitment.compress());
+        hash[0] = VERSIONED_HASH_VERSION_KZG;
+        return hash;
+    }
+    static getEthVersionedBlobHash(commitment) {
+        const hash = sha256(commitment);
+        hash[0] = VERSIONED_HASH_VERSION_KZG;
+        return hash;
     }
     /**
    * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
@@ -125,12 +131,44 @@ import { kzg } from './kzg_context.js';
         ]);
         return `0x${buf.toString('hex')}`;
     }
-    toFinalBlobAccumulator() {
-        return new FinalBlobAccumulator(this.blobCommitmentsHash, this.z, this.y, this.commitment);
+}
+/**
+ * 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 class FinalBlobBatchingChallenges {
+    z;
+    gamma;
+    constructor(z, gamma){
+        this.z = z;
+        this.gamma = gamma;
+    }
+    equals(other) {
+        return this.z.equals(other.z) && this.gamma.equals(other.gamma);
+    }
+    static empty() {
+        return new FinalBlobBatchingChallenges(Fr.ZERO, BLS12Fr.ZERO);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new FinalBlobBatchingChallenges(Fr.fromBuffer(reader), reader.readObject(BLS12Fr));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.z, this.gamma);
     }
 }
 /**
- * See noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr
+ * See noir-projects/noir-protocol-circuits/crates/blob/src/blob_batching_public_inputs.nr -> BlobAccumulatorPublicInputs
  */ export class BatchedBlobAccumulator {
     blobCommitmentsHashAcc;
     zAcc;
@@ -155,6 +193,27 @@ import { kzg } from './kzg_context.js';
         this.finalBlobChallenges = finalBlobChallenges;
     }
     /**
+   * 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 async initialize(blob, finalBlobChallenges) {
+        const [q, evaluation] = computeKzgProof(blob.data, finalBlobChallenges.z.toBuffer());
+        const firstY = BLS12Fr.fromBuffer(Buffer.from(evaluation));
+        // Here, i = 0, so:
+        return new BatchedBlobAccumulator(sha256ToField([
+            blob.commitment
+        ]), blob.challengeZ, firstY, BLS12Point.decompress(blob.commitment), BLS12Point.decompress(Buffer.from(q)), await hashNoirBigNumLimbs(firstY), finalBlobChallenges.gamma, finalBlobChallenges);
+    }
+    /**
    * Create the empty accumulation state of the epoch.
    * @returns An empty blob accumulator with challenges.
    */ static newWithChallenges(finalBlobChallenges) {
@@ -164,32 +223,20 @@ import { kzg } from './kzg_context.js';
    * Given blob i, accumulate all state.
    * We assume the input blob has not been evaluated at z.
    * @returns An updated blob accumulator.
-   */ async accumulate(blob, blobFieldsHash) {
-        const { proof, y: thisY } = blob.evaluate(this.finalBlobChallenges.z);
-        const thisC = BLS12Point.decompress(blob.commitment);
-        const thisQ = BLS12Point.decompress(proof);
-        const blobChallengeZ = await blob.computeChallengeZ(blobFieldsHash);
+   */ async accumulate(blob) {
         if (this.isEmptyState()) {
-            /**
-       * Init the first accumulation state of the epoch.
-       * - 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
-       */ return new BatchedBlobAccumulator(sha256ToField([
-                blob.commitment
-            ]), blobChallengeZ, thisY, thisC, thisQ, await hashNoirBigNumLimbs(thisY), this.finalBlobChallenges.gamma, this.finalBlobChallenges);
+            return BatchedBlobAccumulator.initialize(blob, this.finalBlobChallenges);
         } else {
+            const [q, evaluation] = computeKzgProof(blob.data, this.finalBlobChallenges.z.toBuffer());
+            const thisY = BLS12Fr.fromBuffer(Buffer.from(evaluation));
             // Moving from i - 1 to i, so:
             return new BatchedBlobAccumulator(sha256ToField([
                 this.blobCommitmentsHashAcc,
                 blob.commitment
             ]), await poseidon2Hash([
                 this.zAcc,
-                blobChallengeZ
-            ]), this.yAcc.add(thisY.mul(this.gammaPow)), this.cAcc.add(thisC.mul(this.gammaPow)), this.qAcc.add(thisQ.mul(this.gammaPow)), await poseidon2Hash([
+                blob.challengeZ
+            ]), this.yAcc.add(thisY.mul(this.gammaPow)), this.cAcc.add(BLS12Point.decompress(blob.commitment).mul(this.gammaPow)), this.qAcc.add(BLS12Point.decompress(Buffer.from(q)).mul(this.gammaPow)), await poseidon2Hash([
                 this.gammaAcc,
                 await hashNoirBigNumLimbs(thisY)
             ]), this.gammaPow.mul(this.finalBlobChallenges.gamma), this.finalBlobChallenges);
@@ -198,18 +245,12 @@ import { kzg } from './kzg_context.js';
     /**
    * Given blobs, accumulate all state.
    * We assume the input blobs have not been evaluated at z.
-   * @param blobs - The blobs to accumulate. They should be in the same L1 block.
    * @returns An updated blob accumulator.
    */ async accumulateBlobs(blobs) {
-        if (blobs.length > BLOBS_PER_BLOCK) {
-            throw new Error(`Too many blobs to accumulate. The maximum is ${BLOBS_PER_BLOCK} per block. Got ${blobs.length}.`);
-        }
-        // Compute the hash of all the fields in the block.
-        const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blobs);
         // Initialize the acc to iterate over:
         let acc = this.clone();
-        for (const blob of blobs){
-            acc = await acc.accumulate(blob, blobFieldsHash);
+        for(let i = 0; i < blobs.length; i++){
+            acc = await acc.accumulate(blobs[i]);
         }
         return acc;
     }
@@ -224,9 +265,8 @@ import { kzg } from './kzg_context.js';
    * - c := c_acc (final commitment to be checked on L1)
    * - gamma := poseidon2(gamma_acc, z) (challenge for linear combination of y and C, above)
    *
-   * @param verifyProof - Whether to verify the KZG proof.
    * @returns A batched blob.
-   */ async finalize(verifyProof = false) {
+   */ async finalize() {
         // All values in acc are final, apart from gamma := poseidon2(gammaAcc, z):
         const calculatedGamma = await poseidon2Hash([
             this.gammaAcc,
@@ -239,11 +279,10 @@ import { kzg } from './kzg_context.js';
         if (!calculatedGamma.equals(this.finalBlobChallenges.gamma.toBN254Fr())) {
             throw new Error(`Blob batching mismatch: accumulated gamma ${calculatedGamma} does not equal injected gamma ${this.finalBlobChallenges.gamma.toBN254Fr()}`);
         }
-        const batchedBlob = new BatchedBlob(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.qAcc);
-        if (verifyProof && !batchedBlob.verify()) {
+        if (!verifyKzgProof(this.cAcc.compress(), this.zAcc.toBuffer(), this.yAcc.toBuffer(), this.qAcc.compress())) {
             throw new Error(`KZG proof did not verify.`);
         }
-        return batchedBlob;
+        return new BatchedBlob(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.qAcc);
     }
     isEmptyState() {
         return this.blobCommitmentsHashAcc.isZero() && this.zAcc.isZero() && this.yAcc.isZero() && this.cAcc.isZero() && this.qAcc.isZero() && this.gammaAcc.isZero() && this.gammaPow.isZero();
@@ -251,10 +290,10 @@ import { kzg } from './kzg_context.js';
     clone() {
         return new BatchedBlobAccumulator(Fr.fromBuffer(this.blobCommitmentsHashAcc.toBuffer()), Fr.fromBuffer(this.zAcc.toBuffer()), BLS12Fr.fromBuffer(this.yAcc.toBuffer()), BLS12Point.fromBuffer(this.cAcc.toBuffer()), BLS12Point.fromBuffer(this.qAcc.toBuffer()), Fr.fromBuffer(this.gammaAcc.toBuffer()), BLS12Fr.fromBuffer(this.gammaPow.toBuffer()), FinalBlobBatchingChallenges.fromBuffer(this.finalBlobChallenges.toBuffer()));
     }
-    toBlobAccumulator() {
-        return new BlobAccumulator(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.gammaAcc, this.gammaPow);
-    }
-    toFinalBlobAccumulator() {
-        return new FinalBlobAccumulator(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc);
-    }
+}
+// To mimic the hash accumulation in the rollup circuits, here we hash
+// each u128 limb of the noir bignum struct representing the BLS field.
+async function hashNoirBigNumLimbs(field) {
+    const num = field.toNoirBigNum();
+    return await poseidon2Hash(num.limbs.map(Fr.fromHexString));
 }

package/dest/blob_batching_public_inputs.d.ts

@@ -0,0 +1,71 @@
+import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { Blob } from './blob.js';
+import { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
+/**
+ * See nr BlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
+ */
+export declare class BlobAccumulatorPublicInputs {
+    blobCommitmentsHashAcc: Fr;
+    zAcc: Fr;
+    yAcc: BLS12Fr;
+    cAcc: BLS12Point;
+    gammaAcc: Fr;
+    gammaPowAcc: BLS12Fr;
+    constructor(blobCommitmentsHashAcc: Fr, zAcc: Fr, yAcc: BLS12Fr, cAcc: BLS12Point, gammaAcc: Fr, gammaPowAcc: BLS12Fr);
+    static empty(): BlobAccumulatorPublicInputs;
+    equals(other: BlobAccumulatorPublicInputs): boolean;
+    static fromBuffer(buffer: Buffer | BufferReader): BlobAccumulatorPublicInputs;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Given blobs, accumulate all public inputs state.
+     * We assume the input blobs have not been evaluated at z.
+     * NOTE: Does NOT accumulate non circuit values including Q. This exists to simulate/check exactly what the circuit is doing
+     * and is unsafe for other use. For that reason, a toBatchedBlobAccumulator does not exist. See evaluateBlobs() oracle for usage.
+     * @returns An updated blob accumulator.
+     */
+    accumulateBlobs(blobs: Blob[], finalBlobChallenges: FinalBlobBatchingChallenges): Promise<BlobAccumulatorPublicInputs>;
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): BlobAccumulatorPublicInputs;
+    /**
+     * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
+     * @returns A BlobAccumulatorPublicInputs instance.
+     */
+    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): BlobAccumulatorPublicInputs;
+}
+/**
+ * See nr FinalBlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
+ */
+export declare class FinalBlobAccumulatorPublicInputs {
+    blobCommitmentsHash: Fr;
+    z: Fr;
+    y: BLS12Fr;
+    c: BLS12Point;
+    constructor(blobCommitmentsHash: Fr, z: Fr, y: BLS12Fr, c: BLS12Point);
+    static empty(): FinalBlobAccumulatorPublicInputs;
+    static fromBuffer(buffer: Buffer | BufferReader): FinalBlobAccumulatorPublicInputs;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static fromBatchedBlob(blob: BatchedBlob): FinalBlobAccumulatorPublicInputs;
+    toFields(): Fr[];
+    toString(): string;
+    equals(other: FinalBlobAccumulatorPublicInputs): boolean;
+    static random(): FinalBlobAccumulatorPublicInputs;
+    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): FinalBlobAccumulatorPublicInputs;
+    [inspect.custom](): string;
+}
+/**
+ * startBlobAccumulator: Accumulated opening proofs for all blobs before this block range.
+ * endBlobAccumulator: Accumulated opening proofs for all blobs after adding this block range.
+ * finalBlobChallenges:  Final values z and gamma, shared across the epoch.
+ */
+export declare class BlockBlobPublicInputs {
+    startBlobAccumulator: BlobAccumulatorPublicInputs;
+    endBlobAccumulator: BlobAccumulatorPublicInputs;
+    finalBlobChallenges: FinalBlobBatchingChallenges;
+    constructor(startBlobAccumulator: BlobAccumulatorPublicInputs, endBlobAccumulator: BlobAccumulatorPublicInputs, finalBlobChallenges: FinalBlobBatchingChallenges);
+    static empty(): BlockBlobPublicInputs;
+    static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs;
+    toBuffer(): Buffer<ArrayBufferLike>;
+}
+//# sourceMappingURL=blob_batching_public_inputs.d.ts.map

package/dest/blob_batching_public_inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_batching_public_inputs.d.ts","sourceRoot":"","sources":["../src/blob_batching_public_inputs.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtG;;GAEG;AACH,qBAAa,2BAA2B;IAE7B,sBAAsB,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE,EAAE;IACZ,WAAW,EAAE,OAAO;gBALpB,sBAAsB,EAAE,EAAE,EAC1B,IAAI,EAAE,EAAE,EACR,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,OAAO;IAG7B,MAAM,CAAC,KAAK,IAAI,2BAA2B;IAI3C,MAAM,CAAC,KAAK,EAAE,2BAA2B;IAWzC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,2BAA2B;IAY7E,QAAQ;IAWR;;;;;;OAMG;IACG,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,mBAAmB,EAAE,2BAA2B;IAsBrF,QAAQ;IAaR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,2BAA2B;IAgB1E;;;OAGG;IACH,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,sBAAsB;CAUtE;AAED;;GAEG;AACH,qBAAa,gCAAgC;IAElC,mBAAmB,EAAE,EAAE;IACvB,CAAC,EAAE,EAAE;IACL,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,UAAU;gBAHb,mBAAmB,EAAE,EAAE,EACvB,CAAC,EAAE,EAAE,EACL,CAAC,EAAE,OAAO,EACV,CAAC,EAAE,UAAU;IAGtB,MAAM,CAAC,KAAK,IAAI,gCAAgC;IAIhD,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,gCAAgC;IAUlF,QAAQ;IAIR,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,WAAW;IAIxC,QAAQ;IAUR,QAAQ;IAQR,MAAM,CAAC,KAAK,EAAE,gCAAgC;IAU9C,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,sBAAsB;IASrE,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB;AAED;;;;GAIG;AACH,qBAAa,qBAAqB;IAEvB,oBAAoB,EAAE,2BAA2B;IACjD,kBAAkB,EAAE,2BAA2B;IAC/C,mBAAmB,EAAE,2BAA2B;gBAFhD,oBAAoB,EAAE,2BAA2B,EACjD,kBAAkB,EAAE,2BAA2B,EAC/C,mBAAmB,EAAE,2BAA2B;IAGzD,MAAM,CAAC,KAAK,IAAI,qBAAqB;IAQrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,qBAAqB;IASvE,QAAQ;CAGT"}