@aztec/blob-lib 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/types.ts

@@ -0,0 +1,17 @@
+export * from './batched_blob.js';
+export * from './circuit_types/index.js';
+export * from './interface.js';
+export * from './sponge_blob.js';
+
+/**
+ * Type definition for the KZG instance returned by Blob.getViemKzgInstance().
+ * Contains the cryptographic functions needed for blob commitment and proof generation.
+ */
+export interface BlobKzgInstance {
+  /** Function to compute KZG commitment from blob data */
+  blobToKzgCommitment(blob: Uint8Array): Uint8Array;
+  /** Function to compute KZG proof for blob data */
+  computeBlobKzgProof(blob: Uint8Array, commitment: Uint8Array): Uint8Array;
+  /** Function to compute both blob data cells and their corresponding KZG proofs for EIP7594 */
+  computeCellsAndKzgProofs(blob: Uint8Array): [Uint8Array[], Uint8Array[]];
+}

package/dest/blob_public_inputs.d.ts

@@ -1,50 +0,0 @@
-/// <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

@@ -1 +0,0 @@
-{"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

@@ -1,146 +0,0 @@
-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');
-    }
-}

package/dest/encoding.d.ts

@@ -1,66 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { Blob as BlobBuffer } from 'c-kzg';
-export declare const TX_START_PREFIX = 8392562855083340404n;
-export declare const TX_START_PREFIX_BYTES_LENGTH: number;
-export declare const TX_EFFECT_PREFIX_BYTE_LENGTH: number;
-export declare const REVERT_CODE_PREFIX = 1;
-/**
- * Deserializes a blob buffer into an array of field elements.
- *
- * Blobs are converted into BN254 fields to perform a poseidon2 hash on them (fieldHash).
- * This method is sparse, meaning it does not include trailing zeros at the end of the blob.
- *
- * However, we cannot simply trim the zero's from the end of the blob, as some logs may include zero's
- * within them.
- * If we end on a set of zeros, such as the log below:
- * length 7: [ a, b, c, d, e, 0, 0]
- *
- * we will end up with the incorrect hash if we trim the zeros from the end.
- *
- * Each transactions logs contains a TX start prefix, which includes a string followed
- * by the length ( in field elements ) of the transaction's log.
- *
- * This function finds the end of the last transaction's logs, and returns the array up to this point.
- *
- * We search for a series of Tx Prefixes progressing the cursor in the field reader until we hit
- * a field that is not a Tx Prefix, this indicates that we have reached the end of the last transaction's logs.
- *
- * +------------------+------------------+------------------+------------------+
- * | TX1 Start Prefix | TX1 Log Fields   | TX2 Start Prefix | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                          ^
- *                                                          |
- * Function reads until here --------------------------------
- *
- * @param blob - The blob buffer to deserialize.
- * @returns An array of field elements.
- */
-export declare function deserializeEncodedBlobToFields(blob: BlobBuffer): Fr[];
-/**
- * Get the length of the transaction from the first field.
- *
- * @param firstField - The first field of the transaction.
- * @returns The length of the transaction.
- *
- * @throws If the first field does not include the correct prefix - encoding invalid.
- */
-export declare function getLengthFromFirstField(firstField: Fr): number;
-/**
- * Determines whether a field is the first field of a tx effect
- */
-export declare function isValidFirstField(field: Fr): boolean;
-/**
- * Extract the fields from a blob buffer, but do not take into account encoding
- * that will include trailing zeros.
- *
- * +------------------+------------------+------------------+------------------+
- * |                  |                  |                  | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                ^
- *                                                |
- * Function reads until here ----------------------
- */
-export declare function extractBlobFieldsFromBuffer(blob: BlobBuffer): Fr[];
-//# sourceMappingURL=encoding.d.ts.map

