@aztec-labs/blob-lib 6.0.0-nightly.20260829

package/dest/encoding/tx_blob_data.js

@@ -0,0 +1,79 @@
+import { chunk } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FieldReader } from '@aztec-labs/foundation/serialize';
+import { BlobDeserializationError } from '../errors.js';
+import { decodeTxStartMarker, encodeTxStartMarker } from './tx_start_marker.js';
+export function encodeTxBlobData(txBlobData) {
+    return [
+        encodeTxStartMarker(txBlobData.txStartMarker),
+        txBlobData.txHash,
+        txBlobData.transactionFee,
+        ...txBlobData.noteHashes,
+        ...txBlobData.nullifiers,
+        ...txBlobData.l2ToL1Msgs,
+        ...txBlobData.publicDataWrites.flat(),
+        ...txBlobData.privateLogs.map((log)=>[
+                new Fr(log.length),
+                ...log
+            ]).flat(),
+        ...txBlobData.publicLogs,
+        ...txBlobData.contractClassLog
+    ];
+}
+export function decodeTxBlobData(fields) {
+    const reader = FieldReader.asReader(fields);
+    if (reader.isFinished()) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for tx blob data.`);
+    }
+    const txStartMarker = decodeTxStartMarker(reader.readField());
+    const checkRemainingFields = (requiredFields, type)=>{
+        if (requiredFields > reader.remainingFields()) {
+            throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for ${type}. Expected ${requiredFields} fields, only ${reader.remainingFields()} remaining.`);
+        }
+    };
+    const numTxEffectFields = txStartMarker.numBlobFields - 1; // -1 because we already read the tx start marker.
+    checkRemainingFields(numTxEffectFields, 'tx effect');
+    const txHash = reader.readField();
+    const transactionFee = reader.readField();
+    checkRemainingFields(txStartMarker.numNoteHashes, 'note hashes');
+    const noteHashes = reader.readFieldArray(txStartMarker.numNoteHashes);
+    checkRemainingFields(txStartMarker.numNullifiers, 'nullifiers');
+    const nullifiers = reader.readFieldArray(txStartMarker.numNullifiers);
+    checkRemainingFields(txStartMarker.numL2ToL1Msgs, 'l2-to-l1 messages');
+    const l2ToL1Msgs = reader.readFieldArray(txStartMarker.numL2ToL1Msgs);
+    checkRemainingFields(txStartMarker.numPublicDataWrites * 2, 'public data writes'); // *2 for leaf slot and value
+    const publicDataWrites = chunk(reader.readFieldArray(txStartMarker.numPublicDataWrites * 2), 2);
+    const privateLogs = Array.from({
+        length: txStartMarker.numPrivateLogs
+    }, ()=>{
+        const length = reader.readU32();
+        checkRemainingFields(length, 'private log');
+        return reader.readFieldArray(length);
+    });
+    checkRemainingFields(txStartMarker.publicLogsLength, 'public logs');
+    const publicLogs = reader.readFieldArray(txStartMarker.publicLogsLength);
+    const contractClassLogBlobDataLength = txStartMarker.contractClassLogLength > 0 ? txStartMarker.contractClassLogLength + 1 : 0; // If the log exists, +1 for the contract address
+    checkRemainingFields(contractClassLogBlobDataLength, 'contract class logs');
+    const contractClassLog = reader.readFieldArray(contractClassLogBlobDataLength);
+    return {
+        txStartMarker,
+        txHash,
+        transactionFee,
+        noteHashes,
+        nullifiers,
+        l2ToL1Msgs,
+        publicDataWrites,
+        privateLogs,
+        publicLogs,
+        contractClassLog
+    };
+}
+export function getNumTxBlobFields(txStartMarker) {
+    return 1 + // tx start marker
+    1 + // tx hash
+    1 + // transaction fee
+    txStartMarker.numNoteHashes + txStartMarker.numNullifiers + txStartMarker.numL2ToL1Msgs + txStartMarker.numPublicDataWrites * 2 + // *2 for leaf slot and value per public data write
+    txStartMarker.numPrivateLogs + // +1 length field for each private log
+    txStartMarker.privateLogsLength + txStartMarker.publicLogsLength + txStartMarker.contractClassLogLength + (txStartMarker.contractClassLogLength > 0 ? 1 : 0 // +1 for contract address of the contract class log
+    );
+}

