@aztec/blob-lib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/dest/batched_blob.d.ts

@@ -0,0 +1,26 @@
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FinalBlobAccumulator } from './circuit_types/index.js';
+/**
+ * A class to represent the result from accumulating blobs in an epoch using BatchedBlobAccumulator.
+ */
+export declare class BatchedBlob {
+    readonly blobCommitmentsHash: Fr;
+    readonly z: Fr;
+    readonly y: BLS12Fr;
+    readonly commitment: BLS12Point;
+    readonly q: BLS12Point;
+    constructor(
+    /** Hash of Cs (to link to L1 blob hashes). */
+    blobCommitmentsHash: Fr, 
+    /** Challenge point z such that p_i(z) = y_i. */
+    z: Fr, 
+    /** Evaluation y, linear combination of all evaluations y_i = p_i(z) with gamma. */
+    y: BLS12Fr, 
+    /** Commitment C, linear combination of all commitments C_i = [p_i] with gamma. */
+    commitment: BLS12Point, 
+    /** KZG opening 'proof' Q (commitment to the quotient poly.), linear combination of all blob kzg 'proofs' Q_i with gamma. */
+    q: BLS12Point);
+    toFinalBlobAccumulator(): FinalBlobAccumulator;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF0Y2hlZF9ibG9iLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYmF0Y2hlZF9ibG9iLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDckUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRWhFOztHQUVHO0FBQ0gscUJBQWEsV0FBVzthQUdKLG1CQUFtQixFQUFFLEVBQUU7YUFFdkIsQ0FBQyxFQUFFLEVBQUU7YUFFTCxDQUFDLEVBQUUsT0FBTzthQUVWLFVBQVUsRUFBRSxVQUFVO2FBRXRCLENBQUMsRUFBRSxVQUFVO0lBVi9CO0lBQ0UsOENBQThDO0lBQzlCLG1CQUFtQixFQUFFLEVBQUU7SUFDdkMsZ0RBQWdEO0lBQ2hDLENBQUMsRUFBRSxFQUFFO0lBQ3JCLG1GQUFtRjtJQUNuRSxDQUFDLEVBQUUsT0FBTztJQUMxQixrRkFBa0Y7SUFDbEUsVUFBVSxFQUFFLFVBQVU7SUFDdEMsNEhBQTRIO0lBQzVHLENBQUMsRUFBRSxVQUFVLEVBQzNCO0lBRUosc0JBQXNCLHlCQUVyQjtDQUNGIn0=

package/dest/batched_blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batched_blob.d.ts","sourceRoot":"","sources":["../src/batched_blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;GAEG;AACH,qBAAa,WAAW;aAGJ,mBAAmB,EAAE,EAAE;aAEvB,CAAC,EAAE,EAAE;aAEL,CAAC,EAAE,OAAO;aAEV,UAAU,EAAE,UAAU;aAEtB,CAAC,EAAE,UAAU;IAV/B;IACE,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,EAC3B;IAEJ,sBAAsB,yBAErB;CACF"}

package/dest/batched_blob.js

@@ -0,0 +1,20 @@
+import { FinalBlobAccumulator } from './circuit_types/index.js';
+/**
+ * A class to represent the result from accumulating blobs in an epoch using BatchedBlobAccumulator.
+ */ 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;
+    }
+    toFinalBlobAccumulator() {
+        return new FinalBlobAccumulator(this.blobCommitmentsHash, this.z, this.y, this.commitment);
+    }
+}

package/dest/blob.d.ts

@@ -1,131 +1,94 @@
-import { Fr } from '@aztec/foundation/fields';
+import { FIELDS_PER_BLOB } from '@aztec/constants';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
-import cKzg from 'c-kzg';
-import type { Blob as BlobBuffer } from 'c-kzg';
 import type { BlobJson } from './interface.js';