package/dest/encoding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,OAAO,CAAC;AAIhD,eAAO,MAAM,eAAe,uBAAuB,CAAC;AAEpD,eAAO,MAAM,4BAA4B,QAA0C,CAAC;AAEpF,eAAO,MAAM,4BAA4B,QAAmC,CAAC;AAC7E,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,UAAU,GAAG,EAAE,EAAE,CAsBrE;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,EAAE,GAAG,MAAM,CAO9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,EAAE,GAAG,OAAO,CAqBpD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,EAAE,EAAE,CAYlE"}

package/dest/encoding.js

@@ -1,113 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
-// Note duplicated from stdlib !
-// This will appear as 0x74785f7374617274 in logs
-export const TX_START_PREFIX = 8392562855083340404n;
-// These are helper constants to decode tx effects from blob encoded fields
-export const TX_START_PREFIX_BYTES_LENGTH = TX_START_PREFIX.toString(16).length / 2;
-// 7 bytes for: | 0 | txlen[0] | txlen[1] | 0 | REVERT_CODE_PREFIX | 0 | revertCode |
-export const TX_EFFECT_PREFIX_BYTE_LENGTH = TX_START_PREFIX_BYTES_LENGTH + 7;
-export const REVERT_CODE_PREFIX = 1;
-/**
- * Deserializes a blob buffer into an array of field elements.
- *
- * Blobs are converted into BN254 fields to perform a poseidon2 hash on them (fieldHash).
- * This method is sparse, meaning it does not include trailing zeros at the end of the blob.
- *
- * However, we cannot simply trim the zero's from the end of the blob, as some logs may include zero's
- * within them.
- * If we end on a set of zeros, such as the log below:
- * length 7: [ a, b, c, d, e, 0, 0]
- *
- * we will end up with the incorrect hash if we trim the zeros from the end.
- *
- * Each transactions logs contains a TX start prefix, which includes a string followed
- * by the length ( in field elements ) of the transaction's log.
- *
- * This function finds the end of the last transaction's logs, and returns the array up to this point.
- *
- * We search for a series of Tx Prefixes progressing the cursor in the field reader until we hit
- * a field that is not a Tx Prefix, this indicates that we have reached the end of the last transaction's logs.
- *
- * +------------------+------------------+------------------+------------------+
- * | TX1 Start Prefix | TX1 Log Fields   | TX2 Start Prefix | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                          ^
- *                                                          |
- * Function reads until here --------------------------------
- *
- * @param blob - The blob buffer to deserialize.
- * @returns An array of field elements.
- */ export function deserializeEncodedBlobToFields(blob) {
-    // Convert blob buffer to array of field elements
-    const reader = BufferReader.asReader(blob);
-    const array = reader.readArray(blob.length >> 5, Fr); // >> 5 = / 32 (bytes per field)
-    const fieldReader = FieldReader.asReader(array);
-    // Read fields until we hit zeros at the end
-    while(!fieldReader.isFinished()){
-        const currentField = fieldReader.peekField();
-        // Stop when we hit a zero field
-        if (!currentField || currentField.isZero()) {
-            break;
-        }
-        // Skip the remaining fields in this transaction
-        const len = getLengthFromFirstField(currentField);
-        fieldReader.skip(len);
-    }
-    // Return array up to last non-zero field
-    return array.slice(0, fieldReader.cursor);
-}
-/**
- * Get the length of the transaction from the first field.
- *
- * @param firstField - The first field of the transaction.
- * @returns The length of the transaction.
- *
- * @throws If the first field does not include the correct prefix - encoding invalid.
- */ export function getLengthFromFirstField(firstField) {
-    // Check that the first field includes the correct prefix
-    if (!isValidFirstField(firstField)) {
-        throw new Error('Invalid prefix');
-    }
-    const buf = firstField.toBuffer().subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    return new Fr(buf.subarray(TX_START_PREFIX_BYTES_LENGTH + 1, TX_START_PREFIX_BYTES_LENGTH + 3)).toNumber();
-}
-/**
- * Determines whether a field is the first field of a tx effect
- */ export function isValidFirstField(field) {
-    const buf = field.toBuffer();
-    if (!buf.subarray(0, field.size - TX_EFFECT_PREFIX_BYTE_LENGTH).equals(Buffer.alloc(field.size - TX_EFFECT_PREFIX_BYTE_LENGTH))) {
-        return false;
-    }
-    const sliced = buf.subarray(-TX_EFFECT_PREFIX_BYTE_LENGTH);
-    if (// Checking we start with the correct prefix...
-    !new Fr(sliced.subarray(0, TX_START_PREFIX_BYTES_LENGTH)).equals(new Fr(TX_START_PREFIX)) || // ...and include the revert code prefix..
-    sliced[sliced.length - 3] !== REVERT_CODE_PREFIX || // ...and the following revert code is valid.
-    sliced[sliced.length - 1] > 4) {
-        return false;
-    }
-    return true;
-}
-/**
- * Extract the fields from a blob buffer, but do not take into account encoding
- * that will include trailing zeros.
- *
- * +------------------+------------------+------------------+------------------+
- * |                  |                  |                  | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                ^
- *                                                |
- * Function reads until here ----------------------
- */ export function extractBlobFieldsFromBuffer(blob) {
-    const reader = BufferReader.asReader(blob);
-    const array = reader.readArray(blob.length >> 5, Fr);
-    // Find the index of the last non-zero field
-    let lastNonZeroIndex = array.length - 1;
-    while(lastNonZeroIndex >= 0 && array[lastNonZeroIndex].isZero()){
-        lastNonZeroIndex--;
-    }
-    // Return the trimmed array
-    return array.slice(0, lastNonZeroIndex + 1);
-}

