@aztec/blob-lib 1.0.0-nightly.20250611 → 1.0.0-nightly.20250613

package/dest/blob.d.ts

@@ -12,27 +12,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.
@@ -117,6 +109,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.
      *
@@ -139,23 +144,21 @@ 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;
     };
-    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;AAK/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,EAAE,MAAM,GAAG,QAAQ;IAW/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;;;;;;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,6BAA6B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE;IAYlE,MAAM,CAAC,kBAAkB;;;;WAWZ,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;;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;;;;IAOzB;;;;OAIG;WACU,gBAAgB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;CAU7D"}

package/dest/blob.js

@@ -14,16 +14,12 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
     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.
@@ -65,13 +61,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.
@@ -105,9 +95,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
             blob: `0x${Buffer.from(this.data).toString('hex')}`,
             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')}`
         };
     }
     /**
@@ -173,13 +161,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 +199,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,47 +207,11 @@ 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) {
-        let buf = Buffer.alloc(0);
-        blobs.forEach((blob)=>{
-            buf = Buffer.concat([
-                buf,
-                blob.getEthVersionedBlobHash(),
-                blob.challengeZ.toBuffer(),
-                blob.evaluationY,
-                blob.commitment,
-                blob.proof
-            ]);
-        });
-        // For multiple blobs, we prefix the number of blobs:
-        const lenBuf = Buffer.alloc(1);
-        lenBuf.writeUint8(blobs.length);
-        buf = Buffer.concat([
-            lenBuf,
-            buf
-        ]);
-        return `0x${buf.toString('hex')}`;
-    }
-    static getPrefixedEthBlobCommitments(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([
@@ -246,7 +219,7 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
                 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([
@@ -261,11 +234,11 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
             computeBlobKzgProof: cKzg.computeBlobKzgProof
         };
     }
-    // Returns as many blobs as we require to broadcast the given fields
-    // Assumes we share the fields hash between all blobs
-    // TODO(MW): Rename to more accurate getBlobsPerBlock() - the items here share a fields hash,
-    // which can only be done for one block because the hash is calculated in block root.
-    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

@@ -1,7 +1,6 @@
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { Blob } from './blob.js';
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from './blob_batching_public_inputs.js';
 /**
  * A class to create, manage, and prove batched EVM blobs.
  */
@@ -29,10 +28,6 @@ export declare class BatchedBlob {
     q: BLS12Point);
     /**
      * Get the final batched opening proof from multiple blobs.
-     *
-     * TODO(MW): Using the old Blob struct means there are ignored values (e.g. blob.evaluationY, because we now evaluate at shared z).
-     * When switching to batching, create new class w/o useless values.
-     *
      * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
      *      beforehand from ALL blobs.
      *
@@ -153,7 +148,6 @@ export declare class BatchedBlobAccumulator {
      * - gamma_acc := poseidon2(y_0.limbs)
      * - gamma^(i + 1) = gamma^1 = gamma // denoted gamma_pow_acc
      *
-     * TODO(MW): When moved to batching, we should ONLY evaluate individual blobs at z => won't need finalZ input.
      * @returns An initial blob accumulator.
      */
     static initialize(blob: Blob, finalBlobChallenges: FinalBlobBatchingChallenges): Promise<BatchedBlobAccumulator>;
