@aztec/blob-lib 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/dest/blob_batching.js

@@ -1,24 +1,52 @@
-import { AZTEC_MAX_EPOCH_DURATION, BLOBS_PER_BLOCK } from '@aztec/constants';
-import { poseidon2Hash, sha256ToField } from '@aztec/foundation/crypto';
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { computeBlobFieldsHashFromBlobs } from './blob_utils.js';
+import { BLOBS_PER_CHECKPOINT, MAX_CHECKPOINTS_PER_EPOCH } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BatchedBlob } from './batched_blob.js';
+import { getBlobsPerL1Block } from './blob_utils.js';
 import { BlobAccumulator, FinalBlobAccumulator, FinalBlobBatchingChallenges } from './circuit_types/index.js';
-import { computeEthVersionedBlobHash, hashNoirBigNumLimbs } from './hash.js';
-import { kzg } from './kzg_context.js';
+import { computeBlobFieldsHash, hashNoirBigNumLimbs } from './hash.js';
+import { getKzg } from './kzg_context.js';
 /**
  * A class to create, manage, and prove batched EVM blobs.
- */ export class BatchedBlob {
-    blobCommitmentsHash;
-    z;
-    y;
-    commitment;
-    q;
-    constructor(/** Hash of Cs (to link to L1 blob hashes). */ blobCommitmentsHash, /** Challenge point z such that p_i(z) = y_i. */ z, /** Evaluation y, linear combination of all evaluations y_i = p_i(z) with gamma. */ y, /** Commitment C, linear combination of all commitments C_i = [p_i] with gamma. */ commitment, /** KZG opening 'proof' Q (commitment to the quotient poly.), linear combination of all blob kzg 'proofs' Q_i with gamma. */ q){
-        this.blobCommitmentsHash = blobCommitmentsHash;
-        this.z = z;
-        this.y = y;
-        this.commitment = commitment;
-        this.q = q;
+ * See noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr
+ */ export class BatchedBlobAccumulator {
+    blobCommitmentsHashAcc;
+    zAcc;
+    yAcc;
+    cAcc;
+    qAcc;
+    gammaAcc;
+    gammaPow;
+    finalBlobChallenges;
+    constructor(/** Hash of Cs (to link to L1 blob hashes). */ blobCommitmentsHashAcc, /** Challenge point z_acc. Final value used such that p_i(z) = y_i. */ zAcc, /** Evaluation y_acc. Final value is is linear combination of all evaluations y_i = p_i(z) with gamma. */ yAcc, /** Commitment c_acc. Final value is linear combination of all commitments C_i = [p_i] with gamma. */ cAcc, /** KZG opening q_acc. Final value is linear combination of all blob kzg 'proofs' Q_i with gamma. */ qAcc, /**
+     * Challenge point gamma_acc for multi opening. Used with y, C, and kzg 'proof' Q above.
+     * TODO(#13608): We calculate this by hashing natively in the circuit (hence Fr representation), but it's actually used
+     * as a BLS12Fr field elt. Is this safe? Is there a skew?
+     */ gammaAcc, /** Simply gamma^(i + 1) at blob i. Used for calculating the i'th element of the above linear comb.s */ gammaPow, /** Final challenge values used in evaluation. Optimistically input and checked in the final acc. */ finalBlobChallenges){
+        this.blobCommitmentsHashAcc = blobCommitmentsHashAcc;
+        this.zAcc = zAcc;
+        this.yAcc = yAcc;
+        this.cAcc = cAcc;
+        this.qAcc = qAcc;
+        this.gammaAcc = gammaAcc;
+        this.gammaPow = gammaPow;
+        this.finalBlobChallenges = finalBlobChallenges;
+    }
+    /**
+   * Create the empty accumulation state of the epoch.
+   * @returns An empty blob accumulator with challenges.
+   */ static newWithChallenges(finalBlobChallenges) {
+        return new BatchedBlobAccumulator(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO, finalBlobChallenges);
+    }
+    /**
+   * Returns an empty BatchedBlobAccumulator with precomputed challenges from all blobs in the epoch.
+   * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
+   *      beforehand from ALL blobs.
+   */ static async fromBlobFields(blobFieldsPerCheckpoint) {
+        const finalBlobChallenges = await this.precomputeBatchedBlobChallenges(blobFieldsPerCheckpoint);
+        return BatchedBlobAccumulator.newWithChallenges(finalBlobChallenges);
     }
     /**
    * Get the final batched opening proof from multiple blobs.
@@ -26,25 +54,18 @@ import { kzg } from './kzg_context.js';
    *      beforehand from ALL blobs.
    *
    * @returns A batched blob.
-   */ static async batch(blobs) {
-        if (blobs.length > AZTEC_MAX_EPOCH_DURATION) {
-            throw new Error(`Too many blocks sent to batch(). The maximum is ${AZTEC_MAX_EPOCH_DURATION}. Got ${blobs.length}.`);
+   */ static async batch(blobFieldsPerCheckpoint, verifyProof = false) {
+        const numCheckpoints = blobFieldsPerCheckpoint.length;
+        if (numCheckpoints > MAX_CHECKPOINTS_PER_EPOCH) {
+            throw new Error(`Too many checkpoints sent to batch(). The maximum is ${MAX_CHECKPOINTS_PER_EPOCH}. Got ${numCheckpoints}.`);
         }
         // Precalculate the values (z and gamma) and initialize the accumulator:
-        let acc = await this.newAccumulator(blobs);
+        let acc = await this.fromBlobFields(blobFieldsPerCheckpoint);
         // Now we can create a multi opening proof of all input blobs:
-        for (const blockBlobs of blobs){
-            acc = await acc.accumulateBlobs(blockBlobs);
+        for (const blobFields of blobFieldsPerCheckpoint){
+            acc = await acc.accumulateFields(blobFields);
         }
-        return await acc.finalize();
-    }
-    /**
-   * Returns an empty BatchedBlobAccumulator with precomputed challenges from all blobs in the epoch.
-   * @dev MUST input all blobs to be broadcast. Does not work in multiple calls because z and gamma are calculated
-   *      beforehand from ALL blobs.
-   */ static async newAccumulator(blobs) {
-        const finalBlobChallenges = await this.precomputeBatchedBlobChallenges(blobs);
-        return BatchedBlobAccumulator.newWithChallenges(finalBlobChallenges);
+        return await acc.finalize(verifyProof);
     }
     /**
    * Gets the final challenges based on all blobs and their elements to perform a multi opening proof.
@@ -57,13 +78,15 @@ import { kzg } from './kzg_context.js';
    *
    * @param blobs - The blobs to precompute the challenges for. Each sub-array is the blobs for an L1 block.
    * @returns Challenges z and gamma.
-   */ static async precomputeBatchedBlobChallenges(blobs) {
+   */ static async precomputeBatchedBlobChallenges(blobFieldsPerCheckpoint) {
         // Compute the final challenge z to evaluate the blobs.
         let z;
-        for (const blockBlobs of blobs){
+        const allBlobs = [];
+        for (const blobFields of blobFieldsPerCheckpoint){
             // Compute the hash of all the fields in the block.
-            const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blockBlobs);
-            for (const blob of blockBlobs){
+            const blobFieldsHash = await computeBlobFieldsHash(blobFields);
+            const blobs = await getBlobsPerL1Block(blobFields);
+            for (const blob of blobs){
                 // Compute the challenge z for each blob and accumulate it.
                 const challengeZ = await blob.computeChallengeZ(blobFieldsHash);
                 if (!z) {
@@ -75,13 +98,13 @@ import { kzg } from './kzg_context.js';
                     ]);
                 }
             }
+            allBlobs.push(...blobs);
         }
         if (!z) {
             throw new Error('No blobs to precompute challenges for.');
         }
         // Now we have a shared challenge for all blobs, evaluate them...
-        const allBlobs = blobs.flat();
-        const proofObjects = allBlobs.map((b)=>b.evaluate(z));
+        const proofObjects = await Promise.all(allBlobs.map((b)=>b.evaluate(z)));
         const evaluations = await Promise.all(proofObjects.map(({ y })=>hashNoirBigNumLimbs(y)));
         // ...and find the challenge for the linear combination of blobs.
         let gamma = evaluations[0];
@@ -98,74 +121,12 @@ import { kzg } from './kzg_context.js';
         ]);
         return new FinalBlobBatchingChallenges(z, BLS12Fr.fromBN254Fr(gamma));
     }
-    verify() {
-        return kzg.verifyKzgProof(this.commitment.compress(), this.z.toBuffer(), this.y.toBuffer(), this.q.compress());
-    }
-    // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
-    getEthVersionedBlobHash() {
-        return computeEthVersionedBlobHash(this.commitment.compress());
-    }
-    /**
-   * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
-   *
-   * input[:32]     - versioned_hash
-   * input[32:64]   - z
-   * input[64:96]   - y
-   * input[96:144]  - commitment C
-   * input[144:192] - commitment Q (a 'proof' committing to the quotient polynomial q(X))
-   *
-   * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
-   */ getEthBlobEvaluationInputs() {
-        const buf = Buffer.concat([
-            this.getEthVersionedBlobHash(),
-            this.z.toBuffer(),
-            this.y.toBuffer(),
-            this.commitment.compress(),
-            this.q.compress()
-        ]);
-        return `0x${buf.toString('hex')}`;
-    }
-    toFinalBlobAccumulator() {
-        return new FinalBlobAccumulator(this.blobCommitmentsHash, this.z, this.y, this.commitment);
-    }
-}
-/**
- * See noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr
- */ export class BatchedBlobAccumulator {
-    blobCommitmentsHashAcc;
-    zAcc;
-    yAcc;
-    cAcc;
-    qAcc;
-    gammaAcc;
-    gammaPow;
-    finalBlobChallenges;
-    constructor(/** Hash of Cs (to link to L1 blob hashes). */ blobCommitmentsHashAcc, /** Challenge point z_acc. Final value used such that p_i(z) = y_i. */ zAcc, /** Evaluation y_acc. Final value is is linear combination of all evaluations y_i = p_i(z) with gamma. */ yAcc, /** Commitment c_acc. Final value is linear combination of all commitments C_i = [p_i] with gamma. */ cAcc, /** KZG opening q_acc. Final value is linear combination of all blob kzg 'proofs' Q_i with gamma. */ qAcc, /**
-     * Challenge point gamma_acc for multi opening. Used with y, C, and kzg 'proof' Q above.
-     * TODO(#13608): We calculate this by hashing natively in the circuit (hence Fr representation), but it's actually used
-     * as a BLS12Fr field elt. Is this safe? Is there a skew?
-     */ gammaAcc, /** Simply gamma^(i + 1) at blob i. Used for calculating the i'th element of the above linear comb.s */ gammaPow, /** Final challenge values used in evaluation. Optimistically input and checked in the final acc. */ finalBlobChallenges){
-        this.blobCommitmentsHashAcc = blobCommitmentsHashAcc;
-        this.zAcc = zAcc;
-        this.yAcc = yAcc;
-        this.cAcc = cAcc;
-        this.qAcc = qAcc;
-        this.gammaAcc = gammaAcc;
-        this.gammaPow = gammaPow;
-        this.finalBlobChallenges = finalBlobChallenges;
-    }
-    /**
-   * Create the empty accumulation state of the epoch.
-   * @returns An empty blob accumulator with challenges.
-   */ static newWithChallenges(finalBlobChallenges) {
-        return new BatchedBlobAccumulator(Fr.ZERO, Fr.ZERO, BLS12Fr.ZERO, BLS12Point.ZERO, BLS12Point.ZERO, Fr.ZERO, BLS12Fr.ZERO, finalBlobChallenges);
-    }
     /**
    * Given blob i, accumulate all state.
    * We assume the input blob has not been evaluated at z.
    * @returns An updated blob accumulator.
-   */ async accumulate(blob, blobFieldsHash) {
-        const { proof, y: thisY } = blob.evaluate(this.finalBlobChallenges.z);
+   */ async accumulateBlob(blob, blobFieldsHash) {
+        const { proof, y: thisY } = await blob.evaluate(this.finalBlobChallenges.z);
         const thisC = BLS12Point.decompress(blob.commitment);
         const thisQ = BLS12Point.decompress(proof);
         const blobChallengeZ = await blob.computeChallengeZ(blobFieldsHash);
@@ -198,18 +159,19 @@ import { kzg } from './kzg_context.js';
     /**
    * Given blobs, accumulate all state.
    * We assume the input blobs have not been evaluated at z.
-   * @param blobs - The blobs to accumulate. They should be in the same L1 block.
+   * @param blobFields - The blob fields of a checkpoint to accumulate.
    * @returns An updated blob accumulator.
-   */ async accumulateBlobs(blobs) {
-        if (blobs.length > BLOBS_PER_BLOCK) {
-            throw new Error(`Too many blobs to accumulate. The maximum is ${BLOBS_PER_BLOCK} per block. Got ${blobs.length}.`);
+   */ async accumulateFields(blobFields) {
+        const blobs = await getBlobsPerL1Block(blobFields);
+        if (blobs.length > BLOBS_PER_CHECKPOINT) {
+            throw new Error(`Too many blobs to accumulate. The maximum is ${BLOBS_PER_CHECKPOINT} per checkpoint. Got ${blobs.length}.`);
         }
         // Compute the hash of all the fields in the block.
-        const blobFieldsHash = await computeBlobFieldsHashFromBlobs(blobs);
+        const blobFieldsHash = await computeBlobFieldsHash(blobFields);
         // Initialize the acc to iterate over:
         let acc = this.clone();
         for (const blob of blobs){
-            acc = await acc.accumulate(blob, blobFieldsHash);
+            acc = await acc.accumulateBlob(blob, blobFieldsHash);
         }
         return acc;
     }
@@ -240,11 +202,14 @@ import { kzg } from './kzg_context.js';
             throw new Error(`Blob batching mismatch: accumulated gamma ${calculatedGamma} does not equal injected gamma ${this.finalBlobChallenges.gamma.toBN254Fr()}`);
         }
         const batchedBlob = new BatchedBlob(this.blobCommitmentsHashAcc, this.zAcc, this.yAcc, this.cAcc, this.qAcc);
-        if (verifyProof && !batchedBlob.verify()) {
+        if (verifyProof && !this.verify()) {
             throw new Error(`KZG proof did not verify.`);
         }
         return batchedBlob;
     }
+    verify() {
+        return getKzg().verifyKzgProof(this.cAcc.compress(), this.zAcc.toBuffer(), this.yAcc.toBuffer(), this.qAcc.compress());
+    }
     isEmptyState() {
         return this.blobCommitmentsHashAcc.isZero() && this.zAcc.isZero() && this.yAcc.isZero() && this.cAcc.isZero() && this.qAcc.isZero() && this.gammaAcc.isZero() && this.gammaPow.isZero();
     }

package/dest/blob_utils.d.ts

@@ -1,5 +1,8 @@
-import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BatchedBlob } from './batched_blob.js';
 import { Blob } from './blob.js';
+import { type CheckpointBlobData } from './encoding/index.js';
 /**
  * @param blobs - The blobs to emit.
  * @returns The blobs' compressed commitments in hex prefixed by the number of blobs. 1 byte for the prefix, 48 bytes
@@ -13,18 +16,25 @@ export declare function getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${strin
  *
  * @throws If the number of fields does not match what's indicated by the checkpoint prefix.
  */
-export declare function getBlobsPerL1Block(fields: Fr[]): Blob[];
+export declare function getBlobsPerL1Block(fields: Fr[]): Promise<Blob[]>;
 /**
- * Get the fields from all blobs in the checkpoint. Ignoring the fields beyond the length specified by the
- * checkpoint prefix (the first field).
- *
- * @param blobs - The blobs to read fields from. Should be all the blobs in the L1 block proposing the checkpoint.
- * @param checkEncoding - Whether to check if the entire encoded blob fields are valid. If false, it will still check
- * the checkpoint prefix and throw if there's not enough fields.
- * @returns The fields added throughout the checkpoint.
+ * Get the encoded data from all blobs in the checkpoint.
+ * @param blobs - The blobs to read data from. Should be all the blobs for the L1 block proposing the checkpoint.
+ * @returns The encoded data of the checkpoint.
  */
-export declare function getBlobFieldsInCheckpoint(blobs: Blob[], checkEncoding?: boolean): Fr[];
-export declare function computeBlobFieldsHashFromBlobs(blobs: Blob[]): Promise<Fr>;
+export declare function decodeCheckpointBlobDataFromBlobs(blobs: Blob[]): CheckpointBlobData;
 export declare function computeBlobsHashFromBlobs(blobs: Blob[]): Fr;
 export declare function getBlobCommitmentsFromBlobs(blobs: Blob[]): BLS12Point[];
-//# sourceMappingURL=blob_utils.d.ts.map
+/**
+ * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
+ *
+ * input[:32]     - versioned_hash
+ * input[32:64]   - z
+ * input[64:96]   - y
+ * input[96:144]  - commitment C
+ * input[144:192] - commitment Q (a 'proof' committing to the quotient polynomial q(X))
+ *
+ * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+ */
+export declare function getEthBlobEvaluationInputs(batchedBlob: BatchedBlob): `0x${string}`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYl91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Jsb2JfdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzVELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ2pDLE9BQU8sRUFBRSxLQUFLLGtCQUFrQixFQUFzQyxNQUFNLHFCQUFxQixDQUFDO0FBR2xHOzs7OztHQUtHO0FBQ0gsd0JBQWdCLDZCQUE2QixDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxLQUFLLE1BQU0sRUFBRSxDQVMxRTtBQUVEOzs7OztHQUtHO0FBQ0gsd0JBQXNCLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsR0FBRyxPQUFPLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FXdEU7QUFFRDs7OztHQUlHO0FBQ0gsd0JBQWdCLGlDQUFpQyxDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxrQkFBa0IsQ0FHbkY7QUFFRCx3QkFBZ0IseUJBQXlCLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsQ0FFM0Q7QUFFRCx3QkFBZ0IsMkJBQTJCLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLFVBQVUsRUFBRSxDQUV2RTtBQUVEOzs7Ozs7Ozs7O0dBVUc7QUFDSCx3QkFBZ0IsMEJBQTBCLENBQUMsV0FBVyxFQUFFLFdBQVcsR0FBRyxLQUFLLE1BQU0sRUFBRSxDQVNsRiJ9

package/dest/blob_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blob_utils.d.ts","sourceRoot":"","sources":["../src/blob_utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE,CAS1E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,CASvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,aAAa,UAAQ,GAAG,EAAE,EAAE,CAEpF;AAED,wBAAsB,8BAA8B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC,CAQ/E;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAE3D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAEvE"}
+{"version":3,"file":"blob_utils.d.ts","sourceRoot":"","sources":["../src/blob_utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,kBAAkB,EAAsC,MAAM,qBAAqB,CAAC;AAGlG;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE,CAS1E;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAWtE;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,kBAAkB,CAGnF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,CAE3D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAEvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,WAAW,GAAG,KAAK,MAAM,EAAE,CASlF"}

package/dest/blob_utils.js

@@ -1,8 +1,8 @@
 import { FIELDS_PER_BLOB } from '@aztec/constants';
-import { BLS12Point } from '@aztec/foundation/fields';
+import { BLS12Point } from '@aztec/foundation/curves/bls12';
 import { Blob } from './blob.js';
-import { deserializeEncodedBlobToFields } from './deserialize.js';
-import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
+import { decodeCheckpointBlobDataFromBuffer } from './encoding/index.js';
+import { computeBlobsHash, computeEthVersionedBlobHash } from './hash.js';
 /**
  * @param blobs - The blobs to emit.
  * @returns The blobs' compressed commitments in hex prefixed by the number of blobs. 1 byte for the prefix, 48 bytes
@@ -24,33 +24,22 @@ import { computeBlobFieldsHash, computeBlobsHash } from './hash.js';
  * @returns As many blobs as required to broadcast the given fields to an L1 block.
  *
  * @throws If the number of fields does not match what's indicated by the checkpoint prefix.
- */ export function getBlobsPerL1Block(fields) {
+ */ export async function getBlobsPerL1Block(fields) {
     if (!fields.length) {
         throw new Error('Cannot create blobs from empty fields.');
     }
     const numBlobs = Math.ceil(fields.length / FIELDS_PER_BLOB);
-    return Array.from({
+    return await Promise.all(Array.from({
         length: numBlobs
-    }, (_, i)=>Blob.fromFields(fields.slice(i * FIELDS_PER_BLOB, (i + 1) * FIELDS_PER_BLOB)));
+    }, (_, i)=>Blob.fromFields(fields.slice(i * FIELDS_PER_BLOB, (i + 1) * FIELDS_PER_BLOB))));
 }
 /**
- * Get the fields from all blobs in the checkpoint. Ignoring the fields beyond the length specified by the
- * checkpoint prefix (the first field).
- *
- * @param blobs - The blobs to read fields from. Should be all the blobs in the L1 block proposing the checkpoint.
- * @param checkEncoding - Whether to check if the entire encoded blob fields are valid. If false, it will still check
- * the checkpoint prefix and throw if there's not enough fields.
- * @returns The fields added throughout the checkpoint.
- */ export function getBlobFieldsInCheckpoint(blobs, checkEncoding = false) {
-    return deserializeEncodedBlobToFields(Buffer.concat(blobs.map((b)=>b.data)), checkEncoding);
-}
-export async function computeBlobFieldsHashFromBlobs(blobs) {
-    const fields = blobs.map((b)=>b.toFields()).flat();
-    const numBlobFields = fields[0].toNumber();
-    if (numBlobFields > fields.length) {
-        throw new Error(`The prefix indicates ${numBlobFields} fields. Got ${fields.length}.`);
-    }
-    return await computeBlobFieldsHash(fields.slice(0, numBlobFields));
+ * Get the encoded data from all blobs in the checkpoint.
+ * @param blobs - The blobs to read data from. Should be all the blobs for the L1 block proposing the checkpoint.
+ * @returns The encoded data of the checkpoint.
+ */ export function decodeCheckpointBlobDataFromBlobs(blobs) {
+    const buf = Buffer.concat(blobs.map((b)=>b.data));
+    return decodeCheckpointBlobDataFromBuffer(buf);
 }
 export function computeBlobsHashFromBlobs(blobs) {
     return computeBlobsHash(blobs.map((b)=>b.getEthVersionedBlobHash()));
@@ -58,3 +47,23 @@ export function computeBlobsHashFromBlobs(blobs) {
 export function getBlobCommitmentsFromBlobs(blobs) {
     return blobs.map((b)=>BLS12Point.decompress(b.commitment));
 }
+/**
+ * Returns a proof of opening of the blobs to verify on L1 using the point evaluation precompile:
+ *
+ * input[:32]     - versioned_hash
+ * input[32:64]   - z
+ * input[64:96]   - y
+ * input[96:144]  - commitment C
+ * input[144:192] - commitment Q (a 'proof' committing to the quotient polynomial q(X))
+ *
+ * See https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+ */ export function getEthBlobEvaluationInputs(batchedBlob) {
+    const buf = Buffer.concat([
+        computeEthVersionedBlobHash(batchedBlob.commitment.compress()),
+        batchedBlob.z.toBuffer(),
+        batchedBlob.y.toBuffer(),
+        batchedBlob.commitment.compress(),
+        batchedBlob.q.compress()
+    ]);
+    return `0x${buf.toString('hex')}`;
+}

package/dest/circuit_types/blob_accumulator.d.ts

@@ -1,4 +1,5 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
 /**
  * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr` for documentation.
@@ -17,5 +18,6 @@ export declare class BlobAccumulator {
     toBuffer(): Buffer<ArrayBufferLike>;
     toFields(): Fr[];
     static fromFields(fields: Fr[] | FieldReader): BlobAccumulator;
+    static random(): BlobAccumulator;
 }
-//# sourceMappingURL=blob_accumulator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvYl9hY2N1bXVsYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NpcmN1aXRfdHlwZXMvYmxvYl9hY2N1bXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQVcsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQzlFLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBcUIsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRjs7R0FFRztBQUNILHFCQUFhLGVBQWU7SUFFakIsc0JBQXNCLEVBQUUsRUFBRTtJQUMxQixJQUFJLEVBQUUsRUFBRTtJQUNSLElBQUksRUFBRSxPQUFPO0lBQ2IsSUFBSSxFQUFFLFVBQVU7SUFDaEIsUUFBUSxFQUFFLEVBQUU7SUFDWixXQUFXLEVBQUUsT0FBTztJQU43QixZQUNTLHNCQUFzQixFQUFFLEVBQUUsRUFDMUIsSUFBSSxFQUFFLEVBQUUsRUFDUixJQUFJLEVBQUUsT0FBTyxFQUNiLElBQUksRUFBRSxVQUFVLEVBQ2hCLFFBQVEsRUFBRSxFQUFFLEVBQ1osV0FBVyxFQUFFLE9BQU8sRUFDekI7SUFFSixNQUFNLENBQUMsS0FBSyxJQUFJLGVBQWUsQ0FFOUI7SUFFRCxNQUFNLENBQUMsS0FBSyxFQUFFLGVBQWUsV0FTNUI7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLGVBQWUsQ0FVaEU7SUFFRCxRQUFRLDRCQVNQO0lBRUQsUUFBUSxTQVdQO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxHQUFHLGVBQWUsQ0FjN0Q7SUFFRCxNQUFNLENBQUMsTUFBTSxvQkFTWjtDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"blob_accumulator.d.ts","sourceRoot":"","sources":["../../src/circuit_types/blob_accumulator.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;;GAEG;AACH,qBAAa,eAAe;IAEjB,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,eAAe;IAI/B,MAAM,CAAC,KAAK,EAAE,eAAe;IAW7B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAYjE,QAAQ;IAWR,QAAQ;IAaR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe;CAe/D"}
+{"version":3,"file":"blob_accumulator.d.ts","sourceRoot":"","sources":["../../src/circuit_types/blob_accumulator.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F;;GAEG;AACH,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE,EAAE;IACZ,WAAW,EAAE,OAAO;IAN7B,YACS,sBAAsB,EAAE,EAAE,EAC1B,IAAI,EAAE,EAAE,EACR,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,OAAO,EACzB;IAEJ,MAAM,CAAC,KAAK,IAAI,eAAe,CAE9B;IAED,MAAM,CAAC,KAAK,EAAE,eAAe,WAS5B;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe,CAUhE;IAED,QAAQ,4BASP;IAED,QAAQ,SAWP;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe,CAc7D;IAED,MAAM,CAAC,MAAM,oBASZ;CACF"}

package/dest/circuit_types/blob_accumulator.js

@@ -1,5 +1,6 @@
 import { BLS12_FQ_LIMBS, BLS12_FR_LIMBS } from '@aztec/constants';
-import { BLS12Fq, BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fq, BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 /**
  * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/blob_accumulator.nr` for documentation.
@@ -55,4 +56,7 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
             limbs: reader.readFieldArray(BLS12_FR_LIMBS).map((f)=>f.toString())
         }));
     }
+    static random() {
+        return new BlobAccumulator(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random(), Fr.random(), BLS12Fr.random());
+    }
 }

package/dest/circuit_types/final_blob_accumulator.d.ts

@@ -1,4 +1,5 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
 /**
@@ -19,4 +20,4 @@ export declare class FinalBlobAccumulator {
     static random(): FinalBlobAccumulator;
     [inspect.custom](): string;
 }
-//# sourceMappingURL=final_blob_accumulator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluYWxfYmxvYl9hY2N1bXVsYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NpcmN1aXRfdHlwZXMvZmluYWxfYmxvYl9hY2N1bXVsYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFL0I7O0dBRUc7QUFDSCxxQkFBYSxvQkFBb0I7SUFFdEIsbUJBQW1CLEVBQUUsRUFBRTtJQUN2QixDQUFDLEVBQUUsRUFBRTtJQUNMLENBQUMsRUFBRSxPQUFPO0lBQ1YsQ0FBQyxFQUFFLFVBQVU7SUFKdEIsWUFDUyxtQkFBbUIsRUFBRSxFQUFFLEVBQ3ZCLENBQUMsRUFBRSxFQUFFLEVBQ0wsQ0FBQyxFQUFFLE9BQU8sRUFDVixDQUFDLEVBQUUsVUFBVSxFQUNsQjtJQUVKLE1BQU0sQ0FBQyxLQUFLLElBQUksb0JBQW9CLENBRW5DO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxvQkFBb0IsQ0FRckU7SUFFRCxRQUFRLDRCQUVQO0lBRUQsUUFBUSxTQU9QO0lBR0QsUUFBUSxXQU1QO0lBRUQsTUFBTSxDQUFDLEtBQUssRUFBRSxvQkFBb0IsV0FPakM7SUFHRCxNQUFNLENBQUMsTUFBTSx5QkFFWjtJQUVELENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQU9mO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"final_blob_accumulator.d.ts","sourceRoot":"","sources":["../../src/circuit_types/final_blob_accumulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B;;GAEG;AACH,qBAAa,oBAAoB;IAEtB,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,oBAAoB;IAIpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,oBAAoB;IAUtE,QAAQ;IAIR,QAAQ;IAUR,QAAQ;IAQR,MAAM,CAAC,KAAK,EAAE,oBAAoB;IAUlC,MAAM,CAAC,MAAM;IAIb,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}
+{"version":3,"file":"final_blob_accumulator.d.ts","sourceRoot":"","sources":["../../src/circuit_types/final_blob_accumulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B;;GAEG;AACH,qBAAa,oBAAoB;IAEtB,mBAAmB,EAAE,EAAE;IACvB,CAAC,EAAE,EAAE;IACL,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,UAAU;IAJtB,YACS,mBAAmB,EAAE,EAAE,EACvB,CAAC,EAAE,EAAE,EACL,CAAC,EAAE,OAAO,EACV,CAAC,EAAE,UAAU,EAClB;IAEJ,MAAM,CAAC,KAAK,IAAI,oBAAoB,CAEnC;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,oBAAoB,CAQrE;IAED,QAAQ,4BAEP;IAED,QAAQ,SAOP;IAGD,QAAQ,WAMP;IAED,MAAM,CAAC,KAAK,EAAE,oBAAoB,WAOjC;IAGD,MAAM,CAAC,MAAM,yBAEZ;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,WAOf;CACF"}

package/dest/circuit_types/final_blob_accumulator.js

@@ -1,6 +1,9 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
+var _computedKey;
+import { BLS12Fr, BLS12Point } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { inspect } from 'util';
+_computedKey = inspect.custom;
 /**
  * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_accumulator.nr` for documentation.
  */ export class FinalBlobAccumulator {
@@ -52,7 +55,7 @@ import { inspect } from 'util';
     static random() {
         return new FinalBlobAccumulator(Fr.random(), Fr.random(), BLS12Fr.random(), BLS12Point.random());
     }
-    [inspect.custom]() {
+    [_computedKey]() {
         return `FinalBlobAccumulator {
       blobCommitmentsHash: ${inspect(this.blobCommitmentsHash)},
       z: ${inspect(this.z)},

package/dest/circuit_types/final_blob_batching_challenges.d.ts

@@ -1,4 +1,5 @@
-import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader } from '@aztec/foundation/serialize';
 /**
  * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_batching_challenges.nr` for documentation.
@@ -12,4 +13,4 @@ export declare class FinalBlobBatchingChallenges {
     static fromBuffer(buffer: Buffer | BufferReader): FinalBlobBatchingChallenges;
     toBuffer(): Buffer<ArrayBufferLike>;
 }
-//# sourceMappingURL=final_blob_batching_challenges.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluYWxfYmxvYl9iYXRjaGluZ19jaGFsbGVuZ2VzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2lyY3VpdF90eXBlcy9maW5hbF9ibG9iX2JhdGNoaW5nX2NoYWxsZW5nZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3pELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFxQixNQUFNLDZCQUE2QixDQUFDO0FBRTlFOztHQUVHO0FBQ0gscUJBQWEsMkJBQTJCO2FBRXBCLENBQUMsRUFBRSxFQUFFO2FBQ0wsS0FBSyxFQUFFLE9BQU87SUFGaEMsWUFDa0IsQ0FBQyxFQUFFLEVBQUUsRUFDTCxLQUFLLEVBQUUsT0FBTyxFQUM1QjtJQUVKLE1BQU0sQ0FBQyxLQUFLLEVBQUUsMkJBQTJCLFdBRXhDO0lBRUQsTUFBTSxDQUFDLEtBQUssSUFBSSwyQkFBMkIsQ0FFMUM7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLDJCQUEyQixDQUc1RTtJQUVELFFBQVEsNEJBRVA7Q0FDRiJ9

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

@@ -1 +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"}
+{"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,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E;;GAEG;AACH,qBAAa,2BAA2B;aAEpB,CAAC,EAAE,EAAE;aACL,KAAK,EAAE,OAAO;IAFhC,YACkB,CAAC,EAAE,EAAE,EACL,KAAK,EAAE,OAAO,EAC5B;IAEJ,MAAM,CAAC,KAAK,EAAE,2BAA2B,WAExC;IAED,MAAM,CAAC,KAAK,IAAI,2BAA2B,CAE1C;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,2BAA2B,CAG5E;IAED,QAAQ,4BAEP;CACF"}

package/dest/circuit_types/final_blob_batching_challenges.js

@@ -1,4 +1,5 @@
-import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+import { BLS12Fr } from '@aztec/foundation/curves/bls12';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 /**
  * See `noir-projects/noir-protocol-circuits/crates/blob/src/abis/final_blob_batching_challenges.nr` for documentation.

package/dest/circuit_types/index.d.ts

@@ -1,4 +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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jaXJjdWl0X3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHFDQUFxQyxDQUFDIn0=

package/dest/encoding/block_blob_data.d.ts

@@ -0,0 +1,30 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+import { type BlockEndMarker } from './block_end_marker.js';
+import { type BlockEndStateField } from './block_end_state_field.js';
+import { type TxBlobData } from './tx_blob_data.js';
+export declare const NUM_BLOCK_END_BLOB_FIELDS = 6;
+export declare const NUM_FIRST_BLOCK_END_BLOB_FIELDS = 7;
+export declare const NUM_CHECKPOINT_END_MARKER_FIELDS = 1;
+/**
+ * Returns the number of blob fields used for block end data.
+ * @param isFirstBlockInCheckpoint - Whether this is the first block in a checkpoint.
+ */
+export declare function getNumBlockEndBlobFields(isFirstBlockInCheckpoint: boolean): number;
+export interface BlockEndBlobData {
+    blockEndMarker: BlockEndMarker;
+    blockEndStateField: BlockEndStateField;
+    lastArchiveRoot: Fr;
+    noteHashRoot: Fr;
+    nullifierRoot: Fr;
+    publicDataRoot: Fr;
+    l1ToL2MessageRoot: Fr | undefined;
+}
+export interface BlockBlobData extends BlockEndBlobData {
+    txs: TxBlobData[];
+}
+export declare function encodeBlockEndBlobData(blockEndBlobData: BlockEndBlobData): Fr[];
+export declare function decodeBlockEndBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockEndBlobData;
+export declare function encodeBlockBlobData(blockBlobData: BlockBlobData): Fr[];
+export declare function decodeBlockBlobData(fields: Fr[] | FieldReader, isFirstBlock: boolean): BlockBlobData;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxvY2tfYmxvYl9kYXRhLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW5jb2RpbmcvYmxvY2tfYmxvYl9kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFHMUQsT0FBTyxFQUNMLEtBQUssY0FBYyxFQUlwQixNQUFNLHVCQUF1QixDQUFDO0FBQy9CLE9BQU8sRUFDTCxLQUFLLGtCQUFrQixFQUd4QixNQUFNLDRCQUE0QixDQUFDO0FBQ3BDLE9BQU8sRUFBRSxLQUFLLFVBQVUsRUFBc0MsTUFBTSxtQkFBbUIsQ0FBQztBQUl4RixlQUFPLE1BQU0seUJBQXlCLElBQUksQ0FBQztBQUMzQyxlQUFPLE1BQU0sK0JBQStCLElBQUksQ0FBQztBQUNqRCxlQUFPLE1BQU0sZ0NBQWdDLElBQUksQ0FBQztBQUVsRDs7O0dBR0c7QUFDSCx3QkFBZ0Isd0JBQXdCLENBQUMsd0JBQXdCLEVBQUUsT0FBTyxHQUFHLE1BQU0sQ0FFbEY7QUFFRCxNQUFNLFdBQVcsZ0JBQWdCO0lBQy9CLGNBQWMsRUFBRSxjQUFjLENBQUM7SUFDL0Isa0JBQWtCLEVBQUUsa0JBQWtCLENBQUM7SUFDdkMsZUFBZSxFQUFFLEVBQUUsQ0FBQztJQUNwQixZQUFZLEVBQUUsRUFBRSxDQUFDO0lBQ2pCLGFBQWEsRUFBRSxFQUFFLENBQUM7SUFDbEIsY0FBYyxFQUFFLEVBQUUsQ0FBQztJQUNuQixpQkFBaUIsRUFBRSxFQUFFLEdBQUcsU0FBUyxDQUFDO0NBQ25DO0FBRUQsTUFBTSxXQUFXLGFBQWMsU0FBUSxnQkFBZ0I7SUFDckQsR0FBRyxFQUFFLFVBQVUsRUFBRSxDQUFDO0NBQ25CO0FBRUQsd0JBQWdCLHNCQUFzQixDQUFDLGdCQUFnQixFQUFFLGdCQUFnQixHQUFHLEVBQUUsRUFBRSxDQVUvRTtBQUVELHdCQUFnQixzQkFBc0IsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxFQUFFLFlBQVksRUFBRSxPQUFPLEdBQUcsZ0JBQWdCLENBbUIxRztBQUVELHdCQUFnQixtQkFBbUIsQ0FBQyxhQUFhLEVBQUUsYUFBYSxHQUFHLEVBQUUsRUFBRSxDQUV0RTtBQUVELHdCQUFnQixtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsRUFBRSxFQUFFLEdBQUcsV0FBVyxFQUFFLFlBQVksRUFBRSxPQUFPLEdBQUcsYUFBYSxDQStCcEcifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"block_blob_data.d.ts","sourceRoot":"","sources":["../../src/encoding/block_blob_data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG1D,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,KAAK,UAAU,EAAsC,MAAM,mBAAmB,CAAC;AAIxF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,eAAO,MAAM,+BAA+B,IAAI,CAAC;AACjD,eAAO,MAAM,gCAAgC,IAAI,CAAC;AAElD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,wBAAwB,EAAE,OAAO,GAAG,MAAM,CAElF;AAED,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,eAAe,EAAE,EAAE,CAAC;IACpB,YAAY,EAAE,EAAE,CAAC;IACjB,aAAa,EAAE,EAAE,CAAC;IAClB,cAAc,EAAE,EAAE,CAAC;IACnB,iBAAiB,EAAE,EAAE,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,GAAG,EAAE,UAAU,EAAE,CAAC;CACnB;AAED,wBAAgB,sBAAsB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,EAAE,EAAE,CAU/E;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,YAAY,EAAE,OAAO,GAAG,gBAAgB,CAmB1G;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,GAAG,EAAE,EAAE,CAEtE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,YAAY,EAAE,OAAO,GAAG,aAAa,CA+BpG"}

package/dest/encoding/block_blob_data.js

@@ -0,0 +1,75 @@
+import { FieldReader } from '@aztec/foundation/serialize';
+import { BlobDeserializationError } from '../errors.js';
+import { decodeBlockEndMarker, encodeBlockEndMarker, isBlockEndMarker } from './block_end_marker.js';
+import { decodeBlockEndStateField, encodeBlockEndStateField } from './block_end_state_field.js';
+import { decodeTxBlobData, encodeTxBlobData } from './tx_blob_data.js';
+// Must match the implementation in `noir-protocol-circuits/crates/types/src/blob_data/block_blob_data.nr`.
+export const NUM_BLOCK_END_BLOB_FIELDS = 6;
+export const NUM_FIRST_BLOCK_END_BLOB_FIELDS = 7;
+export const NUM_CHECKPOINT_END_MARKER_FIELDS = 1;
+/**
+ * Returns the number of blob fields used for block end data.
+ * @param isFirstBlockInCheckpoint - Whether this is the first block in a checkpoint.
+ */ export function getNumBlockEndBlobFields(isFirstBlockInCheckpoint) {
+    return isFirstBlockInCheckpoint ? NUM_FIRST_BLOCK_END_BLOB_FIELDS : NUM_BLOCK_END_BLOB_FIELDS;
+}
+export function encodeBlockEndBlobData(blockEndBlobData) {
+    return [
+        encodeBlockEndMarker(blockEndBlobData.blockEndMarker),
+        encodeBlockEndStateField(blockEndBlobData.blockEndStateField),
+        blockEndBlobData.lastArchiveRoot,
+        blockEndBlobData.noteHashRoot,
+        blockEndBlobData.nullifierRoot,
+        blockEndBlobData.publicDataRoot,
+        ...blockEndBlobData.l1ToL2MessageRoot ? [
+            blockEndBlobData.l1ToL2MessageRoot
+        ] : []
+    ];
+}
+export function decodeBlockEndBlobData(fields, isFirstBlock) {
+    const reader = FieldReader.asReader(fields);
+    const numBlockEndData = getNumBlockEndBlobFields(isFirstBlock);
+    if (numBlockEndData > reader.remainingFields()) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for block end data. Expected ${numBlockEndData} fields, only ${reader.remainingFields()} remaining.`);
+    }
+    return {
+        blockEndMarker: decodeBlockEndMarker(reader.readField()),
+        blockEndStateField: decodeBlockEndStateField(reader.readField()),
+        lastArchiveRoot: reader.readField(),
+        noteHashRoot: reader.readField(),
+        nullifierRoot: reader.readField(),
+        publicDataRoot: reader.readField(),
+        l1ToL2MessageRoot: isFirstBlock ? reader.readField() : undefined
+    };
+}
+export function encodeBlockBlobData(blockBlobData) {
+    return [
+        ...blockBlobData.txs.map((tx)=>encodeTxBlobData(tx)).flat(),
+        ...encodeBlockEndBlobData(blockBlobData)
+    ];
+}
+export function decodeBlockBlobData(fields, isFirstBlock) {
+    const reader = FieldReader.asReader(fields);
+    const txs = [];
+    let hasReachedBlockEnd = false;
+    while(!hasReachedBlockEnd){
+        if (reader.isFinished()) {
+            throw new BlobDeserializationError(`Incorrect encoding of blob fields: not enough fields for block end marker.`);
+        }
+        const currentField = reader.peekField();
+        if (isBlockEndMarker(currentField)) {
+            hasReachedBlockEnd = true;
+        } else {
+            txs.push(decodeTxBlobData(reader));
+        }
+    }
+    const blockEndBlobData = decodeBlockEndBlobData(reader, isFirstBlock);
+    const blockEndMarker = blockEndBlobData.blockEndMarker;
+    if (blockEndMarker.numTxs !== txs.length) {
+        throw new BlobDeserializationError(`Incorrect encoding of blob fields: expected ${blockEndMarker.numTxs} txs, but got ${txs.length}.`);
+    }
+    return {
+        txs,
+        ...blockEndBlobData
+    };
+}