package/dest/encoding/tx_start_marker.d.ts

@@ -0,0 +1,16 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+export interface TxStartMarker {
+    numBlobFields: number;
+    revertCode: number;
+    numNoteHashes: number;
+    numNullifiers: number;
+    numL2ToL1Msgs: number;
+    numPublicDataWrites: number;
+    numPrivateLogs: number;
+    privateLogsLength: number;
+    publicLogsLength: number;
+    contractClassLogLength: number;
+}
+export declare function encodeTxStartMarker(txStartMarker: TxStartMarker): Fr;
+export declare function decodeTxStartMarker(field: Fr): TxStartMarker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfc3RhcnRfbWFya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW5jb2RpbmcvdHhfc3RhcnRfbWFya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQWlCekQsTUFBTSxXQUFXLGFBQWE7SUFDNUIsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLG1CQUFtQixFQUFFLE1BQU0sQ0FBQztJQUM1QixjQUFjLEVBQUUsTUFBTSxDQUFDO0lBQ3ZCLGlCQUFpQixFQUFFLE1BQU0sQ0FBQztJQUMxQixnQkFBZ0IsRUFBRSxNQUFNLENBQUM7SUFDekIsc0JBQXNCLEVBQUUsTUFBTSxDQUFDO0NBQ2hDO0FBRUQsd0JBQWdCLG1CQUFtQixDQUFDLGFBQWEsRUFBRSxhQUFhLEdBQUcsRUFBRSxDQXVCcEU7QUFFRCx3QkFBZ0IsbUJBQW1CLENBQUMsS0FBSyxFQUFFLEVBQUUsR0FBRyxhQUFhLENBd0M1RCJ9

package/dest/encoding/tx_start_marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_start_marker.d.ts","sourceRoot":"","sources":["../../src/encoding/tx_start_marker.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAiBzD,MAAM,WAAW,aAAa;IAC5B,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,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,EAAE,CAuBpE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,EAAE,GAAG,aAAa,CAwC5D"}

package/dest/encoding/tx_start_marker.js

@@ -0,0 +1,77 @@
+import { TX_START_PREFIX } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BlobDeserializationError } from '../errors.js';
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/tx_blob_data.nr`.
+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 PRIVATE_LOGS_LENGTH_BIT_SIZE = 16n;
+const PUBLIC_LOGS_LENGTH_BIT_SIZE = 32n;
+const CONTRACT_CLASS_LOG_LENGTH_BIT_SIZE = 16n;
+export function encodeTxStartMarker(txStartMarker) {
+    let value = BigInt(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 <<= PRIVATE_LOGS_LENGTH_BIT_SIZE;
+    value += BigInt(txStartMarker.privateLogsLength);
+    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);
+}
+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 privateLogsLength = Number(value & 2n ** PRIVATE_LOGS_LENGTH_BIT_SIZE - 1n);
+    value >>= PRIVATE_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;
+    const prefix = value;
+    if (prefix !== BigInt(TX_START_PREFIX)) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: invalid tx start marker.`);
+    }
+    return {
+        numBlobFields,
+        revertCode,
+        numNoteHashes,
+        numNullifiers,
+        numL2ToL1Msgs,
+        numPublicDataWrites,
+        numPrivateLogs,
+        privateLogsLength,
+        publicLogsLength,
+        contractClassLogLength
+    };
+}

