@aztec/blob-lib 0.0.0-test.0

package/dest/blob.d.ts

@@ -0,0 +1,162 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import cKzg from 'c-kzg';
+import type { Blob as BlobBuffer } from 'c-kzg';
+import type { BlobJson } from './interface.js';
+export declare const VERSIONED_HASH_VERSION_KZG = 1;
+/**
+ * A class to create, manage, and prove EVM blobs.
+ */
+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. */
+    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. */
+    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);
+    /**
+     * 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.
+     * @returns A Blob created from the buffer.
+     *
+     * @throws If unable to deserialize the blob.
+     */
+    static fromEncodedBlobBuffer(blob: BlobBuffer, multiBlobFieldsHash?: Fr): Promise<Blob>;
+    /**
+     * Create a Blob from an array of fields.
+     *
+     * @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>;
+    /**
+     * Create a Blob from a JSON object.
+     *
+     * Blobs will be in this form when requested from the blob sink, 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>;
+    /**
+     * 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[];
+    /**
+     * 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(): [Fr, Fr];
+    getEthVersionedBlobHash(): Buffer;
+    static getEthVersionedBlobHash(commitment: Buffer): Buffer;
+    /**
+     * 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(): Buffer;
+    /**
+     * Create a Blob from a buffer.
+     *
+     * @dev WARNING: this method contains all metadata aswell as the data itself
+     *
+     * @param buf - The buffer to create the Blob from.
+     * @returns A Blob created from the buffer.
+     */
+    static fromBuffer(buf: Buffer | BufferReader): Blob;
+    /**
+     * Get the size of the blob in bytes
+     */
+    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
+     */
+    getEthBlobEvaluationInputs(): `0x${string}`;
+    static getEthBlobEvaluationInputs(blobs: Blob[]): `0x${string}`;
+    static getViemKzgInstance(): {
+        blobToKzgCommitment: typeof cKzg.blobToKzgCommitment;
+        computeBlobKzgProof: typeof cKzg.computeBlobKzgProof;
+    };
+    static getBlobs(fields: Fr[]): Promise<Blob[]>;
+}
+//# sourceMappingURL=blob.d.ts.map

package/dest/blob.d.ts.map

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

package/dest/blob.js

@@ -0,0 +1,266 @@
+import { poseidon2Hash, sha256 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
+import cKzg from 'c-kzg';
+import { deserializeEncodedBlobToFields, extractBlobFieldsFromBuffer } from './encoding.js';
+import { BlobDeserializationError } from './errors.js';
+/* eslint-disable import/no-named-as-default-member */ const { BYTES_PER_BLOB, FIELD_ELEMENTS_PER_BLOB, blobToKzgCommitment, computeKzgProof, verifyKzgProof } = cKzg;
+// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
+export const VERSIONED_HASH_VERSION_KZG = 0x01;
+/**
+ * A class to create, manage, and prove EVM blobs.
+ */ export class Blob {
+    data;
+    fieldsHash;
+    challengeZ;
+    evaluationY;
+    commitment;
+    proof;
+    constructor(/** The blob to be broadcast on L1 in bytes form. */ data, /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */ fieldsHash, /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y. */ challengeZ, /** Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts. */ evaluationY, /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */ commitment, /** KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes). */ proof){
+        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.
+   * 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.
+   * @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 (err) {
+            throw new BlobDeserializationError(`Failed to create Blob from encoded blob buffer, this blob was likely not created by us`);
+        }
+    }
+    /**
+   * Create a Blob from an array of fields.
+   *
+   * @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}`);
+        }
+        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)
+        ]);
+        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);
+    }
+    /**
+   * Create a Blob from a JSON object.
+   *
+   * Blobs will be in this form when requested from the blob sink, 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) {
+        const blobBuffer = Buffer.from(json.blob.slice(2), 'hex');
+        const blob = await Blob.fromEncodedBlobBuffer(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) {
+        return {
+            blob: `0x${Buffer.from(this.data).toString('hex')}`,
+            index,
+            // eslint-disable-next-line camelcase
+            kzg_commitment: `0x${this.commitment.toString('hex')}`,
+            // eslint-disable-next-line camelcase
+            kzg_proof: `0x${this.proof.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 (err) {
+            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 (err) {
+            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;
+    }
+    static getEthVersionedBlobHash(commitment) {
+        const hash = sha256(commitment);
+        hash[0] = VERSIONED_HASH_VERSION_KZG;
+        return hash;
+    }
+    /**
+   * 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));
+    }
+    /**
+   * Create a Blob from a buffer.
+   *
+   * @dev WARNING: this method contains all metadata aswell 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(), reader.readBuffer(), reader.readBuffer());
+    }
+    /**
+   * Get the size of the blob in bytes
+   */ getSize() {
+        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 getViemKzgInstance() {
+        return {
+            blobToKzgCommitment: cKzg.blobToKzgCommitment,
+            computeBlobKzgProof: cKzg.computeBlobKzgProof
+        };
+    }
+    // Returns as many blobs as we require to broadcast the given fields
+    // Assumes we share the fields hash between all blobs
+    static async getBlobs(fields) {
+        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))
+    ];
+}

