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

package/dest/blob_batching_public_inputs.d.ts

@@ -1,71 +0,0 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
-import { inspect } from 'util';
-import { Blob } from './blob.js';
-import { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-/**
- * See nr BlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */
-export declare class BlobAccumulatorPublicInputs {
-    blobCommitmentsHashAcc: Fr;
-    zAcc: Fr;
-    yAcc: BLS12Fr;
-    cAcc: BLS12Point;
-    gammaAcc: Fr;
-    gammaPowAcc: BLS12Fr;
-    constructor(blobCommitmentsHashAcc: Fr, zAcc: Fr, yAcc: BLS12Fr, cAcc: BLS12Point, gammaAcc: Fr, gammaPowAcc: BLS12Fr);
-    static empty(): BlobAccumulatorPublicInputs;
-    equals(other: BlobAccumulatorPublicInputs): boolean;
-    static fromBuffer(buffer: Buffer | BufferReader): BlobAccumulatorPublicInputs;
-    toBuffer(): Buffer<ArrayBufferLike>;
-    /**
-     * Given blobs, accumulate all public inputs state.
-     * We assume the input blobs have not been evaluated at z.
-     * NOTE: Does NOT accumulate non circuit values including Q. This exists to simulate/check exactly what the circuit is doing
-     * and is unsafe for other use. For that reason, a toBatchedBlobAccumulator does not exist. See evaluateBlobs() oracle for usage.
-     * @returns An updated blob accumulator.
-     */
-    accumulateBlobs(blobs: Blob[], finalBlobChallenges: FinalBlobBatchingChallenges): Promise<BlobAccumulatorPublicInputs>;
-    toFields(): Fr[];
-    static fromFields(fields: Fr[] | FieldReader): BlobAccumulatorPublicInputs;
-    /**
-     * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
-     * @returns A BlobAccumulatorPublicInputs instance.
-     */
-    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): BlobAccumulatorPublicInputs;
-}
-/**
- * See nr FinalBlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */
-export declare class FinalBlobAccumulatorPublicInputs {
-    blobCommitmentsHash: Fr;
-    z: Fr;
-    y: BLS12Fr;
-    c: BLS12Point;
-    constructor(blobCommitmentsHash: Fr, z: Fr, y: BLS12Fr, c: BLS12Point);
-    static empty(): FinalBlobAccumulatorPublicInputs;
-    static fromBuffer(buffer: Buffer | BufferReader): FinalBlobAccumulatorPublicInputs;
-    toBuffer(): Buffer<ArrayBufferLike>;
-    static fromBatchedBlob(blob: BatchedBlob): FinalBlobAccumulatorPublicInputs;
-    toFields(): Fr[];
-    toString(): string;
-    equals(other: FinalBlobAccumulatorPublicInputs): boolean;
-    static random(): FinalBlobAccumulatorPublicInputs;
-    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): FinalBlobAccumulatorPublicInputs;
-    [inspect.custom](): string;
-}
-/**
- * startBlobAccumulator: Accumulated opening proofs for all blobs before this block range.
- * endBlobAccumulator: Accumulated opening proofs for all blobs after adding this block range.
- * finalBlobChallenges:  Final values z and gamma, shared across the epoch.
- */
-export declare class BlockBlobPublicInputs {
-    startBlobAccumulator: BlobAccumulatorPublicInputs;
-    endBlobAccumulator: BlobAccumulatorPublicInputs;
-    finalBlobChallenges: FinalBlobBatchingChallenges;
-    constructor(startBlobAccumulator: BlobAccumulatorPublicInputs, endBlobAccumulator: BlobAccumulatorPublicInputs, finalBlobChallenges: FinalBlobBatchingChallenges);
-    static empty(): BlockBlobPublicInputs;
-    static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs;
-    toBuffer(): Buffer<ArrayBufferLike>;
-}
-//# sourceMappingURL=blob_batching_public_inputs.d.ts.map

package/dest/blob_batching_public_inputs.d.ts.map

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