package/dest/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class BlobDeserializationError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHFCQUFhLHdCQUF5QixTQUFRLEtBQUs7SUFDakQsWUFBWSxPQUFPLEVBQUUsTUFBTSxFQUcxQjtDQUNGIn0=

package/dest/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF"}

package/dest/errors.js

@@ -0,0 +1,6 @@
+export class BlobDeserializationError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'BlobDeserializationError';
+    }
+}

package/dest/hash.d.ts

@@ -0,0 +1,44 @@
+import { BLS12Fr } from '@aztec-labs/foundation/curves/bls12';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+/**
+ * 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;
+/**
+ * Computes a non-standard Poseidon2 hash over the provided fields.
+ *
+ * This function is used to compute:
+ * - `blobFieldsHash` of a checkpoint:
+ *   Verified in the circuit against all fields absorbed into the blob sponge over the entire checkpoint.
+ *   The exact number of fields is encoded in the checkpoint end marker (the last field).
+ *   This hash is used when generating the challenge `z` for all blobs in the checkpoint.
+ * - `spongeBlobHash` of a block:
+ *   Computed from the block's tx effects, its end-state, and the blob fields of all prior blocks in the same checkpoint.
+ *   This hash is included in the block header.
+ */
+export declare function computeBlobFieldsHash(fields: Fr[]): Promise<Fr>;
+export declare function computeBlobCommitment(data: Uint8Array): Promise<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 the u128 limbs of a BLS field's noir bignum representation under the `BLOB_HASHED_Y_LIMBS` separator.
+ * Used to commit to blob evaluation values `y_i` before folding them into the gamma accumulator; mirrors the
+ * hash accumulation performed in the rollup circuits.
+ */
+export declare function hashBlobYLimbs(field: BLS12Fr): Promise<Fr>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2hhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQU96RDs7R0FFRztBQUNILHdCQUFnQiwyQkFBMkIsQ0FBQyxVQUFVLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FJdEU7QUFPRCx3QkFBZ0IsZ0JBQWdCLENBQUMsc0JBQXNCLEVBQUUsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUVyRTtBQUVEOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsd0JBQXNCLHFCQUFxQixDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsRUFBRSxDQUFDLENBSXJFO0FBRUQsd0JBQXNCLHFCQUFxQixDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQU03RTtBQUVEOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCx3QkFBZ0Isa0JBQWtCLENBQUMsVUFBVSxFQUFFLE1BQU0sR0FBRyxDQUFDLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FNL0Q7QUFFRCx3QkFBc0IsaUJBQWlCLENBQUMsY0FBYyxFQUFFLEVBQUUsRUFBRSxVQUFVLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FNM0Y7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQXNCLGNBQWMsQ0FBQyxLQUFLLEVBQUUsT0FBTyxHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FHaEUifQ==

package/dest/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAOzD;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAItE;AAOD,wBAAgB,gBAAgB,CAAC,sBAAsB,EAAE,MAAM,EAAE,GAAG,EAAE,CAErE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAIrE;AAED,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAM7E;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,CAM3F;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,EAAE,CAAC,CAGhE"}

package/dest/hash.js