package/src/blob_public_inputs.ts

@@ -1,157 +0,0 @@
-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, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { type Blob, VERSIONED_HASH_VERSION_KZG } from './blob.js';
-
-/**
- * Public inputs required to be passed from our rollup circuits to verify a blob.
- */
-export class BlobPublicInputs {
-  constructor(
-    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). */
-    public z: Fr,
-    /** Evaluation y = p(z), where p() is the blob polynomial. */
-    public y: bigint,
-    /** Commitment to the blob C. */
-    public kzgCommitment: Tuple<Fr, 2>,
-  ) {}
-
-  static empty(): BlobPublicInputs {
-    return new BlobPublicInputs(Fr.ZERO, 0n, [Fr.ZERO, Fr.ZERO]);
-  }
-
-  isEmpty(): boolean {
-    return this.z.isZero() && this.y == 0n && this.kzgCommitment[0].isZero() && this.kzgCommitment[1].isZero();
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): BlobPublicInputs {
-    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: Fr[] | FieldReader): BlobPublicInputs {
-    const reader = FieldReader.asReader(fields);
-    // TODO: Create a BigNum to fields conversion we can use here and in type_conversion.ts
-    const fromBigNum = (fieldArr: Fr[]) => {
-      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: FieldsOf<BlobPublicInputs>) {
-    return [fields.z, fields.y, fields.kzgCommitment] as const;
-  }
-
-  static fromBlob(input: Blob): BlobPublicInputs {
-    return new BlobPublicInputs(input.challengeZ, toBigIntBE(input.evaluationY), input.commitmentToFields());
-  }
-
-  getBlobHash(): Buffer {
-    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(): Buffer {
-    return Buffer.concat([
-      this.kzgCommitment[0].toBuffer().subarray(1),
-      this.kzgCommitment[1].toBuffer().subarray(-17),
-    ]);
-  }
-
-  equals(other: BlobPublicInputs) {
-    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 {
-  constructor(public inner: Tuple<BlobPublicInputs, typeof BLOBS_PER_BLOCK>) {}
-
-  static empty(): BlockBlobPublicInputs {
-    return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, BlobPublicInputs.empty));
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new BlockBlobPublicInputs(reader.readArray(BLOBS_PER_BLOCK, BlobPublicInputs));
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...BlockBlobPublicInputs.getFields(this));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): BlockBlobPublicInputs {
-    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: FieldsOf<BlockBlobPublicInputs>) {
-    return [fields.inner] as const;
-  }
-
-  static fromBlobs(inputs: Blob[]): BlockBlobPublicInputs {
-    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');
-  }
-}