@@ -1,168 +0,0 @@
-import { BLS12_FQ_LIMBS, BLS12_FR_LIMBS } from '@aztec/constants';
-import { BLS12Fq, BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import { inspect } from 'util';
-import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-/**
- * See nr BlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */ export class BlobAccumulatorPublicInputs {
-    blobCommitmentsHashAcc;
-    zAcc;
-    yAcc;
-    cAcc;
-    gammaAcc;
-    gammaPowAcc;
-    constructor(blobCommitmentsHashAcc, zAcc, yAcc, cAcc, gammaAcc, gammaPowAcc){
-        this.blobCommitmentsHashAcc = blobCommitmentsHashAcc;
-        this.zAcc = zAcc;
-        this.yAcc = yAcc;
-        this.cAcc = cAcc;
-        this.gammaAcc = gammaAcc;
-        this.gammaPowAcc = gammaPowAcc;
-    }
-    static empty() {
-        return new BlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO);
-    }
-    equals(other) {
-        return this.blobCommitmentsHashAcc.equals(other.blobCommitmentsHashAcc) && this.zAcc.equals(other.zAcc) && this.yAcc.equals(other.yAcc) && this.cAcc.equals(other.cAcc) && this.gammaAcc.equals(other.gammaAcc) && this.gammaPowAcc.equals(other.gammaPowAcc);
-    }
-    static fromBuffer(buffer) {
-        const reader = BufferReader.asReader(buffer);
-        return new BlobAccumulatorPublicInputs(Fr.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader), BLS12Point.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader));
-    }
-    toBuffer() {
-        return serializeToBuffer(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.gammaAcc, this.gammaPowAcc);
-    }
-    /**
-   * Given blobs, accumulate all public inputs state.
-   * We assume the input blobs have not been evaluated at z.
-   * NOTE: Does NOT accumulate non circuit values including Q. This exists to simulate/check exactly what the circuit is doing
-   * and is unsafe for other use. For that reason, a toBatchedBlobAccumulator does not exist. See evaluateBlobs() oracle for usage.
-   * @returns An updated blob accumulator.
-   */ async accumulateBlobs(blobs, finalBlobChallenges) {
-        let acc = new BatchedBlobAccumulator(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, BLS12Point.ZERO, this.gammaAcc, this.gammaPowAcc, finalBlobChallenges);
-        acc = await acc.accumulateBlobs(blobs);
-        return new BlobAccumulatorPublicInputs(acc.blobCommitmentsHashAcc, acc.zAcc, acc.yAcc, acc.cAcc, acc.gammaAcc, acc.gammaPow);
-    }
-    toFields() {
-        return [
-            this.blobCommitmentsHashAcc,
-            this.zAcc,
-            ...this.yAcc.toNoirBigNum().limbs.map(Fr.fromString),
-            ...this.cAcc.x.toNoirBigNum().limbs.map(Fr.fromString),
-            ...this.cAcc.y.toNoirBigNum().limbs.map(Fr.fromString),
-            new Fr(this.cAcc.isInfinite),
-            this.gammaAcc,
-            ...this.gammaPowAcc.toNoirBigNum().limbs.map(Fr.fromString)
-        ];
-    }
-    static fromFields(fields) {
-        const reader = FieldReader.asReader(fields);
-        return new BlobAccumulatorPublicInputs(reader.readField(), reader.readField(), BLS12Fr.fromNoirBigNum({
-            limbs: reader.readFieldArray(BLS12_FR_LIMBS).map((f)=>f.toString())
-        }), new BLS12Point(BLS12Fq.fromNoirBigNum({
-            limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map((f)=>f.toString())
-        }), BLS12Fq.fromNoirBigNum({
-            limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map((f)=>f.toString())
-        }), reader.readBoolean()), reader.readField(), BLS12Fr.fromNoirBigNum({
-            limbs: reader.readFieldArray(BLS12_FR_LIMBS).map((f)=>f.toString())
-        }));
-    }
-    /**
-   * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
-   * @returns A BlobAccumulatorPublicInputs instance.
-   */ static fromBatchedBlobAccumulator(accumulator) {
-        return new BlobAccumulatorPublicInputs(accumulator.blobCommitmentsHashAcc, accumulator.zAcc, accumulator.yAcc, accumulator.cAcc, accumulator.gammaAcc, accumulator.gammaPow);
-    }
-}
-/**
- * See nr FinalBlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */ export class FinalBlobAccumulatorPublicInputs {
-    blobCommitmentsHash;
-    z;
-    y;
-    c;
-    constructor(blobCommitmentsHash, z, y, c){
-        this.blobCommitmentsHash = blobCommitmentsHash;
-        this.z = z;
-        this.y = y;
-        this.c = c;
-    }
-    static empty() {
-        return new FinalBlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO);
-    }
-    static fromBuffer(buffer) {
-        const reader = BufferReader.asReader(buffer);
-        return new FinalBlobAccumulatorPublicInputs(Fr.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader), BLS12Point.fromBuffer(reader));
-    }
-    toBuffer() {
-        return serializeToBuffer(this.blobCommitmentsHash, this.z, this.y, this.c);
-    }
-    static fromBatchedBlob(blob) {
-        return new FinalBlobAccumulatorPublicInputs(blob.blobCommitmentsHash, blob.z, blob.y, blob.commitment);
-    }
-    toFields() {
-        return [
-            this.blobCommitmentsHash,
-            this.z,
-            ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
-            ...this.c.toBN254Fields()
-        ];
-    }
-    // The below is used to send to L1 for proof verification
-    toString() {
-        // We prepend 32 bytes for the (unused) 'blobHash' slot. This is not read or required by getEpochProofPublicInputs() on L1, but
-        // is expected since we usually pass the full precompile inputs via verifyEpochRootProof() to getEpochProofPublicInputs() to ensure
-        // we use calldata rather than a slice in memory:
-        const buf = Buffer.concat([
-            Buffer.alloc(32),
-            this.z.toBuffer(),
-            this.y.toBuffer(),
-            this.c.compress()
-        ]);
-        return buf.toString('hex');
-    }
-    equals(other) {
-        return this.blobCommitmentsHash.equals(other.blobCommitmentsHash) && this.z.equals(other.z) && this.y.equals(other.y) && this.c.equals(other.c);
-    }
-    // Creates a random instance. Used for testing only - will not prove/verify.
-    static random() {
-        return new FinalBlobAccumulatorPublicInputs(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
-    }
-    // Warning: MUST be final accumulator state.
-    static fromBatchedBlobAccumulator(accumulator) {
-        return new FinalBlobAccumulatorPublicInputs(accumulator.blobCommitmentsHashAcc, accumulator.zAcc, accumulator.yAcc, accumulator.cAcc);
-    }
-    [inspect.custom]() {
-        return `FinalBlobAccumulatorPublicInputs {
-      blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
-      z: ${inspect(this.z)},
-      y: ${inspect(this.y)},
-      c: ${inspect(this.c)},
-    }`;
-    }
-}
-/**
- * startBlobAccumulator: Accumulated opening proofs for all blobs before this block range.
- * endBlobAccumulator: Accumulated opening proofs for all blobs after adding this block range.
- * finalBlobChallenges:  Final values z and gamma, shared across the epoch.
- */ export class BlockBlobPublicInputs {
-    startBlobAccumulator;
-    endBlobAccumulator;
-    finalBlobChallenges;
-    constructor(startBlobAccumulator, endBlobAccumulator, finalBlobChallenges){
-        this.startBlobAccumulator = startBlobAccumulator;
-        this.endBlobAccumulator = endBlobAccumulator;
-        this.finalBlobChallenges = finalBlobChallenges;
-    }
-    static empty() {
-        return new BlockBlobPublicInputs(BlobAccumulatorPublicInputs.empty(), BlobAccumulatorPublicInputs.empty(), FinalBlobBatchingChallenges.empty());
-    }
-    static fromBuffer(buffer) {
-        const reader = BufferReader.asReader(buffer);
-        return new BlockBlobPublicInputs(reader.readObject(BlobAccumulatorPublicInputs), reader.readObject(BlobAccumulatorPublicInputs), reader.readObject(FinalBlobBatchingChallenges));
-    }
-    toBuffer() {
-        return serializeToBuffer(this.startBlobAccumulator, this.endBlobAccumulator, this.finalBlobChallenges);
-    }
-}