@@ -0,0 +1,82 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { sha256, sha256ToField } from '@aztec-labs/foundation/crypto/sha256';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { getBytesPerBlob, getBytesPerCommitment, getKzg } from './kzg_context.js';
+import { SpongeBlob } from './sponge_blob.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);
+}
+/**
+ * Computes a non-standard Poseidon2 hash over the provided fields.
+ *
+ * This function is used to compute:
+ * - `blobFieldsHash` of a checkpoint:
+ *   Verified in the circuit against all fields absorbed into the blob sponge over the entire checkpoint.
+ *   The exact number of fields is encoded in the checkpoint end marker (the last field).
+ *   This hash is used when generating the challenge `z` for all blobs in the checkpoint.
+ * - `spongeBlobHash` of a block:
+ *   Computed from the block's tx effects, its end-state, and the blob fields of all prior blocks in the same checkpoint.
+ *   This hash is included in the block header.
+ */ export async function computeBlobFieldsHash(fields) {
+    const sponge = SpongeBlob.init();
+    await sponge.absorb(fields);
+    return sponge.squeeze();
+}
+export async function computeBlobCommitment(data) {
+    if (data.length !== getBytesPerBlob()) {
+        throw new Error(`Expected ${getBytesPerBlob()} bytes per blob. Got ${data.length}.`);
+    }
+    return Buffer.from(await getKzg().asyncBlobToKzgCommitment(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 !== getBytesPerCommitment()) {
+        throw new Error(`Expected ${getBytesPerCommitment()} bytes for blob commitment. Got ${commitment.length}.`);
+    }
+    return [
+        new Fr(commitment.subarray(0, 31)),
+        new Fr(commitment.subarray(31, getBytesPerCommitment()))
+    ];
+}
+export async function computeChallengeZ(blobFieldsHash, commitment) {
+    const commitmentFields = commitmentToFields(commitment);
+    return await poseidon2HashWithSeparator([
+        blobFieldsHash,
+        commitmentFields[0],
+        commitmentFields[1]
+    ], DomainSeparator.BLOB_CHALLENGE_Z);
+}
+/**
+ * Hash the u128 limbs of a BLS field's noir bignum representation under the `BLOB_HASHED_Y_LIMBS` separator.
+ * Used to commit to blob evaluation values `y_i` before folding them into the gamma accumulator; mirrors the
+ * hash accumulation performed in the rollup circuits.
+ */ export async function hashBlobYLimbs(field) {
+    const num = field.toNoirBigNum();
+    return await poseidon2HashWithSeparator(num.limbs.map(Fr.fromHexString), DomainSeparator.BLOB_HASHED_Y_LIMBS);
+}

package/dest/index.d.ts

@@ -0,0 +1,11 @@
+export * from './batched_blob.js';
+export * from './blob.js';
+export * from './blob_batching.js';
+export * from './blob_utils.js';
+export * from './circuit_types/index.js';
+export * from './encoding/index.js';
+export * from './hash.js';
+export * from './interface.js';
+export * from './sponge_blob.js';
+export * from './kzg_context.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsa0JBQWtCLENBQUMifQ==

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}

package/dest/index.js

@@ -0,0 +1,10 @@
+export * from './batched_blob.js';
+export * from './blob.js';
+export * from './blob_batching.js';
+export * from './blob_utils.js';
+export * from './circuit_types/index.js';
+export * from './encoding/index.js';
+export * from './hash.js';
+export * from './interface.js';
+export * from './sponge_blob.js';
+export * from './kzg_context.js';