@@ -165,7 +159,6 @@ export declare class BatchedBlobAccumulator {
     /**
      * Given blob i, accumulate all state.
      * We assume the input blob has not been evaluated at z.
-     * TODO(MW): Currently returning new accumulator. May be better to mutate in future?
      * @returns An updated blob accumulator.
      */
     accumulate(blob: Blob): Promise<BatchedBlobAccumulator>;
@@ -189,17 +182,7 @@ export declare class BatchedBlobAccumulator {
      * @returns A batched blob.
      */
     finalize(): Promise<BatchedBlob>;
-    /**
-     * Converts to a struct for the public inputs of our rollup circuits.
-     * @returns A BlobAccumulatorPublicInputs instance.
-     */
-    toBlobAccumulatorPublicInputs(): BlobAccumulatorPublicInputs;
-    /**
-     * Converts to a struct for the public inputs of our root rollup circuit.
-     * Warning: MUST be final accumulator state.
-     * @returns A FinalBlobAccumulatorPublicInputs instance.
-     */
-    toFinalBlobAccumulatorPublicInputs(): FinalBlobAccumulatorPublicInputs;
     isEmptyState(): boolean;
+    clone(): BatchedBlobAccumulator;
 }
 //# 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":"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"}
+{"version":3,"file":"blob_batching.d.ts","sourceRoot":"","sources":["../src/blob_batching.ts"],"names":[],"mappings":"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"}

package/dest/blob_batching.js

@@ -5,7 +5,6 @@ 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';
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from './blob_batching_public_inputs.js';
 const { computeKzgProof, verifyKzgProof } = cKzg;
 /**
  * A class to create, manage, and prove batched EVM blobs.
@@ -24,10 +23,6 @@ const { computeKzgProof, verifyKzgProof } = cKzg;
     }
     /**
    * Get the final batched opening proof from multiple blobs.
-   *
-   * TODO(MW): Using the old Blob struct means there are ignored values (e.g. blob.evaluationY, because we now evaluate at shared z).
-   * When switching to batching, create new class w/o useless values.
-   *
    * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
    *      beforehand from ALL blobs.
    *
@@ -209,7 +204,6 @@ const { computeKzgProof, verifyKzgProof } = cKzg;
    * - gamma_acc := poseidon2(y_0.limbs)
    * - gamma^(i + 1) = gamma^1 = gamma // denoted gamma_pow_acc
    *
-   * TODO(MW): When moved to batching, we should ONLY evaluate individual blobs at z => won't need finalZ input.
    * @returns An initial blob accumulator.
    */ static async initialize(blob, finalBlobChallenges) {
         const [q, evaluation] = computeKzgProof(blob.data, finalBlobChallenges.z.toBuffer());
@@ -228,7 +222,6 @@ const { computeKzgProof, verifyKzgProof } = cKzg;
     /**
    * Given blob i, accumulate all state.
    * We assume the input blob has not been evaluated at z.
-   * TODO(MW): Currently returning new accumulator. May be better to mutate in future?
    * @returns An updated blob accumulator.
    */ async accumulate(blob) {
         if (this.isEmptyState()) {
@@ -254,8 +247,8 @@ const { computeKzgProof, verifyKzgProof } = cKzg;
    * We assume the input blobs have not been evaluated at z.
    * @returns An updated blob accumulator.
    */ async accumulateBlobs(blobs) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let acc = this; // TODO(MW): this.clone()
+        // Initialise the acc to iterate over:
+        let acc = this.clone();
         for(let i = 0; i < blobs.length; i++){
             acc = await acc.accumulate(blobs[i]);
         }
@@ -291,22 +284,12 @@ const { computeKzgProof, verifyKzgProof } = cKzg;
         }
         return new BatchedBlob(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.qAcc);
     }
-    /**
-   * Converts to a struct for the public inputs of our rollup circuits.
-   * @returns A BlobAccumulatorPublicInputs instance.
-   */ toBlobAccumulatorPublicInputs() {
-        return new BlobAccumulatorPublicInputs(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.gammaAcc, this.gammaPow);
-    }
-    /**
-   * Converts to a struct for the public inputs of our root rollup circuit.
-   * Warning: MUST be final accumulator state.
-   * @returns A FinalBlobAccumulatorPublicInputs instance.
-   */ toFinalBlobAccumulatorPublicInputs() {
-        return new FinalBlobAccumulatorPublicInputs(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc);
-    }
     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.

package/dest/blob_batching_public_inputs.d.ts

@@ -28,6 +28,11 @@ export declare class BlobAccumulatorPublicInputs {
     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.
@@ -46,6 +51,7 @@ export declare class FinalBlobAccumulatorPublicInputs {
     toString(): string;
     equals(other: FinalBlobAccumulatorPublicInputs): boolean;
     static random(): FinalBlobAccumulatorPublicInputs;
+    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): FinalBlobAccumulatorPublicInputs;
     [inspect.custom](): string;
 }
 /**
@@ -61,6 +67,5 @@ export declare class BlockBlobPublicInputs {
     static empty(): BlockBlobPublicInputs;
     static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs;
     toBuffer(): Buffer<ArrayBufferLike>;
-    static fromBlobs(startBlobAccumulator: BatchedBlobAccumulator, blobs: Blob[]): Promise<BlockBlobPublicInputs>;
 }
 //# sourceMappingURL=blob_batching_public_inputs.d.ts.map

package/dest/blob_batching_public_inputs.d.ts.map

@@ -1 +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;CAe3E;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;IAWR,QAAQ;IAQR,MAAM,CAAC,KAAK,EAAE,gCAAgC;IAU9C,MAAM,CAAC,MAAM;IAIb,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;WAQK,SAAS,CAAC,oBAAoB,EAAE,sBAAsB,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAQpH"}
+{"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

@@ -68,6 +68,12 @@ import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batc
             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.
@@ -100,11 +106,7 @@ import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batc
             this.blobCommitmentsHash,
             this.z,
             ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
-            // TODO(MW): add conversion when public inputs finalised
-            ...[
-                new Fr(this.c.compress().subarray(0, 31)),
-                new Fr(this.c.compress().subarray(31, 48))
-            ]
+            ...this.c.toBN254Fields()
         ];
     }
     // The below is used to send to L1 for proof verification
@@ -127,6 +129,10 @@ import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batc
     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)},
@@ -159,12 +165,4 @@ import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batc
     toBuffer() {
         return serializeToBuffer(this.startBlobAccumulator, this.endBlobAccumulator, this.finalBlobChallenges);
     }
-    // Creates BlockBlobPublicInputs from the starting accumulator state and all blobs in the block.
-    // Assumes that startBlobAccumulator.finalChallenges have already been precomputed.
-    // Does not finalise challenge values (this is done in the final root rollup).
-    // TODO(MW): Integrate with BatchedBlob once old Blob classes removed
-    static async fromBlobs(startBlobAccumulator, blobs) {
-        const endBlobAccumulator = await startBlobAccumulator.accumulateBlobs(blobs);
-        return new BlockBlobPublicInputs(startBlobAccumulator.toBlobAccumulatorPublicInputs(), endBlobAccumulator.toBlobAccumulatorPublicInputs(), startBlobAccumulator.finalBlobChallenges);
-    }
 }

package/dest/interface.d.ts

@@ -5,6 +5,5 @@ export interface BlobJson {
     blob: string;
     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,EAAE,MAAM,CAAC;IAEd,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/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAA+B,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAEzE,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,SAAI,GAAG,qBAAqB,CAOzE;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAA+B,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAA+B,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAEtG,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,SAAI,GAAG,qBAAqB,CAOzE;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}

package/dest/testing.js

@@ -3,7 +3,7 @@ import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
 import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-import { BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
+import { BlobAccumulatorPublicInputs, BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
 import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 /**
@@ -29,7 +29,7 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
  * @returns A block blob public inputs instance.
  */ export function makeBlockBlobPublicInputs(seed = 1) {
     const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
-    return new BlockBlobPublicInputs(startBlobAccumulator.toBlobAccumulatorPublicInputs(), makeBatchedBlobAccumulator(seed + 1).toBlobAccumulatorPublicInputs(), startBlobAccumulator.finalBlobChallenges);
+    return new BlockBlobPublicInputs(BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(startBlobAccumulator), BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 1)), startBlobAccumulator.finalBlobChallenges);
 }
 // TODO: copied form stdlib tx effect
 function encodeFirstField(length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/blob-lib",
-  "version": "1.0.0-nightly.20250611",
+  "version": "1.0.0-nightly.20250613",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -25,8 +25,8 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/constants": "1.0.0-nightly.20250611",
-    "@aztec/foundation": "1.0.0-nightly.20250611",
+    "@aztec/constants": "1.0.0-nightly.20250613",
+    "@aztec/foundation": "1.0.0-nightly.20250613",
     "c-kzg": "4.0.0-alpha.1",
     "tslib": "^2.4.0"
   },

