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

package/dest/blob_batching.js

@@ -0,0 +1,299 @@
+import { AZTEC_MAX_EPOCH_DURATION, BLOBS_PER_BLOCK } from '@aztec/constants';
+import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
+import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+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 {
+    blobCommitmentsHash;
+    z;
+    y;
+    commitment;
+    q;
+    constructor(/** Hash of Cs (to link to L1 blob hashes). */ blobCommitmentsHash, /** Challenge point z such that p_i(z) = y_i. */ z, /** Evaluation y, linear combination of all evaluations y_i = p_i(z) with gamma. */ y, /** Commitment C, linear combination of all commitments C_i = [p_i] with gamma. */ commitment, /** KZG opening 'proof' Q (commitment to the quotient poly.), linear combination of all blob kzg 'proofs' Q_i with gamma. */ q){
+        this.blobCommitmentsHash = blobCommitmentsHash;
+        this.z = z;
+        this.y = y;
+        this.commitment = commitment;
+        this.q = q;
+    }
+    /**
+   * 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 async batch(blobs) {
+        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:
+        acc = await acc.accumulateBlobs(blobs);
+        return await acc.finalize();
+    }
+    /**
+   * 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 async newAccumulator(blobs) {
+        const finalBlobChallenges = await this.precomputeBatchedBlobChallenges(blobs);
+        return BatchedBlobAccumulator.newWithChallenges(finalBlobChallenges);
+    }
+    /**
+   * 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 async precomputeBatchedBlobChallenges(blobs) {
+        // 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 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]);
+        // We start at i = 1, because gamma is initialized as the first blob's evaluation.
+        for(let i = 1; i < blobs.length; i++){
+            gamma = await poseidon2Hash([
+                gamma,
+                await hashNoirBigNumLimbs(evaluations[i])
+            ]);
+        }
+        gamma = await poseidon2Hash([
+            gamma,
+            z
+        ]);
+        return new FinalBlobBatchingChallenges(z, BLS12Fr.fromBN254Fr(gamma));
+    }
+    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() {
+        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:
+   *
+   * 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() {
+        const buf = Buffer.concat([
+            this.getEthVersionedBlobHash(),
+            this.z.toBuffer(),
+            this.y.toBuffer(),
+            this.commitment.compress(),
+            this.q.compress()
+        ]);
+        return `0x${buf.toString('hex')}`;
+    }
+}
+/**
+ * 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/blob_batching_public_inputs.nr -> BlobAccumulatorPublicInputs
+ */ export class BatchedBlobAccumulator {
+    blobCommitmentsHashAcc;
+    zAcc;
+    yAcc;
+    cAcc;
+    qAcc;
+    gammaAcc;
+    gammaPow;
+    finalBlobChallenges;
+    constructor(/** Hash of Cs (to link to L1 blob hashes). */ blobCommitmentsHashAcc, /** Challenge point z_acc. Final value used such that p_i(z) = y_i. */ zAcc, /** Evaluation y_acc. Final value is is linear combination of all evaluations y_i = p_i(z) with gamma. */ yAcc, /** Commitment c_acc. Final value is linear combination of all commitments C_i = [p_i] with gamma. */ cAcc, /** KZG opening q_acc. Final value is linear combination of all blob kzg 'proofs' Q_i with gamma. */ qAcc, /**
+     * 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, /** Simply gamma^(i + 1) at blob i. Used for calculating the i'th element of the above linear comb.s */ gammaPow, /** Final challenge values used in evaluation. Optimistically input and checked in the final acc. */ finalBlobChallenges){
+        this.blobCommitmentsHashAcc = blobCommitmentsHashAcc;
+        this.zAcc = zAcc;
+        this.yAcc = yAcc;
+        this.cAcc = cAcc;
+        this.qAcc = qAcc;
+        this.gammaAcc = gammaAcc;
+        this.gammaPow = gammaPow;
+        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) {
+        return new BatchedBlobAccumulator(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO, finalBlobChallenges);
+    }
+    /**
+   * 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) {
+        if (this.isEmptyState()) {
+            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,
+                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);
+        }
+    }
+    /**
+   * Given blobs, accumulate all state.
+   * We assume the input blobs have not been evaluated at z.
+   * @returns An updated blob accumulator.
+   */ async accumulateBlobs(blobs) {
+        // Initialize the acc to iterate over:
+        let acc = this.clone();
+        for(let i = 0; i < blobs.length; i++){
+            acc = await acc.accumulate(blobs[i]);
+        }
+        return acc;
+    }
+    /**
+   * 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.
+   */ async finalize() {
+        // All values in acc are final, apart from gamma := poseidon2(gammaAcc, z):
+        const calculatedGamma = await poseidon2Hash([
+            this.gammaAcc,
+            this.zAcc
+        ]);
+        // Check final values:
+        if (!this.zAcc.equals(this.finalBlobChallenges.z)) {
+            throw new Error(`Blob batching mismatch: accumulated z ${this.zAcc} does not equal injected z ${this.finalBlobChallenges.z}`);
+        }
+        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()}`);
+        }
+        if (!verifyKzgProof(this.cAcc.compress(), this.zAcc.toBuffer(), this.yAcc.toBuffer(), this.qAcc.compress())) {
+            throw new Error(`KZG proof did not verify.`);
+        }
+        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();
+    }
+    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()));
+    }
+}
+// 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"}

package/dest/blob_batching_public_inputs.js

@@ -0,0 +1,168 @@
+import { BLS12_FQ_LIMBS, BLS12_FR_LIMBS } from '@aztec/constants';
+import { BLS12Fq, BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
+/**
+ * See nr BlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
+ */ export class BlobAccumulatorPublicInputs {
+    blobCommitmentsHashAcc;
+    zAcc;
+    yAcc;
+    cAcc;
+    gammaAcc;
+    gammaPowAcc;
+    constructor(blobCommitmentsHashAcc, zAcc, yAcc, cAcc, gammaAcc, gammaPowAcc){
+        this.blobCommitmentsHashAcc = blobCommitmentsHashAcc;
+        this.zAcc = zAcc;
+        this.yAcc = yAcc;
+        this.cAcc = cAcc;
+        this.gammaAcc = gammaAcc;
+        this.gammaPowAcc = gammaPowAcc;
+    }
+    static empty() {
+        return new BlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO);
+    }
+    equals(other) {
+        return this.blobCommitmentsHashAcc.equals(other.blobCommitmentsHashAcc) && this.zAcc.equals(other.zAcc) && this.yAcc.equals(other.yAcc) && this.cAcc.equals(other.cAcc) && this.gammaAcc.equals(other.gammaAcc) && this.gammaPowAcc.equals(other.gammaPowAcc);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BlobAccumulatorPublicInputs(Fr.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader), BLS12Point.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.gammaAcc, this.gammaPowAcc);
+    }
+    /**
+   * 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.
+   */ async accumulateBlobs(blobs, finalBlobChallenges) {
+        let acc = new BatchedBlobAccumulator(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, BLS12Point.ZERO, this.gammaAcc, this.gammaPowAcc, finalBlobChallenges);
+        acc = await acc.accumulateBlobs(blobs);
+        return new BlobAccumulatorPublicInputs(acc.blobCommitmentsHashAcc, acc.zAcc, acc.yAcc, acc.cAcc, acc.gammaAcc, acc.gammaPow);
+    }
+    toFields() {
+        return [
+            this.blobCommitmentsHashAcc,
+            this.zAcc,
+            ...this.yAcc.toNoirBigNum().limbs.map(Fr.fromString),
+            ...this.cAcc.x.toNoirBigNum().limbs.map(Fr.fromString),
+            ...this.cAcc.y.toNoirBigNum().limbs.map(Fr.fromString),
+            new Fr(this.cAcc.isInfinite),
+            this.gammaAcc,
+            ...this.gammaPowAcc.toNoirBigNum().limbs.map(Fr.fromString)
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new BlobAccumulatorPublicInputs(reader.readField(), reader.readField(), BLS12Fr.fromNoirBigNum({
+            limbs: reader.readFieldArray(BLS12_FR_LIMBS).map((f)=>f.toString())
+        }), new BLS12Point(BLS12Fq.fromNoirBigNum({
+            limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map((f)=>f.toString())
+        }), BLS12Fq.fromNoirBigNum({
+            limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map((f)=>f.toString())
+        }), reader.readBoolean()), reader.readField(), BLS12Fr.fromNoirBigNum({
+            limbs: reader.readFieldArray(BLS12_FR_LIMBS).map((f)=>f.toString())
+        }));
+    }
+    /**
+   * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
+   * @returns A BlobAccumulatorPublicInputs instance.
+   */ static fromBatchedBlobAccumulator(accumulator) {
+        return new BlobAccumulatorPublicInputs(accumulator.blobCommitmentsHashAcc, accumulator.zAcc, accumulator.yAcc, accumulator.cAcc, accumulator.gammaAcc, accumulator.gammaPow);
+    }
+}
+/**
+ * See nr FinalBlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
+ */ export class FinalBlobAccumulatorPublicInputs {
+    blobCommitmentsHash;
+    z;
+    y;
+    c;
+    constructor(blobCommitmentsHash, z, y, c){
+        this.blobCommitmentsHash = blobCommitmentsHash;
+        this.z = z;
+        this.y = y;
+        this.c = c;
+    }
+    static empty() {
+        return new FinalBlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new FinalBlobAccumulatorPublicInputs(Fr.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader), BLS12Point.fromBuffer(reader));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.blobCommitmentsHash, this.z, this.y, this.c);
+    }
+    static fromBatchedBlob(blob) {
+        return new FinalBlobAccumulatorPublicInputs(blob.blobCommitmentsHash, blob.z, blob.y, blob.commitment);
+    }
+    toFields() {
+        return [
+            this.blobCommitmentsHash,
+            this.z,
+            ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
+            ...this.c.toBN254Fields()
+        ];
+    }
+    // The below is used to send to L1 for proof verification
+    toString() {
+        // We prepend 32 bytes for the (unused) 'blobHash' slot. This is not read or required by getEpochProofPublicInputs() on L1, but
+        // is expected since we usually pass the full precompile inputs via verifyEpochRootProof() to getEpochProofPublicInputs() to ensure
+        // we use calldata rather than a slice in memory:
+        const buf = Buffer.concat([
+            Buffer.alloc(32),
+            this.z.toBuffer(),
+            this.y.toBuffer(),
+            this.c.compress()
+        ]);
+        return buf.toString('hex');
+    }
+    equals(other) {
+        return this.blobCommitmentsHash.equals(other.blobCommitmentsHash) && this.z.equals(other.z) && this.y.equals(other.y) && this.c.equals(other.c);
+    }
+    // Creates a random instance. Used for testing only - will not prove/verify.
+    static random() {
+        return new FinalBlobAccumulatorPublicInputs(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
+    }
+    // Warning: MUST be final accumulator state.
+    static fromBatchedBlobAccumulator(accumulator) {
+        return new FinalBlobAccumulatorPublicInputs(accumulator.blobCommitmentsHashAcc, accumulator.zAcc, accumulator.yAcc, accumulator.cAcc);
+    }
+    [inspect.custom]() {
+        return `FinalBlobAccumulatorPublicInputs {
+      blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
+      z: ${inspect(this.z)},
+      y: ${inspect(this.y)},
+      c: ${inspect(this.c)},
+    }`;
+    }
+}
+/**
+ * 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 class BlockBlobPublicInputs {
+    startBlobAccumulator;
+    endBlobAccumulator;
+    finalBlobChallenges;
+    constructor(startBlobAccumulator, endBlobAccumulator, finalBlobChallenges){
+        this.startBlobAccumulator = startBlobAccumulator;
+        this.endBlobAccumulator = endBlobAccumulator;
+        this.finalBlobChallenges = finalBlobChallenges;
+    }
+    static empty() {
+        return new BlockBlobPublicInputs(BlobAccumulatorPublicInputs.empty(), BlobAccumulatorPublicInputs.empty(), FinalBlobBatchingChallenges.empty());
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BlockBlobPublicInputs(reader.readObject(BlobAccumulatorPublicInputs), reader.readObject(BlobAccumulatorPublicInputs), reader.readObject(FinalBlobBatchingChallenges));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.startBlobAccumulator, this.endBlobAccumulator, this.finalBlobChallenges);
+    }
+}

package/dest/index.d.ts

@@ -1,7 +1,8 @@
 export * from './blob.js';
+export * from './blob_batching.js';
 export * from './encoding.js';
 export * from './interface.js';
 export * from './errors.js';
-export * from './blob_public_inputs.js';
+export * from './blob_batching_public_inputs.js';
 export * from './sponge_blob.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,kBAAkB,CAAC"}

package/dest/index.js

@@ -1,13 +1,14 @@
 import cKzg from 'c-kzg';
-/* eslint-disable import/no-named-as-default-member */ const { loadTrustedSetup } = cKzg;
+const { loadTrustedSetup } = cKzg;
 export * from './blob.js';
+export * from './blob_batching.js';
 export * from './encoding.js';
 export * from './interface.js';
 export * from './errors.js';
-export * from './blob_public_inputs.js';
+export * from './blob_batching_public_inputs.js';
 export * from './sponge_blob.js';
 try {
-    loadTrustedSetup();
+    loadTrustedSetup(8); // See https://notes.ethereum.org/@jtraglia/windowed_multiplications
 } catch (error) {
     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,

package/dest/interface.d.ts

@@ -3,8 +3,7 @@
  */
 export interface BlobJson {
     blob: string;
-    index?: number;
+    index: string;
     kzg_commitment: string;
-    kzg_proof: string;
 }
 //# sourceMappingURL=interface.d.ts.map

package/dest/interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,cAAc,EAAE,MAAM,CAAC;IAEvB,SAAS,EAAE,MAAM,CAAC;CACnB"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;CACxB"}

package/dest/sponge_blob.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { type FieldsOf } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, type Tuple } from '@aztec/foundation/serialize';
@@ -22,7 +20,7 @@ export declare class SpongeBlob {
     /** Number of effects that will be absorbed. */
     expectedFields: number);
     static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob;
-    toBuffer(): Buffer;
+    toBuffer(): Buffer<ArrayBufferLike>;
     static getFields(fields: FieldsOf<SpongeBlob>): (number | Poseidon2Sponge)[];
     toFields(): Fr[];
     static fromFields(fields: Fr[] | FieldReader): SpongeBlob;
@@ -39,7 +37,7 @@ export declare class Poseidon2Sponge {
     squeezeMode: boolean;
     constructor(cache: Tuple<Fr, 3>, state: Tuple<Fr, 4>, cacheSize: number, squeezeMode: boolean);
     static fromBuffer(buffer: Buffer | BufferReader): Poseidon2Sponge;
-    toBuffer(): Buffer;
+    toBuffer(): Buffer<ArrayBufferLike>;
     static getFields(fields: FieldsOf<Poseidon2Sponge>): (number | boolean | [Fr, Fr, Fr] | [Fr, Fr, Fr, Fr])[];
     toFields(): Fr[];
     static fromFields(fields: Fr[] | FieldReader): Poseidon2Sponge;

package/dest/sponge_blob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sponge_blob.d.ts","sourceRoot":"","sources":["../src/sponge_blob.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,KAAK,QAAQ,EAAa,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,KAAK,EAGX,MAAM,6BAA6B,CAAC;AAErC;;;GAGG;AACH,qBAAa,UAAU;IAEnB,gEAAgE;aAChD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,MAAM,EAAE,MAAM;IACrB,+CAA+C;aAC/B,cAAc,EAAE,MAAM;;IALtC,gEAAgE;IAChD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,MAAM,EAAE,MAAM;IACrB,+CAA+C;IAC/B,cAAc,EAAE,MAAM;IAGxC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU;IAK5D,QAAQ;IAIR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU;IASzD,KAAK;IAIC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAUnB,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC;IAS5B,MAAM,CAAC,KAAK,IAAI,UAAU;IAI1B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU;CAGhD;AAGD,qBAAa,eAAe;IAEjB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM;IACjB,WAAW,EAAE,OAAO;gBAHpB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO;IAG7B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAUjE,QAAQ;IAIR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIlD,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe;IAU9D,MAAM,CAAC,KAAK,IAAI,eAAe;IAS/B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IAU9C,aAAa;IAWb,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAenB,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC;CAQ7B"}
+{"version":3,"file":"sponge_blob.d.ts","sourceRoot":"","sources":["../src/sponge_blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAa,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,KAAK,EAGX,MAAM,6BAA6B,CAAC;AAErC;;;GAGG;AACH,qBAAa,UAAU;IAEnB,gEAAgE;aAChD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,MAAM,EAAE,MAAM;IACrB,+CAA+C;aAC/B,cAAc,EAAE,MAAM;;IALtC,gEAAgE;IAChD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,MAAM,EAAE,MAAM;IACrB,+CAA+C;IAC/B,cAAc,EAAE,MAAM;IAGxC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU;IAK5D,QAAQ;IAIR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU;IASzD,KAAK;IAIC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAUnB,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC;IAS5B,MAAM,CAAC,KAAK,IAAI,UAAU;IAI1B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,UAAU;CAGhD;AAGD,qBAAa,eAAe;IAEjB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM;IACjB,WAAW,EAAE,OAAO;gBAHpB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO;IAG7B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAUjE,QAAQ;IAIR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIlD,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe;IAU9D,MAAM,CAAC,KAAK,IAAI,eAAe;IAS/B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IAU9C,aAAa;IAWb,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE;IAenB,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC;CAQ7B"}

package/dest/testing.d.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
-import { BlobPublicInputs, BlockBlobPublicInputs } from './blob_public_inputs.js';
+import { BatchedBlobAccumulator } from './blob_batching.js';
+import { BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
 import { SpongeBlob } from './sponge_blob.js';
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
@@ -10,12 +11,12 @@ import { SpongeBlob } from './sponge_blob.js';
  */
 export declare function makeSpongeBlob(seed?: number): SpongeBlob;
 /**
- * Makes arbitrary 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 blob public inputs instance.
+ * @param seed - The seed to use for generating the blob accumulator.
+ * @returns A blob accumulator instance.
  */
-export declare function makeBlobPublicInputs(seed?: number): BlobPublicInputs;
+export declare function makeBatchedBlobAccumulator(seed?: number): BatchedBlobAccumulator;
 /**
  * Makes arbitrary block blob public inputs.
  * Note: will not verify inside the circuit.