package/dest/interface.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The relevant parts of a response from https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
+ */
+export interface BlobJson {
+    blob: string;
+    kzg_commitment: string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxXQUFXLFFBQVE7SUFDdkIsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLGNBQWMsRUFBRSxNQUFNLENBQUM7Q0FDeEIifQ==

package/dest/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../src/interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;CACxB"}

package/dest/interface.js

@@ -0,0 +1,3 @@
+/**
+ * The relevant parts of a response from https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
+ */ export { };

package/dest/kzg_context.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { DasContextJs } from '@crate-crypto/node-eth-kzg';
+export type { DasContextJs } from '@crate-crypto/node-eth-kzg';
+export declare function getBytesPerBlob(): number;
+export declare function getBytesPerCommitment(): number;
+/**
+ * Returns the lazily-initialized KZG context. The first call synchronously builds the
+ * precomputation tables (~2s locally, blocking the event loop; longer under constrained CPU), so
+ * callers on a latency-sensitive path should warm it ahead of time. Pass a logger to record how
+ * long that first build took.
+ * @param logger - Optional logger; when provided, the initial table build is timed and logged.
+ */
+export declare function getKzg(logger?: Logger): DasContextJs;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia3pnX2NvbnRleHQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9remdfY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUV6RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQU0vRCxZQUFZLEVBQUUsWUFBWSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFlL0Qsd0JBQWdCLGVBQWUsSUFBSSxNQUFNLENBRXhDO0FBRUQsd0JBQWdCLHFCQUFxQixJQUFJLE1BQU0sQ0FFOUM7QUFJRDs7Ozs7O0dBTUc7QUFDSCx3QkFBZ0IsTUFBTSxDQUFDLE1BQU0sQ0FBQyxFQUFFLE1BQU0sR0FBRyxZQUFZLENBT3BEIn0=

package/dest/kzg_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kzg_context.d.ts","sourceRoot":"","sources":["../src/kzg_context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAM/D,YAAY,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAe/D,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAID;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,YAAY,CAOpD"}

package/dest/kzg_context.js

@@ -0,0 +1,37 @@
+import { elapsedSync } from '@aztec-labs/foundation/timer';
+import { createRequire } from 'module';
+let nativeModule;
+/** Lazily loads the @crate-crypto/node-eth-kzg native module. */ function loadNativeModule() {
+    if (!nativeModule) {
+        const require = createRequire(import.meta.url);
+        nativeModule = require('@crate-crypto/node-eth-kzg');
+    }
+    return nativeModule;
+}
+// Ethereum blob constants, loaded lazily from the native module.
+// Values: BYTES_PER_BLOB=131072, BYTES_PER_COMMITMENT=48
+export function getBytesPerBlob() {
+    return loadNativeModule().BYTES_PER_BLOB;
+}
+export function getBytesPerCommitment() {
+    return loadNativeModule().BYTES_PER_COMMITMENT;
+}
+let kzgInstance;
+/**
+ * Returns the lazily-initialized KZG context. The first call synchronously builds the
+ * precomputation tables (~2s locally, blocking the event loop; longer under constrained CPU), so
+ * callers on a latency-sensitive path should warm it ahead of time. Pass a logger to record how
+ * long that first build took.
+ * @param logger - Optional logger; when provided, the initial table build is timed and logged.
+ */ export function getKzg(logger) {
+    if (!kzgInstance) {
+        const [durationMs, instance] = elapsedSync(()=>loadNativeModule().DasContextJs.create({
+                usePrecomp: true
+            }));
+        kzgInstance = instance;
+        logger?.verbose(`Loaded KZG trusted setup`, {
+            durationMs
+        });
+    }
+    return kzgInstance;
+}

package/dest/sponge_blob.d.ts

@@ -0,0 +1,50 @@
+import { type FieldsOf } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, type Tuple } from '@aztec-labs/foundation/serialize';
+/**
+ * A Poseidon2 sponge used to accumulate data that will be added to blobs.
+ * See noir-projects/fnd/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr.
+ */
+export declare class SpongeBlob {
+    /** Sponge with absorbed fields that will go into one or more blobs. */
+    readonly sponge: Poseidon2Sponge;
+    /** Number of effects absorbed so far. */
+    numAbsorbedFields: number;
+    static MAX_FIELDS: number;
+    constructor(
+    /** Sponge with absorbed fields that will go into one or more blobs. */
+    sponge: Poseidon2Sponge, 
+    /** Number of effects absorbed so far. */
+    numAbsorbedFields: number);
+    /**
+     * Initialize the sponge blob to absorb data for a checkpoint.
+     */
+    static init(): SpongeBlob;
+    static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static getFields(fields: FieldsOf<SpongeBlob>): (number | Poseidon2Sponge)[];
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): SpongeBlob;
+    clone(): SpongeBlob;
+    absorb(fields: Fr[]): Promise<void>;
+    squeeze(): Promise<Fr>;
+    static empty(): SpongeBlob;
+}
+export declare class Poseidon2Sponge {
+    cache: Tuple<Fr, 3>;
+    state: Tuple<Fr, 4>;
+    cacheSize: number;
+    squeezeMode: boolean;
+    constructor(cache: Tuple<Fr, 3>, state: Tuple<Fr, 4>, cacheSize: number, squeezeMode: boolean);
+    static fromBuffer(buffer: Buffer | BufferReader): Poseidon2Sponge;
+    toBuffer(): Buffer<ArrayBufferLike>;
+    static getFields(fields: FieldsOf<Poseidon2Sponge>): (number | boolean | [Fr, Fr, Fr] | [Fr, Fr, Fr, Fr])[];
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): Poseidon2Sponge;
+    static empty(): Poseidon2Sponge;
+    static init(iv: Fr): Poseidon2Sponge;
+    performDuplex(): Promise<void>;
+    absorb(fields: Fr[]): Promise<void>;
+    squeeze(): Promise<Fr>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/sponge_blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sponge_blob.d.ts","sourceRoot":"","sources":["../src/sponge_blob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAa,MAAM,8BAA8B,CAAC;AAExE,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,KAAK,EAGX,MAAM,kCAAkC,CAAC;AAE1C;;;GAGG;AACH,qBAAa,UAAU;IAInB,uEAAuE;aACvD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,iBAAiB,EAAE,MAAM;IANlC,MAAM,CAAC,UAAU,SAA0C;IAE3D;IACE,uEAAuE;IACvD,MAAM,EAAE,eAAe;IACvC,yCAAyC;IAClC,iBAAiB,EAAE,MAAM,EAC9B;IAEJ;;OAEG;IACH,MAAM,CAAC,IAAI,IAAI,UAAU,CAKxB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU,CAG3D;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,gCAE5C;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU,CAGxD;IAED,KAAK,eAEJ;IAEK,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,iBAQxB;IAEK,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC,CAE3B;IAED,MAAM,CAAC,KAAK,IAAI,UAAU,CAEzB;CACF;AAGD,qBAAa,eAAe;IAEjB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IACnB,SAAS,EAAE,MAAM;IACjB,WAAW,EAAE,OAAO;IAJ7B,YACS,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,OAAO,EACzB;IAEJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe,CAQhE;IAED,QAAQ,4BAEP;IAED,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,0DAEjD;IAED,QAAQ,IAAI,EAAE,EAAE,CAEf;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe,CAQ7D;IAED,MAAM,CAAC,KAAK,IAAI,eAAe,CAO9B;IAED,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,eAAe,CAInC;IAKK,aAAa,kBASlB;IAEK,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,iBAaxB;IAEK,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC,CAO3B;CACF"}