package/src/blob.ts

@@ -24,14 +24,10 @@ export class Blob {
     public 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. */
     public 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). */
     public readonly challengeZ: Fr,
-    /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */
-    public readonly evaluationY: Buffer,
     /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
     public readonly commitment: Buffer,
-    /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */
-    public readonly proof: Buffer,
   ) {}
 
   /**
@@ -78,14 +74,8 @@ export class Blob {
     const fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : await poseidon2Hash(fields);
     const commitment = Buffer.from(blobToKzgCommitment(data));
     const challengeZ = await poseidon2Hash([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);
   }
 
   /**
@@ -128,8 +118,6 @@ export class Blob {
       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')}`,
     };
   }
 
@@ -209,6 +197,26 @@ export class Blob {
     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?: Fr) {
+    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.
    *
@@ -223,12 +231,8 @@ export class Blob {
         this.data,
         this.fieldsHash,
         this.challengeZ,
-        this.evaluationY.length,
-        this.evaluationY,
         this.commitment.length,
         this.commitment,
-        this.proof.length,
-        this.proof,
       ),
     );
   }
@@ -243,14 +247,7 @@ export class Blob {
    */
   static fromBuffer(buf: Buffer | BufferReader): Blob {
     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());
   }
 
   /**
@@ -261,52 +258,17 @@ export class Blob {
   }
 
   /**
-   * 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}` {
-    const buf = Buffer.concat([
-      this.getEthVersionedBlobHash(),
-      this.challengeZ.toBuffer(),
-      this.evaluationY,
-      this.commitment,
-      this.proof,
-    ]);
-    return `0x${buf.toString('hex')}`;
-  }
-
-  static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}` {
-    let buf = Buffer.alloc(0);
-    blobs.forEach(blob => {
-      buf = Buffer.concat([
-        buf,
-        blob.getEthVersionedBlobHash(),
-        blob.challengeZ.toBuffer(),
-        blob.evaluationY,
-        blob.commitment,
-        blob.proof,
-      ]);
-    });
-    // For multiple blobs, we prefix the number of blobs:
-    const lenBuf = Buffer.alloc(1);
-    lenBuf.writeUint8(blobs.length);
-    buf = Buffer.concat([lenBuf, buf]);
-    return `0x${buf.toString('hex')}`;
-  }
-
   static getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}` {
     let buf = Buffer.alloc(0);
     blobs.forEach(blob => {
       buf = Buffer.concat([buf, 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([lenBuf, buf]);
@@ -320,11 +282,12 @@ export class Blob {
     };
   }
 
-  // Returns as many blobs as we require to broadcast the given fields
-  // Assumes we share the fields hash between all blobs
-  // TODO(MW): Rename to more accurate getBlobsPerBlock() - the items here share a fields hash,
-  // which can only be done for one block because the hash is calculated in block root.
-  static async 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 async getBlobsPerBlock(fields: Fr[]): Promise<Blob[]> {
     const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
     const multiBlobFieldsHash = await poseidon2Hash(fields);
     const res = [];

package/src/blob_batching.ts

@@ -7,7 +7,6 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import cKzg from 'c-kzg';
 
 import { Blob, VERSIONED_HASH_VERSION_KZG } from './blob.js';
-import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from './blob_batching_public_inputs.js';
 
 const { computeKzgProof, verifyKzgProof } = cKzg;
 
@@ -30,10 +29,6 @@ export class BatchedBlob {
 
   /**
    * Get the final batched opening proof from multiple blobs.
-   *
-   * TODO(MW): Using the old Blob struct means there are ignored values (e.g. blob.evaluationY, because we now evaluate at shared z).
-   * When switching to batching, create new class w/o useless values.
-   *
    * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
    *      beforehand from ALL blobs.
    *
@@ -222,7 +217,6 @@ export class BatchedBlobAccumulator {
    * - gamma_acc := poseidon2(y_0.limbs)
    * - gamma^(i + 1) = gamma^1 = gamma // denoted gamma_pow_acc
    *
-   * TODO(MW): When moved to batching, we should ONLY evaluate individual blobs at z => won't need finalZ input.
    * @returns An initial blob accumulator.
    */
   static async initialize(
@@ -264,7 +258,6 @@ export class BatchedBlobAccumulator {
   /**
    * Given blob i, accumulate all state.
    * We assume the input blob has not been evaluated at z.
-   * TODO(MW): Currently returning new accumulator. May be better to mutate in future?
    * @returns An updated blob accumulator.
    */
   async accumulate(blob: Blob) {
@@ -294,8 +287,8 @@ export class BatchedBlobAccumulator {
    * @returns An updated blob accumulator.
    */
   async accumulateBlobs(blobs: Blob[]) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    let acc: BatchedBlobAccumulator = this; // TODO(MW): this.clone()
+    // Initialise the acc to iterate over:
+    let acc: BatchedBlobAccumulator = this.clone();
     for (let i = 0; i < blobs.length; i++) {
       acc = await acc.accumulate(blobs[i]);
     }
@@ -336,30 +329,6 @@ export class BatchedBlobAccumulator {
     return new BatchedBlob(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.qAcc);
   }
 
-  /**
-   * Converts to a struct for the public inputs of our rollup circuits.
-   * @returns A BlobAccumulatorPublicInputs instance.
-   */
-  toBlobAccumulatorPublicInputs() {
-    return new BlobAccumulatorPublicInputs(
-      this.blobCommitmentsHashAcc,
-      this.zAcc,
-      this.yAcc,
-      this.cAcc,
-      this.gammaAcc,
-      this.gammaPow,
-    );
-  }
-
-  /**
-   * Converts to a struct for the public inputs of our root rollup circuit.
-   * Warning: MUST be final accumulator state.
-   * @returns A FinalBlobAccumulatorPublicInputs instance.
-   */
-  toFinalBlobAccumulatorPublicInputs() {
-    return new FinalBlobAccumulatorPublicInputs(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc);
-  }
-
   isEmptyState() {
     return (
       this.blobCommitmentsHashAcc.isZero() &&
@@ -371,6 +340,19 @@ export class BatchedBlobAccumulator {
       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

package/src/blob_batching_public_inputs.ts

@@ -115,6 +115,21 @@ export class BlobAccumulatorPublicInputs {
       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: BatchedBlobAccumulator) {
+    return new BlobAccumulatorPublicInputs(
+      accumulator.blobCommitmentsHashAcc,
+      accumulator.zAcc,
+      accumulator.yAcc,
+      accumulator.cAcc,
+      accumulator.gammaAcc,
+      accumulator.gammaPow,
+    );
+  }
 }
 
 /**
@@ -155,8 +170,7 @@ export class FinalBlobAccumulatorPublicInputs {
       this.blobCommitmentsHash,
       this.z,
       ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
-      // TODO(MW): add conversion when public inputs finalised
-      ...[new Fr(this.c.compress().subarray(0, 31)), new Fr(this.c.compress().subarray(31, 48))],
+      ...this.c.toBN254Fields(),
     ];
   }
 
@@ -183,6 +197,16 @@ export class FinalBlobAccumulatorPublicInputs {
     return new FinalBlobAccumulatorPublicInputs(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
   }
 
+  // Warning: MUST be final accumulator state.
+  static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    return new FinalBlobAccumulatorPublicInputs(
+      accumulator.blobCommitmentsHashAcc,
+      accumulator.zAcc,
+      accumulator.yAcc,
+      accumulator.cAcc,
+    );
+  }
+
   [inspect.custom]() {
     return `FinalBlobAccumulatorPublicInputs {
       blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
@@ -225,17 +249,4 @@ export class BlockBlobPublicInputs {
   toBuffer() {
     return serializeToBuffer(this.startBlobAccumulator, this.endBlobAccumulator, this.finalBlobChallenges);
   }
-
-  // Creates BlockBlobPublicInputs from the starting accumulator state and all blobs in the block.
-  // Assumes that startBlobAccumulator.finalChallenges have already been precomputed.
-  // Does not finalise challenge values (this is done in the final root rollup).
-  // TODO(MW): Integrate with BatchedBlob once old Blob classes removed
-  static async fromBlobs(startBlobAccumulator: BatchedBlobAccumulator, blobs: Blob[]): Promise<BlockBlobPublicInputs> {
-    const endBlobAccumulator = await startBlobAccumulator.accumulateBlobs(blobs);
-    return new BlockBlobPublicInputs(
-      startBlobAccumulator.toBlobAccumulatorPublicInputs(),
-      endBlobAccumulator.toBlobAccumulatorPublicInputs(),
-      startBlobAccumulator.finalBlobChallenges,
-    );
-  }
 }

package/src/interface.ts

@@ -4,8 +4,5 @@
 export interface BlobJson {
   blob: string;
   index: string;
-
   kzg_commitment: string;
-
-  kzg_proof: string;
 }

package/src/testing.ts

@@ -4,7 +4,7 @@ import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
 import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-import { BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
+import { BlobAccumulatorPublicInputs, BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
 import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 
@@ -55,8 +55,8 @@ export function makeBatchedBlobAccumulator(seed = 1): BatchedBlobAccumulator {
 export function makeBlockBlobPublicInputs(seed = 1): BlockBlobPublicInputs {
   const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
   return new BlockBlobPublicInputs(
-    startBlobAccumulator.toBlobAccumulatorPublicInputs(),
-    makeBatchedBlobAccumulator(seed + 1).toBlobAccumulatorPublicInputs(),
+    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(startBlobAccumulator),
+    BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(makeBatchedBlobAccumulator(seed + 1)),
     startBlobAccumulator.finalBlobChallenges,
   );
 }