package/dest/blob_public_inputs.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { BLOBS_PER_BLOCK } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, type Tuple } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { type Blob } from './blob.js';
+/**
+ * Public inputs required to be passed from our rollup circuits to verify a blob.
+ */
+export declare class BlobPublicInputs {
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). */
+    z: Fr;
+    /** Evaluation y = p(z), where p() is the blob polynomial. */
+    y: bigint;
+    /** Commitment to the blob C. */
+    kzgCommitment: Tuple<Fr, 2>;
+    constructor(
+    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). */
+    z: Fr, 
+    /** Evaluation y = p(z), where p() is the blob polynomial. */
+    y: bigint, 
+    /** Commitment to the blob C. */
+    kzgCommitment: Tuple<Fr, 2>);
+    static empty(): BlobPublicInputs;
+    isEmpty(): boolean;
+    static fromBuffer(buffer: Buffer | BufferReader): BlobPublicInputs;
+    toBuffer(): Buffer;
+    static fromFields(fields: Fr[] | FieldReader): BlobPublicInputs;
+    toFields(): Fr[];
+    static getFields(fields: FieldsOf<BlobPublicInputs>): readonly [Fr, bigint, [Fr, Fr]];
+    static fromBlob(input: Blob): BlobPublicInputs;
+    getBlobHash(): Buffer;
+    commitmentToBuffer(): Buffer;
+    equals(other: BlobPublicInputs): boolean;
+}
+export declare class BlockBlobPublicInputs {
+    inner: Tuple<BlobPublicInputs, typeof BLOBS_PER_BLOCK>;
+    constructor(inner: Tuple<BlobPublicInputs, typeof BLOBS_PER_BLOCK>);
+    static empty(): BlockBlobPublicInputs;
+    static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs;
+    toBuffer(): Buffer;
+    static fromFields(fields: Fr[] | FieldReader): BlockBlobPublicInputs;
+    toFields(): Fr[];
+    static getFields(fields: FieldsOf<BlockBlobPublicInputs>): readonly [[BlobPublicInputs, BlobPublicInputs, BlobPublicInputs]];
+    static fromBlobs(inputs: Blob[]): BlockBlobPublicInputs;
+    getBlobsHash(): Buffer;
+    toString(): string;
+}
+//# sourceMappingURL=blob_public_inputs.d.ts.map

package/dest/blob_public_inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blob_public_inputs.d.ts","sourceRoot":"","sources":["../src/blob_public_inputs.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,KAAK,EAAqB,MAAM,6BAA6B,CAAC;AACvG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,KAAK,IAAI,EAA8B,MAAM,WAAW,CAAC;AAElE;;GAEG;AACH,qBAAa,gBAAgB;IAEzB,6DAA6D;IACtD,CAAC,EAAE,EAAE;IACZ,6DAA6D;IACtD,CAAC,EAAE,MAAM;IAChB,gCAAgC;IACzB,aAAa,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;;IALlC,6DAA6D;IACtD,CAAC,EAAE,EAAE;IACZ,6DAA6D;IACtD,CAAC,EAAE,MAAM;IAChB,gCAAgC;IACzB,aAAa,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAGpC,MAAM,CAAC,KAAK,IAAI,gBAAgB;IAIhC,OAAO,IAAI,OAAO;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IAKlE,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,gBAAgB;IAa/D,QAAQ;IAUR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAInD,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,gBAAgB;IAI9C,WAAW,IAAI,MAAM;IAQrB,kBAAkB,IAAI,MAAM;IAO5B,MAAM,CAAC,KAAK,EAAE,gBAAgB;CAQ/B;AAID,qBAAa,qBAAqB;IACb,KAAK,EAAE,KAAK,CAAC,gBAAgB,EAAE,OAAO,eAAe,CAAC;gBAAtD,KAAK,EAAE,KAAK,CAAC,gBAAgB,EAAE,OAAO,eAAe,CAAC;IAEzE,MAAM,CAAC,KAAK,IAAI,qBAAqB;IAIrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,qBAAqB;IAKvE,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,qBAAqB;IAKpE,QAAQ;IAIR,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,qBAAqB,CAAC;IAIxD,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,qBAAqB;IAWvD,YAAY;IAMZ,QAAQ;CAYT"}

package/dest/blob_public_inputs.js