package/dest/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_batching_public_inputs.ts

@@ -1,252 +0,0 @@
-import { BLS12_FQ_LIMBS, BLS12_FR_LIMBS } from '@aztec/constants';
-import { BLS12Fq, BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { inspect } from 'util';
-
-import { Blob } from './blob.js';
-import { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-
-/**
- * See nr BlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */
-export class BlobAccumulatorPublicInputs {
-  constructor(
-    public blobCommitmentsHashAcc: Fr,
-    public zAcc: Fr,
-    public yAcc: BLS12Fr,
-    public cAcc: BLS12Point,
-    public gammaAcc: Fr,
-    public gammaPowAcc: BLS12Fr,
-  ) {}
-
-  static empty(): BlobAccumulatorPublicInputs {
-    return new BlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO);
-  }
-
-  equals(other: BlobAccumulatorPublicInputs) {
-    return (
-      this.blobCommitmentsHashAcc.equals(other.blobCommitmentsHashAcc) &&
-      this.zAcc.equals(other.zAcc) &&
-      this.yAcc.equals(other.yAcc) &&
-      this.cAcc.equals(other.cAcc) &&
-      this.gammaAcc.equals(other.gammaAcc) &&
-      this.gammaPowAcc.equals(other.gammaPowAcc)
-    );
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): BlobAccumulatorPublicInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new BlobAccumulatorPublicInputs(
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      BLS12Fr.fromBuffer(reader),
-      BLS12Point.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      BLS12Fr.fromBuffer(reader),
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(
-      this.blobCommitmentsHashAcc,
-      this.zAcc,
-      this.yAcc,
-      this.cAcc,
-      this.gammaAcc,
-      this.gammaPowAcc,
-    );
-  }
-
-  /**
-   * Given blobs, accumulate all public inputs state.
-   * We assume the input blobs have not been evaluated at z.
-   * NOTE: Does NOT accumulate non circuit values including Q. This exists to simulate/check exactly what the circuit is doing
-   * and is unsafe for other use. For that reason, a toBatchedBlobAccumulator does not exist. See evaluateBlobs() oracle for usage.
-   * @returns An updated blob accumulator.
-   */
-  async accumulateBlobs(blobs: Blob[], finalBlobChallenges: FinalBlobBatchingChallenges) {
-    let acc = new BatchedBlobAccumulator(
-      this.blobCommitmentsHashAcc,
-      this.zAcc,
-      this.yAcc,
-      this.cAcc,
-      BLS12Point.ZERO,
-      this.gammaAcc,
-      this.gammaPowAcc,
-      finalBlobChallenges,
-    );
-    acc = await acc.accumulateBlobs(blobs);
-    return new BlobAccumulatorPublicInputs(
-      acc.blobCommitmentsHashAcc,
-      acc.zAcc,
-      acc.yAcc,
-      acc.cAcc,
-      acc.gammaAcc,
-      acc.gammaPow,
-    );
-  }
-
-  toFields() {
-    return [
-      this.blobCommitmentsHashAcc,
-      this.zAcc,
-      ...this.yAcc.toNoirBigNum().limbs.map(Fr.fromString),
-      ...this.cAcc.x.toNoirBigNum().limbs.map(Fr.fromString),
-      ...this.cAcc.y.toNoirBigNum().limbs.map(Fr.fromString),
-      new Fr(this.cAcc.isInfinite),
-      this.gammaAcc,
-      ...this.gammaPowAcc.toNoirBigNum().limbs.map(Fr.fromString),
-    ];
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): BlobAccumulatorPublicInputs {
-    const reader = FieldReader.asReader(fields);
-    return new BlobAccumulatorPublicInputs(
-      reader.readField(),
-      reader.readField(),
-      BLS12Fr.fromNoirBigNum({ limbs: reader.readFieldArray(BLS12_FR_LIMBS).map(f => f.toString()) }),
-      new BLS12Point(
-        BLS12Fq.fromNoirBigNum({ limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map(f => f.toString()) }),
-        BLS12Fq.fromNoirBigNum({ limbs: reader.readFieldArray(BLS12_FQ_LIMBS).map(f => f.toString()) }),
-        reader.readBoolean(),
-      ),
-      reader.readField(),
-      BLS12Fr.fromNoirBigNum({ limbs: reader.readFieldArray(BLS12_FR_LIMBS).map(f => f.toString()) }),
-    );
-  }
-
-  /**
-   * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
-   * @returns A BlobAccumulatorPublicInputs instance.
-   */
-  static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator) {
-    return new BlobAccumulatorPublicInputs(
-      accumulator.blobCommitmentsHashAcc,
-      accumulator.zAcc,
-      accumulator.yAcc,
-      accumulator.cAcc,
-      accumulator.gammaAcc,
-      accumulator.gammaPow,
-    );
-  }
-}
-
-/**
- * See nr FinalBlobAccumulatorPublicInputs and ts BatchedBlobAccumulator for documentation.
- */
-export class FinalBlobAccumulatorPublicInputs {
-  constructor(
-    public blobCommitmentsHash: Fr,
-    public z: Fr,
-    public y: BLS12Fr,
-    public c: BLS12Point,
-  ) {}
-
-  static empty(): FinalBlobAccumulatorPublicInputs {
-    return new FinalBlobAccumulatorPublicInputs(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): FinalBlobAccumulatorPublicInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new FinalBlobAccumulatorPublicInputs(
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      BLS12Fr.fromBuffer(reader),
-      BLS12Point.fromBuffer(reader),
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(this.blobCommitmentsHash, this.z, this.y, this.c);
-  }
-
-  static fromBatchedBlob(blob: BatchedBlob) {
-    return new FinalBlobAccumulatorPublicInputs(blob.blobCommitmentsHash, blob.z, blob.y, blob.commitment);
-  }
-
-  toFields() {
-    return [
-      this.blobCommitmentsHash,
-      this.z,
-      ...this.y.toNoirBigNum().limbs.map(Fr.fromString),
-      ...this.c.toBN254Fields(),
-    ];
-  }
-
-  // The below is used to send to L1 for proof verification
-  toString() {
-    // We prepend 32 bytes for the (unused) 'blobHash' slot. This is not read or required by getEpochProofPublicInputs() on L1, but
-    // is expected since we usually pass the full precompile inputs via verifyEpochRootProof() to getEpochProofPublicInputs() to ensure
-    // we use calldata rather than a slice in memory:
-    const buf = Buffer.concat([Buffer.alloc(32), this.z.toBuffer(), this.y.toBuffer(), this.c.compress()]);
-    return buf.toString('hex');
-  }
-
-  equals(other: FinalBlobAccumulatorPublicInputs) {
-    return (
-      this.blobCommitmentsHash.equals(other.blobCommitmentsHash) &&
-      this.z.equals(other.z) &&
-      this.y.equals(other.y) &&
-      this.c.equals(other.c)
-    );
-  }
-
-  // Creates a random instance. Used for testing only - will not prove/verify.
-  static random() {
-    return new FinalBlobAccumulatorPublicInputs(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
-  }
-
-  // Warning: MUST be final accumulator state.
-  static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator) {
-    return new FinalBlobAccumulatorPublicInputs(
-      accumulator.blobCommitmentsHashAcc,
-      accumulator.zAcc,
-      accumulator.yAcc,
-      accumulator.cAcc,
-    );
-  }
-
-  [inspect.custom]() {
-    return `FinalBlobAccumulatorPublicInputs {
-      blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
-      z: ${inspect(this.z)},
-      y: ${inspect(this.y)},
-      c: ${inspect(this.c)},
-    }`;
-  }
-}
-
-/**
- * startBlobAccumulator: Accumulated opening proofs for all blobs before this block range.
- * endBlobAccumulator: Accumulated opening proofs for all blobs after adding this block range.
- * finalBlobChallenges:  Final values z and gamma, shared across the epoch.
- */
-export class BlockBlobPublicInputs {
-  constructor(
-    public startBlobAccumulator: BlobAccumulatorPublicInputs,
-    public endBlobAccumulator: BlobAccumulatorPublicInputs,
-    public finalBlobChallenges: FinalBlobBatchingChallenges,
-  ) {}
-
-  static empty(): BlockBlobPublicInputs {
-    return new BlockBlobPublicInputs(
-      BlobAccumulatorPublicInputs.empty(),
-      BlobAccumulatorPublicInputs.empty(),
-      FinalBlobBatchingChallenges.empty(),
-    );
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): BlockBlobPublicInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new BlockBlobPublicInputs(
-      reader.readObject(BlobAccumulatorPublicInputs),
-      reader.readObject(BlobAccumulatorPublicInputs),
-      reader.readObject(FinalBlobBatchingChallenges),
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(this.startBlobAccumulator, this.endBlobAccumulator, this.finalBlobChallenges);
-  }
-}