@aztec/blob-lib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/dest/circuit_types/final_blob_accumulator.js

@@ -0,0 +1,63 @@
+import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+/**
+ * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_accumulator.nr` for documentation.
+ */ export class FinalBlobAccumulator {
+    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 FinalBlobAccumulator(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new FinalBlobAccumulator(Fr.fromBuffer(reader), Fr.fromBuffer(reader), BLS12Fr.fromBuffer(reader), BLS12Point.fromBuffer(reader));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.blobCommitmentsHash, this.z, this.y, this.c);
+    }
+    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 FinalBlobAccumulator(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
+    }
+    [inspect.custom]() {
+        return `FinalBlobAccumulator {
+      blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
+      z: ${inspect(this.z)},
+      y: ${inspect(this.y)},
+      c: ${inspect(this.c)},
+    }`;
+    }
+}

package/dest/circuit_types/final_blob_batching_challenges.d.ts

@@ -0,0 +1,15 @@
+import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+/**
+ * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_batching_challenges.nr` for documentation.
+ */
+export declare class FinalBlobBatchingChallenges {
+    readonly z: Fr;
+    readonly gamma: BLS12Fr;
+    constructor(z: Fr, gamma: BLS12Fr);
+    equals(other: FinalBlobBatchingChallenges): boolean;
+    static empty(): FinalBlobBatchingChallenges;
+    static fromBuffer(buffer: Buffer | BufferReader): FinalBlobBatchingChallenges;
+    toBuffer(): Buffer<ArrayBufferLike>;
+}
+//# sourceMappingURL=final_blob_batching_challenges.d.ts.map

package/dest/circuit_types/final_blob_batching_challenges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"final_blob_batching_challenges.d.ts","sourceRoot":"","sources":["../../src/circuit_types/final_blob_batching_challenges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E;;GAEG;AACH,qBAAa,2BAA2B;aAEpB,CAAC,EAAE,EAAE;aACL,KAAK,EAAE,OAAO;gBADd,CAAC,EAAE,EAAE,EACL,KAAK,EAAE,OAAO;IAGhC,MAAM,CAAC,KAAK,EAAE,2BAA2B;IAIzC,MAAM,CAAC,KAAK,IAAI,2BAA2B;IAI3C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,2BAA2B;IAK7E,QAAQ;CAGT"}

package/dest/circuit_types/final_blob_batching_challenges.js

@@ -0,0 +1,25 @@
+import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+/**
+ * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_batching_challenges.nr` for documentation.
+ */ export class FinalBlobBatchingChallenges {
+    z;
+    gamma;
+    constructor(z, gamma){
+        this.z = z;
+        this.gamma = gamma;
+    }
+    equals(other) {
+        return this.z.equals(other.z) && this.gamma.equals(other.gamma);
+    }
+    static empty() {
+        return new FinalBlobBatchingChallenges(Fr.ZERO, BLS12Fr.ZERO);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new FinalBlobBatchingChallenges(Fr.fromBuffer(reader), reader.readObject(BLS12Fr));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.z, this.gamma);
+    }
+}

package/dest/circuit_types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './blob_accumulator.js';
+export * from './final_blob_accumulator.js';
+export * from './final_blob_batching_challenges.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/circuit_types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/circuit_types/index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC"}

package/dest/circuit_types/index.js

@@ -0,0 +1,4 @@
+/// Types used in the protocol circuits.
+export * from './blob_accumulator.js';
+export * from './final_blob_accumulator.js';
+export * from './final_blob_batching_challenges.js';

package/dest/deserialize.d.ts

@@ -0,0 +1,14 @@
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * Deserializes a buffer into an array of field elements.
+ *
+ * This function returns the fields that were actually added in a checkpoint. The number of fields is specified by the
+ * first field.
+ *
+ * @param buf - The buffer to deserialize.
+ * @param checkEncoding - Whether to check if the encoding is correct. If false, it will still check the checkpoint
+ * prefix and throw if there's not enough fields.
+ * @returns An array of field elements.
+ */
+export declare function deserializeEncodedBlobToFields(buf: Uint8Array, checkEncoding?: boolean): Fr[];
+//# sourceMappingURL=deserialize.d.ts.map