@@ -0,0 +1,146 @@
+import { BLOBS_PER_BLOCK } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { toBigIntBE, toBufferBE, toHex } from '@aztec/foundation/bigint-buffer';
+import { sha256, sha256Trunc } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { VERSIONED_HASH_VERSION_KZG } from './blob.js';
+/**
+ * Public inputs required to be passed from our rollup circuits to verify a blob.
+ */ export class BlobPublicInputs {
+    z;
+    y;
+    kzgCommitment;
+    constructor(/** Challenge point z (= H(H(tx_effects), kzgCommmitment). */ z, /** Evaluation y = p(z), where p() is the blob polynomial. */ y, /** Commitment to the blob C. */ kzgCommitment){
+        this.z = z;
+        this.y = y;
+        this.kzgCommitment = kzgCommitment;
+    }
+    static empty() {
+        return new BlobPublicInputs(Fr.ZERO, 0n, [
+            Fr.ZERO,
+            Fr.ZERO
+        ]);
+    }
+    isEmpty() {
+        return this.z.isZero() && this.y == 0n && this.kzgCommitment[0].isZero() && this.kzgCommitment[1].isZero();
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BlobPublicInputs(Fr.fromBuffer(reader), toBigIntBE(reader.readBytes(32)), reader.readArray(2, Fr));
+    }
+    toBuffer() {
+        return serializeToBuffer(...BlobPublicInputs.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        // TODO: Create a BigNum to fields conversion we can use here and in type_conversion.ts
+        const fromBigNum = (fieldArr)=>{
+            return BigInt(fieldArr[2].toString().concat(fieldArr[1].toString().substring(2), fieldArr[0].toString().substring(2)));
+        };
+        return new BlobPublicInputs(reader.readField(), fromBigNum(reader.readFieldArray(3)), reader.readFieldArray(2));
+    }
+    // NB: y is NOT a BN254 field, it's a larger BLS field, we cannot use serialiseToFields here as it assumes bigints will fit
+    // TODO: Create a BigNum to fields conversion we can use here and in type_conversion.ts
+    toFields() {
+        const hex = toHex(this.y, true);
+        const bigNum = [
+            Fr.fromString('0x' + hex.substring(36)),
+            Fr.fromString('0x' + hex.substring(6, 36)),
+            Fr.fromString(hex.substring(0, 6))
+        ];
+        return [
+            this.z,
+            ...bigNum,
+            ...this.kzgCommitment
+        ];
+    }
+    static getFields(fields) {
+        return [
+            fields.z,
+            fields.y,
+            fields.kzgCommitment
+        ];
+    }
+    static fromBlob(input) {
+        return new BlobPublicInputs(input.challengeZ, toBigIntBE(input.evaluationY), input.commitmentToFields());
+    }
+    getBlobHash() {
+        const hash = sha256(this.commitmentToBuffer());
+        hash[0] = VERSIONED_HASH_VERSION_KZG;
+        return hash;
+    }
+    // Performs the reverse conversion of blob.commitmentToFields()
+    // 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
+    commitmentToBuffer() {
+        return Buffer.concat([
+            this.kzgCommitment[0].toBuffer().subarray(1),
+            this.kzgCommitment[1].toBuffer().subarray(-17)
+        ]);
+    }
+    equals(other) {
+        return this.z.equals(other.z) && this.y == other.y && this.kzgCommitment[0].equals(other.kzgCommitment[0]) && this.kzgCommitment[1].equals(other.kzgCommitment[1]);
+    }
+}
+// NB: it is much cleaner throughout the protocol circuits to define this struct rather than use a nested array.
+// Once we accumulate blob inputs, it should be removed, and we just use BlobPublicInputs::accumulate everywhere.
+export class BlockBlobPublicInputs {
+    inner;
+    constructor(inner){
+        this.inner = inner;
+    }
+    static empty() {
+        return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, BlobPublicInputs.empty));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BlockBlobPublicInputs(reader.readArray(BLOBS_PER_BLOCK, BlobPublicInputs));
+    }
+    toBuffer() {
+        return serializeToBuffer(...BlockBlobPublicInputs.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new BlockBlobPublicInputs(reader.readArray(BLOBS_PER_BLOCK, BlobPublicInputs));
+    }
+    toFields() {
+        return this.inner.map((i)=>i.toFields()).flat();
+    }
+    static getFields(fields) {
+        return [
+            fields.inner
+        ];
+    }
+    static fromBlobs(inputs) {
+        const inner = makeTuple(BLOBS_PER_BLOCK, BlobPublicInputs.empty);
+        if (inputs.length > BLOBS_PER_BLOCK) {
+            throw new Error(`Can only fit ${BLOBS_PER_BLOCK} in one BlockBlobPublicInputs instance (given ${inputs.length})`);
+        }
+        inputs.forEach((input, i)=>{
+            inner[i] = BlobPublicInputs.fromBlob(input);
+        });
+        return new BlockBlobPublicInputs(inner);
+    }
+    getBlobsHash() {
+        const blobHashes = this.inner.map((item)=>item.isEmpty() ? Buffer.alloc(0) : item.getBlobHash());
+        return sha256Trunc(serializeToBuffer(blobHashes));
+    }
+    // The below is used to send to L1 for proof verification
+    toString() {
+        const nonEmptyBlobs = this.inner.filter((item)=>!item.isEmpty());
+        // Write the number of blobs for L1 to verify
+        let buf = Buffer.alloc(1);
+        buf.writeUInt8(nonEmptyBlobs.length);
+        // Using standard toBuffer() does not correctly encode the commitment
+        // On L1, it's a 48 byte number, which we convert to 2 fields for use in the circuits
+        nonEmptyBlobs.forEach((blob)=>{
+            buf = Buffer.concat([
+                buf,
+                blob.z.toBuffer(),
+                toBufferBE(blob.y, 32),
+                blob.commitmentToBuffer()
+            ]);
+        });
+        return buf.toString('hex');
+    }
+}