package/dest/sponge_blob.js

@@ -0,0 +1,144 @@
+import { BLOBS_PER_CHECKPOINT, FIELDS_PER_BLOB, TWO_POW_64 } from '@aztec-labs/constants';
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { poseidon2Permutation } from '@aztec-labs/foundation/crypto/poseidon';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec-labs/foundation/serialize';
+/**
+ * A Poseidon2 sponge used to accumulate data that will be added to blobs.
+ * See noir-projects/fnd/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr.
+ */ export class SpongeBlob {
+    sponge;
+    numAbsorbedFields;
+    static MAX_FIELDS = BLOBS_PER_CHECKPOINT * FIELDS_PER_BLOB;
+    constructor(/** Sponge with absorbed fields that will go into one or more blobs. */ sponge, /** Number of effects absorbed so far. */ numAbsorbedFields){
+        this.sponge = sponge;
+        this.numAbsorbedFields = numAbsorbedFields;
+    }
+    /**
+   * Initialize the sponge blob to absorb data for a checkpoint.
+   */ static init() {
+        // This must match the implementation in noir-projects/fnd/noir-protocol-circuits/crates/types/src/blob_data/sponge_blob.nr
+        const iv = new Fr(BigInt(SpongeBlob.MAX_FIELDS) * TWO_POW_64);
+        const sponge = Poseidon2Sponge.init(iv);
+        return new SpongeBlob(sponge, 0);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readNumber());
+    }
+    toBuffer() {
+        return serializeToBuffer(...SpongeBlob.getFields(this));
+    }
+    static getFields(fields) {
+        return [
+            fields.sponge,
+            fields.numAbsorbedFields
+        ];
+    }
+    toFields() {
+        return serializeToFields(...SpongeBlob.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new SpongeBlob(reader.readObject(Poseidon2Sponge), reader.readField().toNumber());
+    }
+    clone() {
+        return SpongeBlob.fromBuffer(this.toBuffer());
+    }
+    async absorb(fields) {
+        if (this.numAbsorbedFields + fields.length > SpongeBlob.MAX_FIELDS) {
+            throw new Error(`Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${SpongeBlob.MAX_FIELDS}`);
+        }
+        await this.sponge.absorb(fields);
+        this.numAbsorbedFields += fields.length;
+    }
+    async squeeze() {
+        return await this.sponge.squeeze();
+    }
+    static empty() {
+        return new SpongeBlob(Poseidon2Sponge.empty(), 0);
+    }
+}
+// This is just noir's stdlib version of the poseidon2 sponge. We use it for a blob-specific implmentation of the hasher.
+export class Poseidon2Sponge {
+    cache;
+    state;
+    cacheSize;
+    squeezeMode;
+    constructor(cache, state, cacheSize, squeezeMode){
+        this.cache = cache;
+        this.state = state;
+        this.cacheSize = cacheSize;
+        this.squeezeMode = squeezeMode;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new Poseidon2Sponge(reader.readArray(3, Fr), reader.readArray(4, Fr), reader.readNumber(), reader.readBoolean());
+    }
+    toBuffer() {
+        return serializeToBuffer(this.cache, this.state, this.cacheSize, this.squeezeMode);
+    }
+    static getFields(fields) {
+        return [
+            fields.cache,
+            fields.state,
+            fields.cacheSize,
+            fields.squeezeMode
+        ];
+    }
+    toFields() {
+        return serializeToFields(...Poseidon2Sponge.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new Poseidon2Sponge(reader.readFieldArray(3), reader.readFieldArray(4), reader.readField().toNumber(), reader.readBoolean());
+    }
+    static empty() {
+        return new Poseidon2Sponge(makeTuple(3, ()=>Fr.ZERO), makeTuple(4, ()=>Fr.ZERO), 0, false);
+    }
+    static init(iv) {
+        const sponge = Poseidon2Sponge.empty();
+        sponge.state[3] = iv;
+        return sponge;
+    }
+    // Note: there isn't currently an impl in ts that allows for a custom aborption via an
+    // existing sponge.
+    // A custom blob-based impl of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr
+    async performDuplex() {
+        for(let i = 0; i < this.cache.length; i++){
+            if (i < this.cacheSize) {
+                this.state[i] = this.state[i].add(this.cache[i]);
+            }
+        }
+        const perm = await poseidon2Permutation(this.state);
+        // ts doesn't understand that the above always gives 4
+        this.state = [
+            perm[0],
+            perm[1],
+            perm[2],
+            perm[3]
+        ];
+    }
+    async absorb(fields) {
+        if (this.squeezeMode) {
+            throw new Error(`Poseidon sponge is not able to absorb more inputs.`);
+        }
+        for (const field of fields){
+            if (this.cacheSize == this.cache.length) {
+                await this.performDuplex();
+                this.cache[0] = field;
+                this.cacheSize = 1;
+            } else {
+                this.cache[this.cacheSize++] = field;
+            }
+        }
+    }
+    async squeeze() {
+        if (this.squeezeMode) {
+            throw new Error(`Poseidon sponge has already been squeezed.`);
+        }
+        await this.performDuplex();
+        this.squeezeMode = true;
+        return this.state[0];
+    }
+}