package/dest/deserialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.d.ts","sourceRoot":"","sources":["../src/deserialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAM9C;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,UAAQ,GAAG,EAAE,EAAE,CAoB3F"}

package/dest/deserialize.js

@@ -0,0 +1,33 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { checkBlobFieldsEncoding } from './encoding.js';
+import { BlobDeserializationError } from './errors.js';
+/**
+ * Deserializes a buffer into an array of field elements.
+ *
+ * This function returns the fields that were actually added in a checkpoint. The number of fields is specified by the
+ * first field.
+ *
+ * @param buf - The buffer to deserialize.
+ * @param checkEncoding - Whether to check if the encoding is correct. If false, it will still check the checkpoint
+ * prefix and throw if there's not enough fields.
+ * @returns An array of field elements.
+ */ export function deserializeEncodedBlobToFields(buf, checkEncoding = false) {
+    const reader = BufferReader.asReader(buf);
+    const firstField = reader.readObject(Fr);
+    // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error below if the first
+    // field is larger than a javascript integer.
+    const numFields = firstField.toBigInt();
+    const totalFieldsInBuffer = BigInt(buf.length / Fr.SIZE_IN_BYTES);
+    if (numFields > totalFieldsInBuffer) {
+        throw new BlobDeserializationError(`Failed to deserialize blob fields, this blob was likely not created by us`);
+    }
+    const numFieldsWithoutPrefix = Number(numFields) - 1;
+    const blobFields = [
+        firstField
+    ].concat(reader.readArray(numFieldsWithoutPrefix, Fr));
+    if (checkEncoding && !checkBlobFieldsEncoding(blobFields)) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields, this blob was likely not created by us`);
+    }
+    return blobFields;
+}

package/dest/encoding.d.ts

@@ -1,66 +1,26 @@
 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;
+export interface TxStartMarker {
+    prefix: bigint;
+    numBlobFields: number;
+    revertCode: number;
+    numNoteHashes: number;
+    numNullifiers: number;
+    numL2ToL1Msgs: number;
+    numPublicDataWrites: number;
+    numPrivateLogs: number;
+    publicLogsLength: number;
+    contractClassLogLength: number;
+}
+export declare function encodeTxStartMarker(txStartMarker: Omit<TxStartMarker, 'prefix'>): Fr;
+export declare function decodeTxStartMarker(field: Fr): TxStartMarker;
+export declare function getNumBlobFieldsFromTxStartMarker(field: Fr): number;
+export declare function isValidTxStartMarker(txStartMarker: TxStartMarker): boolean;
+export declare function createBlockEndMarker(numTxs: number): Fr;
+export declare function getNumTxsFromBlockEndMarker(field: Fr): number;
+export declare function isBlockEndMarker(field: Fr): boolean;
 /**
- * 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.
+ * Check that the fields are emitted from the circuits and conform to the encoding.
+ * @param blobFields - The concatenated fields from all blobs of an L1 block.
  */
-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[];
+export declare function checkBlobFieldsEncoding(blobFields: Fr[]): boolean;
 //# sourceMappingURL=encoding.d.ts.map

package/dest/encoding.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAa9C,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAGD,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,MAqB/E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,EAAE,GAAG,aAAa,CAmC5D;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,EAAE,UAE1D;AAED,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,aAAa,WAEhE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,MAGlD;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,EAAE,UAEpD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,EAAE,WAIzC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,EAAE,EAAE,WAsCvD"}

package/dest/encoding.js

@@ -1,113 +1,123 @@
+import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
 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);
+import { FieldReader } from '@aztec/foundation/serialize';
+const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
+const REVERT_CODE_BIT_SIZE = 8n;
+const NUM_NOTE_HASH_BIT_SIZE = 16n;
+const NUM_NULLIFIER_BIT_SIZE = 16n;
+const NUM_L2_TO_L1_MSG_BIT_SIZE = 16n;
+const NUM_PUBLIC_DATA_WRITE_BIT_SIZE = 16n;
+const NUM_PRIVATE_LOG_BIT_SIZE = 16n;
+const PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
+const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
+// Must match the implementation in `noir-protocol-circuits/crates/rollup-lib/src/tx_base/components/tx_blob_data.nr`.
+export function encodeTxStartMarker(txStartMarker) {
+    let value = TX_START_PREFIX;
+    value <<= NUM_NOTE_HASH_BIT_SIZE;
+    value += BigInt(txStartMarker.numNoteHashes);
+    value <<= NUM_NULLIFIER_BIT_SIZE;
+    value += BigInt(txStartMarker.numNullifiers);
+    value <<= NUM_L2_TO_L1_MSG_BIT_SIZE;
+    value += BigInt(txStartMarker.numL2ToL1Msgs);
+    value <<= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
+    value += BigInt(txStartMarker.numPublicDataWrites);
+    value <<= NUM_PRIVATE_LOG_BIT_SIZE;
+    value += BigInt(txStartMarker.numPrivateLogs);
+    value <<= PUBLIC_LOGS_LENGTH_BIT_SIZE;
+    value += BigInt(txStartMarker.publicLogsLength);
+    value <<= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
+    value += BigInt(txStartMarker.contractClassLogLength);
+    value <<= REVERT_CODE_BIT_SIZE;
+    value += BigInt(txStartMarker.revertCode);
+    value <<= NUM_BLOB_FIELDS_BIT_SIZE;
+    value += BigInt(txStartMarker.numBlobFields);
+    return new Fr(value);
 }
-/**
- * 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();
+export function decodeTxStartMarker(field) {
+    let value = field.toBigInt();
+    const numBlobFields = Number(value & 2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n);
+    value >>= NUM_BLOB_FIELDS_BIT_SIZE;
+    const revertCode = Number(value & 2n ** REVERT_CODE_BIT_SIZE - 1n);
+    value >>= REVERT_CODE_BIT_SIZE;
+    const contractClassLogLength = Number(value & 2n ** CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE - 1n);
+    value >>= CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE;
+    const publicLogsLength = Number(value & 2n ** PUBLIC_LOGS_LENGTH_BIT_SIZE - 1n);
+    value >>= PUBLIC_LOGS_LENGTH_BIT_SIZE;
+    const numPrivateLogs = Number(value & 2n ** NUM_PRIVATE_LOG_BIT_SIZE - 1n);
+    value >>= NUM_PRIVATE_LOG_BIT_SIZE;
+    const numPublicDataWrites = Number(value & 2n ** NUM_PUBLIC_DATA_WRITE_BIT_SIZE - 1n);
+    value >>= NUM_PUBLIC_DATA_WRITE_BIT_SIZE;
+    const numL2ToL1Msgs = Number(value & 2n ** NUM_L2_TO_L1_MSG_BIT_SIZE - 1n);
+    value >>= NUM_L2_TO_L1_MSG_BIT_SIZE;
+    const numNullifiers = Number(value & 2n ** NUM_NULLIFIER_BIT_SIZE - 1n);
+    value >>= NUM_NULLIFIER_BIT_SIZE;
+    const numNoteHashes = Number(value & 2n ** NUM_NOTE_HASH_BIT_SIZE - 1n);
+    value >>= NUM_NOTE_HASH_BIT_SIZE;
+    // Do not throw if the prefix doesn't match.
+    // The caller function can check it by calling `isValidTxStartMarker`, and decide what to do if it's incorrect.
+    const prefix = value;
+    return {
+        prefix,
+        numBlobFields,
+        revertCode,
+        numNoteHashes,
+        numNullifiers,
+        numL2ToL1Msgs,
+        numPublicDataWrites,
+        numPrivateLogs,
+        publicLogsLength,
+        contractClassLogLength
+    };
+}
+export function getNumBlobFieldsFromTxStartMarker(field) {
+    return Number(field.toBigInt() & 2n ** NUM_BLOB_FIELDS_BIT_SIZE - 1n);
+}
+export function isValidTxStartMarker(txStartMarker) {
+    return txStartMarker.prefix === TX_START_PREFIX;
+}
+export function createBlockEndMarker(numTxs) {
+    // Must match the implementation in `block_rollup_public_inputs_composer.nr > create_block_end_marker`.
+    return new Fr(BLOCK_END_PREFIX * 256n * 256n + BigInt(numTxs));
+}
+export function getNumTxsFromBlockEndMarker(field) {
+    return Number(field.toBigInt() & 0xffffn);
+}
+export function isBlockEndMarker(field) {
+    const value = field.toBigInt();
+    const numTxs = value & 0xffffn;
+    return value - numTxs === BLOCK_END_PREFIX * 256n * 256n;
 }
 /**
- * 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))) {
+ * Check that the fields are emitted from the circuits and conform to the encoding.
+ * @param blobFields - The concatenated fields from all blobs of an L1 block.
+ */ export function checkBlobFieldsEncoding(blobFields) {
+    const reader = FieldReader.asReader(blobFields);
+    const checkpointPrefix = reader.readField();
+    if (checkpointPrefix.toBigInt() !== BigInt(blobFields.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;
+    const numFieldsInCheckpoint = checkpointPrefix.toNumber();
+    let seenNumTxs = 0;
+    while(reader.cursor < numFieldsInCheckpoint){
+        const currentField = reader.readField();
+        if (isBlockEndMarker(currentField)) {
+            // Found a block end marker. Confirm that the number of txs in this block is correct.
+            const numTxs = getNumTxsFromBlockEndMarker(currentField);
+            if (numTxs !== seenNumTxs) {
+                return false;
+            }
+            seenNumTxs = 0;
+            continue;
+        }
+        // If the field is not a block end marker, it must be a tx start marker.
+        const txStartMarker = decodeTxStartMarker(currentField);
+        if (!isValidTxStartMarker(txStartMarker)) {
+            return false;
+        }
+        seenNumTxs += 1;
+        // Skip the remaining fields in this tx. -1 because we already read the tx start marker.
+        reader.skip(txStartMarker.numBlobFields - 1);
+    // TODO: Check the encoding of the tx if we want to be more strict.
     }
     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/dest/hash.d.ts

@@ -0,0 +1,35 @@
+import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+/**
+ * Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+ */
+export declare function computeEthVersionedBlobHash(commitment: Buffer): Buffer;
+export declare function computeBlobsHash(evmVersionedBlobHashes: Buffer[]): Fr;
+/**
+ * The hash of the fields added throughout the checkpoint. The exact number of fields is specified by the checkpoint
+ * prefix (the first field). It's verified in the circuit against the fields absorbed into the sponge blob.
+ * This hash is used in generating the challenge z for all blobs in the same checkpoint.
+ */
+export declare function computeBlobFieldsHash(fields: Fr[]): Promise<Fr>;
+export declare function computeBlobCommitment(data: Uint8Array): Buffer;
+/**
+ * Get the commitment fields of the blob, to compute the challenge z.
+ *
+ * The 48-byte commitment is encoded into two field elements:
+ * +-------------------+------------------------+
+ * |      31 bytes     |         17 bytes       |
+ * +-------------------+------------------------+
+ * |  Field Element 1  |     Field Element 2    |
+ * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+ * +-------------------+------------------------+
+ *
+ * @param commitment - The commitment to convert to fields. Computed from `computeBlobCommitment`.
+ * @returns The fields representing the commitment buffer.
+ */
+export declare function commitmentToFields(commitment: Buffer): [Fr, Fr];
+export declare function computeChallengeZ(blobFieldsHash: Fr, commitment: Buffer): Promise<Fr>;
+/**
+ * Hash each u128 limb of the noir bignum struct representing the BLS field, to mimic the hash accumulation in the
+ * rollup circuits.
+ */
+export declare function hashNoirBigNumLimbs(field: BLS12Fr): Promise<Fr>;
+//# sourceMappingURL=hash.d.ts.map

package/dest/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAMvD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAItE;AAOD,wBAAgB,gBAAgB,CAAC,sBAAsB,EAAE,MAAM,EAAE,GAAG,EAAE,CAErE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAErE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAM9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAM/D;AAED,wBAAsB,iBAAiB,CAAC,cAAc,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,CAG3F;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,CAAC,CAGrE"}

package/dest/hash.js

@@ -0,0 +1,69 @@
+import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, kzg } from './kzg_context.js';
+const VERSIONED_HASH_VERSION_KZG = 0x01;
+/**
+ * Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+ */ export function computeEthVersionedBlobHash(commitment) {
+    const hash = sha256(commitment);
+    hash[0] = VERSIONED_HASH_VERSION_KZG;
+    return hash;
+}
+// TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
+// - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
+// - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+//   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
+// We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
+export function computeBlobsHash(evmVersionedBlobHashes) {
+    return sha256ToField(evmVersionedBlobHashes);
+}
+/**
+ * The hash of the fields added throughout the checkpoint. The exact number of fields is specified by the checkpoint
+ * prefix (the first field). It's verified in the circuit against the fields absorbed into the sponge blob.
+ * This hash is used in generating the challenge z for all blobs in the same checkpoint.
+ */ export async function computeBlobFieldsHash(fields) {
+    return await poseidon2Hash(fields);
+}
+export function computeBlobCommitment(data) {
+    if (data.length !== BYTES_PER_BLOB) {
+        throw new Error(`Expected ${BYTES_PER_BLOB} bytes per blob. Got ${data.length}.`);
+    }
+    return Buffer.from(kzg.blobToKzgCommitment(data));
+}
+/**
+ * Get the commitment fields of the blob, to compute the challenge z.
+ *
+ * The 48-byte commitment is encoded into two field elements:
+ * +-------------------+------------------------+
+ * |      31 bytes     |         17 bytes       |
+ * +-------------------+------------------------+
+ * |  Field Element 1  |     Field Element 2    |
+ * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+ * +-------------------+------------------------+
+ *
+ * @param commitment - The commitment to convert to fields. Computed from `computeBlobCommitment`.
+ * @returns The fields representing the commitment buffer.
+ */ export function commitmentToFields(commitment) {
+    if (commitment.length !== BYTES_PER_COMMITMENT) {
+        throw new Error(`Expected ${BYTES_PER_COMMITMENT} bytes for blob commitment. Got ${commitment.length}.`);
+    }
+    return [
+        new Fr(commitment.subarray(0, 31)),
+        new Fr(commitment.subarray(31, BYTES_PER_COMMITMENT))
+    ];
+}
+export async function computeChallengeZ(blobFieldsHash, commitment) {
+    const commitmentFields = commitmentToFields(commitment);
+    return await poseidon2Hash([
+        blobFieldsHash,
+        commitmentFields[0],
+        commitmentFields[1]
+    ]);
+}
+/**
+ * Hash each u128 limb of the noir bignum struct representing the BLS field, to mimic the hash accumulation in the
+ * rollup circuits.
+ */ export async function hashNoirBigNumLimbs(field) {
+    const num = field.toNoirBigNum();
+    return await poseidon2Hash(num.limbs.map(Fr.fromHexString));
+}

package/dest/index.d.ts

@@ -1,8 +1,11 @@
 export * from './blob.js';
 export * from './blob_batching.js';
+export * from './blob_utils.js';
+export * from './circuit_types/index.js';
+export * from './deserialize.js';
 export * from './encoding.js';
-export * from './interface.js';
 export * from './errors.js';
-export * from './blob_batching_public_inputs.js';
+export * from './hash.js';
+export * from './interface.js';
 export * from './sponge_blob.js';
 //# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,kCAAkC,CAAC;AACjD,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}