-export declare const VERSIONED_HASH_VERSION_KZG = 1;
+export { FIELDS_PER_BLOB };
 /**
  * A class to create, manage, and prove EVM blobs.
+ *
+ * @dev Note: All methods in this class do not check the encoding of the given data. It's the responsibility of other
+ * components to ensure that the blob data (which might spread across multiple blobs) was created following the protocol
+ * and is correctly encoded.
  */
 export declare class Blob {
-    /** The blob to be broadcast on L1 in bytes form. */
-    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 for a single blob, used as z_i in batching (see ./blob_batching.ts). */
-    readonly challengeZ: Fr;
-    /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+    readonly data: Uint8Array;
     readonly commitment: 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 for a single blob, used as z_i in batching (see ./blob_batching.ts). */
-    challengeZ: Fr, 
-    /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+    /**
+     * The data to be broadcast on L1 in bytes form.
+     */
+    data: Uint8Array, 
+    /**
+     * Commitment to the blob data. Used in compressed BLS12 point format (48 bytes).
+     */
     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.
-     *
-     * See `./encoding.ts` for more details.
-     *
-     * This method is used to create a Blob from a buffer.
-     * @param blob - The buffer to create the Blob from.
-     * @param multiBlobFieldsHash - The fields hash to use for the Blob.
+     * Create a Blob from a buffer.
+     * @param data - The buffer of the Blob.
      * @returns A Blob created from the buffer.
      *
-     * @throws If unable to deserialize the blob.
+     * @throws If data does not match the expected length (BYTES_PER_BLOB).
      */
-    static fromEncodedBlobBuffer(blob: BlobBuffer, multiBlobFieldsHash?: Fr): Promise<Blob>;
+    static fromBlobBuffer(data: Uint8Array): Blob;
     /**
      * Create a Blob from an array of fields.
      *
+     * @dev This method pads 0s to the data, extending it to the size of a full blob.
+     *
      * @param fields - The array of fields to create the Blob from.
-     * @param multiBlobFieldsHash - The fields hash to use for the Blob.
      * @returns A Blob created from the array of fields.
      */
-    static fromFields(fields: Fr[], multiBlobFieldsHash?: Fr): Promise<Blob>;
+    static fromFields(fields: Fr[]): Blob;
+    /**
+     * Get the fields from the blob data.
+     *
+     * @dev WARNING: this method returns all fields
+     *
+     * @returns The fields from the blob.
+     */
+    toFields(): Fr[];
     /**
      * Create a Blob from a JSON object.
      *
-     * Blobs will be in this form when requested from the blob sink, or from
+     * Blobs will be in this form when requested from the blob client, or from
      * the beacon chain via `getBlobSidecars`
      * https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
      *
-     * @dev WARNING: by default json deals with encoded buffers
-     *
      * @param json - The JSON object to create the Blob from.
      * @returns A Blob created from the JSON object.
      */
-    static fromJson(json: BlobJson): Promise<Blob>;
+    static fromJson(json: BlobJson): Blob;
     /**
      * Get the JSON representation of the blob.
      *
-     * @dev WARNING: by default json deals with encoded buffers
-     * @param index - optional - The index of the blob in the block.
      * @returns The JSON representation of the blob.
      */
-    toJson(index: number): BlobJson;
-    /**
-     * Get the fields from the blob.
-     *
-     * @dev WARNING: this method does not take into account trailing zeros
-     *
-     * @returns The fields from the blob.
-     */
-    toFields(): Fr[];
-    /**
-     * Get the encoded fields from the blob.
-     *
-     * @dev This method takes into account trailing zeros
-     *
-     * @returns The encoded fields from the blob.
-     *
-     * @throws If unable to deserialize the blob.
-     */
-    toEncodedFields(): Fr[];
-    /**
-     * Get the encoded fields from multiple blobs.
-     *
-     * @dev This method takes into account trailing zeros
-     *
-     * @returns The encoded fields from the blobs.
-     */
-    static toEncodedFields(blobs: Blob[]): Fr[];
+    toJSON(): BlobJson;
+    getEthVersionedBlobHash(): Buffer;
     /**
-     * Get the commitment fields from the blob.
-     *
-     * The 48-byte commitment is encoded into two field elements:
-     * +------------------+------------------+
-     * | Field Element 1  | Field Element 2  |
-     * | [bytes 0-31]     | [bytes 32-47]   |
-     * +------------------+------------------+
-     * |     32 bytes     |     16 bytes    |
-     * +------------------+------------------+
-     * @returns The commitment fields from the blob.
+     * Challenge point z (= H(H(tx_effects), kzgCommitment)).
+     * Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts).
      */
-    commitmentToFields(): [Fr, Fr];
-    getEthVersionedBlobHash(): Buffer;
-    static getEthVersionedBlobHash(commitment: Buffer): Buffer;
+    computeChallengeZ(blobFieldsHash: Fr): Promise<Fr>;
     /**
      * 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.
+     * @param challengeZ - The challenge z at which to evaluate the blob.
+     * @param verifyProof - Whether to verify the KZG proof.
      *
-     * @returns -
-     *  y: Buffer -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts
+     * @returns
+     *  y: BLS12Fr -  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>;
+    evaluate(challengeZ: Fr, verifyProof?: boolean): {
+        y: BLS12Fr;
         proof: Buffer<ArrayBuffer>;
     };
     /**
      * Get the buffer representation of the ENTIRE blob.
      *
-     * @dev WARNING: this buffer contains all metadata aswell as the data itself
+     * @dev WARNING: this buffer contains all metadata as well as the data itself.
      *
      * @returns The buffer representation of the blob.
      */
@@ -133,7 +96,7 @@ export declare class Blob {
     /**
      * Create a Blob from a buffer.
      *
-     * @dev WARNING: this method contains all metadata aswell as the data itself
+     * @dev WARNING: this method contains all metadata as well as the data itself.
      *
      * @param buf - The buffer to create the Blob from.
      * @returns A Blob created from the buffer.
@@ -143,22 +106,10 @@ export declare class Blob {
      * Get the size of the blob in bytes
      */
     getSize(): number;
-    /**
-     * @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: Blob[]): `0x${string}`;
     static getViemKzgInstance(): {
-        blobToKzgCommitment: typeof cKzg.blobToKzgCommitment;
-        computeBlobKzgProof: typeof cKzg.computeBlobKzgProof;
+        blobToKzgCommitment: (blob: Uint8Array<ArrayBufferLike>) => Uint8Array<ArrayBufferLike>;
+        computeBlobKzgProof: (blob: Uint8Array<ArrayBufferLike>, commitment: Uint8Array<ArrayBufferLike>) => Uint8Array<ArrayBufferLike>;
+        computeCellsAndKzgProofs: (b: Uint8Array<ArrayBufferLike>) => [Uint8Array<ArrayBufferLike>[], Uint8Array<ArrayBufferLike>[]];
     };
-    /**
-     * @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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYi5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Jsb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUFFLFlBQVksRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUc5RSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUcvQyxPQUFPLEVBQUUsZUFBZSxFQUFFLENBQUM7QUFFM0I7Ozs7OztHQU1HO0FBQ0gscUJBQWEsSUFBSTthQUtHLElBQUksRUFBRSxVQUFVO2FBSWhCLFVBQVUsRUFBRSxNQUFNO0lBUnBDO0lBQ0U7O09BRUc7SUFDYSxJQUFJLEVBQUUsVUFBVTtJQUNoQzs7T0FFRztJQUNhLFVBQVUsRUFBRSxNQUFNLEVBUW5DO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FHNUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsSUFBSSxDQVFwQztJQUVEOzs7Ozs7T0FNRztJQUNILFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FJZjtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNILE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFFBQVEsR0FBRyxJQUFJLENBU3BDO0lBRUQ7Ozs7T0FJRztJQUNILE1BQU0sSUFBSSxRQUFRLENBTWpCO0lBRUQsdUJBQXVCLElBQUksTUFBTSxDQUVoQztJQUVEOzs7T0FHRztJQUNHLGlCQUFpQixDQUFDLGNBQWMsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUV2RDtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNILFFBQVEsQ0FBQyxVQUFVLEVBQUUsRUFBRSxFQUFFLFdBQVcsVUFBUTs7O01BVTNDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsUUFBUSxJQUFJLE1BQU0sQ0FFakI7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxJQUFJLENBR2xEO0lBRUQ7O09BRUc7SUFDSCxPQUFPLFdBRU47SUFFRCxNQUFNLENBQUMsa0JBQWtCOzs7O01BVXhCO0NBQ0YifQ==

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,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"}
+{"version":3,"file":"blob.d.ts","sourceRoot":"","sources":["../src/blob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B;;;;;;GAMG;AACH,qBAAa,IAAI;aAKG,IAAI,EAAE,UAAU;aAIhB,UAAU,EAAE,MAAM;IARpC;IACE;;OAEG;IACa,IAAI,EAAE,UAAU;IAChC;;OAEG;IACa,UAAU,EAAE,MAAM,EAQnC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAG5C;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,CAQpC;IAED;;;;;;OAMG;IACH,QAAQ,IAAI,EAAE,EAAE,CAIf;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CASpC;IAED;;;;OAIG;IACH,MAAM,IAAI,QAAQ,CAMjB;IAED,uBAAuB,IAAI,MAAM,CAEhC;IAED;;;OAGG;IACG,iBAAiB,CAAC,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAEvD;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,EAAE,EAAE,EAAE,WAAW,UAAQ;;;MAU3C;IAED;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAGlD;IAED;;OAEG;IACH,OAAO,WAEN;IAED,MAAM,CAAC,kBAAkB;;;;MAUxB;CACF"}

package/dest/blob.js

@@ -1,181 +1,125 @@
-import { poseidon2Hash, sha256 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { FIELDS_PER_BLOB } from '@aztec/constants';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-// Importing directly from 'c-kzg' does not work:
-import cKzg from 'c-kzg';
-import { deserializeEncodedBlobToFields, extractBlobFieldsFromBuffer } from './encoding.js';
-import { BlobDeserializationError } from './errors.js';
-const { BYTES_PER_BLOB, FIELD_ELEMENTS_PER_BLOB, blobToKzgCommitment, computeKzgProof, verifyKzgProof } = cKzg;
-// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
-export const VERSIONED_HASH_VERSION_KZG = 0x01;
+import { computeBlobCommitment, computeChallengeZ, computeEthVersionedBlobHash } from './hash.js';
+import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, getKzg } from './kzg_context.js';
+export { FIELDS_PER_BLOB };
 /**
  * A class to create, manage, and prove EVM blobs.
+ *
+ * @dev Note: All methods in this class do not check the encoding of the given data. It's the responsibility of other
+ * components to ensure that the blob data (which might spread across multiple blobs) was created following the protocol
+ * and is correctly encoded.
  */ export class Blob {
     data;
-    fieldsHash;
-    challengeZ;
     commitment;
-    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){
+    constructor(/**
+     * The data to be broadcast on L1 in bytes form.
+     */ data, /**
+     * Commitment to the blob data. Used in compressed BLS12 point format (48 bytes).
+     */ commitment){
         this.data = data;
-        this.fieldsHash = fieldsHash;
-        this.challengeZ = challengeZ;
         this.commitment = commitment;
+        if (data.length !== BYTES_PER_BLOB) {
+            throw new Error(`Blob data must be ${BYTES_PER_BLOB} bytes. Got ${data.length}.`);
+        }
+        if (commitment.length !== BYTES_PER_COMMITMENT) {
+            throw new Error(`Blob commitment must be ${BYTES_PER_COMMITMENT} bytes. Got ${commitment.length}.`);
+        }
     }
     /**
-   * 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.
-   *
-   * See `./encoding.ts` for more details.
-   *
-   * This method is used to create a Blob from a buffer.
-   * @param blob - The buffer to create the Blob from.
-   * @param multiBlobFieldsHash - The fields hash to use for the Blob.
+   * Create a Blob from a buffer.
+   * @param data - The buffer of the Blob.
    * @returns A Blob created from the buffer.
    *
-   * @throws If unable to deserialize the blob.
-   */ static fromEncodedBlobBuffer(blob, multiBlobFieldsHash) {
-        try {
-            const fields = deserializeEncodedBlobToFields(blob);
-            return Blob.fromFields(fields, multiBlobFieldsHash);
-        } catch  {
-            throw new BlobDeserializationError(`Failed to create Blob from encoded blob buffer, this blob was likely not created by us`);
-        }
+   * @throws If data does not match the expected length (BYTES_PER_BLOB).
+   */ static fromBlobBuffer(data) {
+        const commitment = computeBlobCommitment(data);
+        return new Blob(data, commitment);
     }
     /**
    * Create a Blob from an array of fields.
    *
+   * @dev This method pads 0s to the data, extending it to the size of a full blob.
+   *
    * @param fields - The array of fields to create the Blob from.
-   * @param multiBlobFieldsHash - The fields hash to use for the Blob.
    * @returns A Blob created from the array of fields.
-   */ static async fromFields(fields, multiBlobFieldsHash) {
-        if (fields.length > FIELD_ELEMENTS_PER_BLOB) {
-            throw new Error(`Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELD_ELEMENTS_PER_BLOB}`);
+   */ static fromFields(fields) {
+        if (fields.length > FIELDS_PER_BLOB) {
+            throw new Error(`Attempted to overfill blob with ${fields.length} fields. The maximum is ${FIELDS_PER_BLOB}.`);
         }
         const data = Buffer.concat([
             serializeToBuffer(fields)
         ], BYTES_PER_BLOB);
-        // This matches the output of SpongeBlob.squeeze() in the blob circuit
-        const fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : await poseidon2Hash(fields);
-        const commitment = Buffer.from(blobToKzgCommitment(data));
-        const challengeZ = await poseidon2Hash([
-            fieldsHash,
-            ...commitmentToFields(commitment)
-        ]);
-        return new Blob(data, fieldsHash, challengeZ, commitment);
+        const commitment = computeBlobCommitment(data);
+        return new Blob(data, commitment);
+    }
+    /**
+   * Get the fields from the blob data.
+   *
+   * @dev WARNING: this method returns all fields
+   *
+   * @returns The fields from the blob.
+   */ toFields() {
+        const reader = BufferReader.asReader(this.data);
+        const numTotalFields = this.data.length / Fr.SIZE_IN_BYTES;
+        return reader.readArray(numTotalFields, Fr);
     }
     /**
    * Create a Blob from a JSON object.
    *
-   * Blobs will be in this form when requested from the blob sink, or from
+   * Blobs will be in this form when requested from the blob client, or from
    * the beacon chain via `getBlobSidecars`
    * https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
    *
-   * @dev WARNING: by default json deals with encoded buffers
-   *
    * @param json - The JSON object to create the Blob from.
    * @returns A Blob created from the JSON object.
-   */ static async fromJson(json) {
+   */ static fromJson(json) {
         const blobBuffer = Buffer.from(json.blob.slice(2), 'hex');
-        const blob = await Blob.fromEncodedBlobBuffer(blobBuffer);
+        const blob = Blob.fromBlobBuffer(blobBuffer);
         if (blob.commitment.toString('hex') !== json.kzg_commitment.slice(2)) {
             throw new Error('KZG commitment does not match');
         }
-        // We do not check the proof, as it will be different if the challenge is shared
-        // across multiple blobs
         return blob;
     }
     /**
    * Get the JSON representation of the blob.
    *
-   * @dev WARNING: by default json deals with encoded buffers
-   * @param index - optional - The index of the blob in the block.
    * @returns The JSON representation of the blob.
-   */ toJson(index) {
+   */ toJSON() {
         return {
             blob: `0x${Buffer.from(this.data).toString('hex')}`,
-            index: index.toString(),
             // eslint-disable-next-line camelcase
             kzg_commitment: `0x${this.commitment.toString('hex')}`
         };
     }
-    /**
-   * Get the fields from the blob.
-   *
-   * @dev WARNING: this method does not take into account trailing zeros
-   *
-   * @returns The fields from the blob.
-   */ toFields() {
-        return extractBlobFieldsFromBuffer(this.data);
-    }
-    /**
-   * Get the encoded fields from the blob.
-   *
-   * @dev This method takes into account trailing zeros
-   *
-   * @returns The encoded fields from the blob.
-   *
-   * @throws If unable to deserialize the blob.
-   */ toEncodedFields() {
-        try {
-            return deserializeEncodedBlobToFields(this.data);
-        } catch  {
-            throw new BlobDeserializationError(`Failed to deserialize encoded blob fields, this blob was likely not created by us`);
-        }
-    }
-    /**
-   * Get the encoded fields from multiple blobs.
-   *
-   * @dev This method takes into account trailing zeros
-   *
-   * @returns The encoded fields from the blobs.
-   */ static toEncodedFields(blobs) {
-        try {
-            return deserializeEncodedBlobToFields(Buffer.concat(blobs.map((b)=>b.data)));
-        } catch  {
-            throw new BlobDeserializationError(`Failed to deserialize encoded blob fields, this blob was likely not created by us`);
-        }
-    }
-    /**
-   * Get the commitment fields from the blob.
-   *
-   * The 48-byte commitment is encoded into two field elements:
-   * +------------------+------------------+
-   * | Field Element 1  | Field Element 2  |
-   * | [bytes 0-31]     | [bytes 32-47]   |
-   * +------------------+------------------+
-   * |     32 bytes     |     16 bytes    |
-   * +------------------+------------------+
-   * @returns The commitment fields from the blob.
-   */ commitmentToFields() {
-        return commitmentToFields(this.commitment);
-    }
-    // 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);
-        hash[0] = VERSIONED_HASH_VERSION_KZG;
-        return hash;
+        return computeEthVersionedBlobHash(this.commitment);
     }
-    static getEthVersionedBlobHash(commitment) {
-        const hash = sha256(commitment);
-        hash[0] = VERSIONED_HASH_VERSION_KZG;
-        return hash;
+    /**
+   * Challenge point z (= H(H(tx_effects), kzgCommitment)).
+   * Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts).
+   */ async computeChallengeZ(blobFieldsHash) {
+        return await computeChallengeZ(blobFieldsHash, this.commitment);
     }
     /**
    * 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.
+   * @param challengeZ - The challenge z at which to evaluate the blob.
+   * @param verifyProof - Whether to verify the KZG proof.
    *
-   * @returns -
-   *  y: Buffer -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts
+   * @returns
+   *  y: BLS12Fr -  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])) {
+   */ evaluate(challengeZ, verifyProof = false) {
+        const kzg = getKzg();
+        const res = kzg.computeKzgProof(this.data, challengeZ.toBuffer());
+        if (verifyProof && !kzg.verifyKzgProof(this.commitment, challengeZ.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]);
+        const y = BLS12Fr.fromBuffer(Buffer.from(res[1]));
         return {
             y,
             proof
@@ -184,75 +128,40 @@ export const VERSIONED_HASH_VERSION_KZG = 0x01;
     /**
    * Get the buffer representation of the ENTIRE blob.
    *
-   * @dev WARNING: this buffer contains all metadata aswell as the data itself
+   * @dev WARNING: this buffer contains all metadata as well 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.commitment.length, this.commitment));
+        return Buffer.from(serializeToBuffer(this.data.length, this.data, this.commitment.length, this.commitment));
     }
     /**
    * Create a Blob from a buffer.
    *
-   * @dev WARNING: this method contains all metadata aswell as the data itself
+   * @dev WARNING: this method contains all metadata as well as the data itself.
    *
    * @param buf - The buffer to create the Blob from.
    * @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());
+        return new Blob(reader.readUint8Array(), reader.readBuffer());
     }
     /**
    * Get the size of the blob in bytes
    */ getSize() {
         return this.data.length;
     }
-    /**
-   * @param blobs - The blobs to emit
-   * @returns The blobs' compressed commitments in hex prefixed by the number of blobs
-   * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs:
-   * One byte for the number blobs + 48 bytes per blob commitment
-   */ static getPrefixedEthBlobCommitments(blobs) {
-        let buf = Buffer.alloc(0);
-        blobs.forEach((blob)=>{
-            buf = Buffer.concat([
-                buf,
-                blob.commitment
-            ]);
-        });
-        // 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 getViemKzgInstance() {
+        const kzg = getKzg();
         return {
-            blobToKzgCommitment: cKzg.blobToKzgCommitment,
-            computeBlobKzgProof: cKzg.computeBlobKzgProof
+            blobToKzgCommitment: kzg.blobToKzgCommitment.bind(kzg),
+            computeBlobKzgProof: kzg.computeBlobKzgProof.bind(kzg),
+            computeCellsAndKzgProofs: (b)=>{
+                const result = kzg.computeCellsAndKzgProofs(b);
+                return [
+                    result.cells,
+                    result.proofs
+                ];
+            }
         };
     }
-    /**
-   * @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 = [];
-        for(let i = 0; i < numBlobs; i++){
-            const end = fields.length < (i + 1) * FIELD_ELEMENTS_PER_BLOB ? fields.length : (i + 1) * FIELD_ELEMENTS_PER_BLOB;
-            res.push(await Blob.fromFields(fields.slice(i * FIELD_ELEMENTS_PER_BLOB, end), multiBlobFieldsHash));
-        }
-        return res;
-    }
-}
-// 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
-function commitmentToFields(commitment) {
-    return [
-        new Fr(commitment.subarray(0, 31)),
-        new Fr(commitment.subarray(31, 48))
-    ];
 }