@aztec/blob-lib 3.0.0-nightly.20251026 → 3.0.0-nightly.20251031

package/dest/testing.js

@@ -1,8 +1,12 @@
+import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+import { randomInt } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
-import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-import { encodeTxStartMarker } from './encoding.js';
+import { BatchedBlobAccumulator } from './blob_batching.js';
+import { getBlobsPerL1Block } from './blob_utils.js';
+import { FinalBlobBatchingChallenges } from './circuit_types/index.js';
+import { createBlockEndMarker, encodeTxStartMarker } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
@@ -20,17 +24,12 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
  */ export function makeBatchedBlobAccumulator(seed = 1) {
     return new BatchedBlobAccumulator(new Fr(seed), new Fr(seed + 1), new BLS12Fr(seed + 2), BLS12Point.random(), BLS12Point.random(), new Fr(seed + 3), new BLS12Fr(seed + 4), new FinalBlobBatchingChallenges(new Fr(seed + 5), new BLS12Fr(seed + 6)));
 }
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */ export function makeEncodedBlob(length) {
+export function makeEncodedTxBlobFields(length) {
     const txStartMarker = {
         numBlobFields: length,
-        // The rest of the values don't matter. The test components using it only look at `numBlobFields` to split the blobs
-        // into fields for tx effects.
+        // The rest of the values don't matter. The test components using it do not try to deserialize everything.
+        // Only `checkBlobFieldsEncoding` is used and it only looks at `numBlobFields`. This might change in the future
+        // when we add more thorough checks to `checkBlobFieldsEncoding`.
         revertCode: 0,
         numNoteHashes: 0,
         numNullifiers: 0,
@@ -40,12 +39,46 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
         publicLogsLength: 0,
         contractClassLogLength: 0
     };
-    return Blob.fromFields([
+    return [
         encodeTxStartMarker(txStartMarker),
         ...Array.from({
             length: length - 1
-        }, ()=>Fr.random())
-    ]);
+        }, ()=>new Fr(randomInt(Number.MAX_SAFE_INTEGER)))
+    ];
+}
+export function makeEncodedBlockBlobFields(...lengths) {
+    return [
+        ...lengths.length > 0 ? makeEncodedTxBlobFields(lengths[0] - 1) : [],
+        ...lengths.slice(1).flatMap((length)=>makeEncodedTxBlobFields(length)),
+        createBlockEndMarker(lengths.length)
+    ];
+}
+// Create blob fields for a checkpoint with a single block.
+export function makeEncodedBlobFields(length) {
+    if (length <= 2) {
+        throw new Error('Encoded blob fields length must be greater than 2');
+    }
+    const checkpointPrefix = new Fr(length);
+    return [
+        checkpointPrefix,
+        ...makeEncodedBlockBlobFields(length - 1)
+    ]; // -1 to account for the checkpoint prefix.
+}
+/**
+ * Make an encoded blob with the given length
+ *
+ * This will deserialise correctly in the archiver
+ * @param length
+ * @returns
+ */ export function makeEncodedBlob(length) {
+    if (length > FIELDS_PER_BLOB) {
+        throw new Error(`A single encoded blob must be less than ${FIELDS_PER_BLOB} fields`);
+    }
+    return Blob.fromFields(makeEncodedBlobFields(length));
+}
+export function makeEncodedBlobs(length) {
+    const fields = makeEncodedBlobFields(length);
+    return getBlobsPerL1Block(fields);
 }
 /**
  * Make a blob with random fields.

package/dest/types.d.ts

@@ -1,3 +1,5 @@
+export * from './circuit_types/index.js';
+export * from './interface.js';
 export * from './sponge_blob.js';
 /**
  * Type definition for the KZG instance returned by Blob.getViemKzgInstance().

package/dest/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AAIjC;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAClD,kDAAkD;IAClD,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1E,8FAA8F;IAC9F,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;CAC1E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AAEjC;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAClD,kDAAkD;IAClD,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1E,8FAA8F;IAC9F,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,CAAC,UAAU,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;CAC1E"}

package/dest/types.js

@@ -1 +1,3 @@
+export * from './circuit_types/index.js';
+export * from './interface.js';
 export * from './sponge_blob.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/blob-lib",
-  "version": "3.0.0-nightly.20251026",
+  "version": "3.0.0-nightly.20251031",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -27,9 +27,9 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/constants": "3.0.0-nightly.20251026",
-    "@aztec/foundation": "3.0.0-nightly.20251026",
-    "@crate-crypto/node-eth-kzg": "^0.9.1",
+    "@aztec/constants": "3.0.0-nightly.20251031",
+    "@aztec/foundation": "3.0.0-nightly.20251031",
+    "@crate-crypto/node-eth-kzg": "^0.10.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {

package/src/blob.ts

@@ -1,75 +1,80 @@
 import { FIELDS_PER_BLOB } from '@aztec/constants';
-import { poseidon2Hash, sha256 } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { BLS12Fr, Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { deserializeEncodedBlobToFields, extractBlobFieldsFromBuffer } from './deserialize.js';
-import { BlobDeserializationError } from './errors.js';
+import { computeBlobCommitment, computeChallengeZ, computeEthVersionedBlobHash } from './hash.js';
 import type { BlobJson } from './interface.js';
-import { BYTES_PER_BLOB, kzg } from './kzg_context.js';
+import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, kzg } from './kzg_context.js';
 
-// The prefix to the EVM blobHash, defined here: https://eips.ethereum.org/EIPS/eip-4844#specification
-export const VERSIONED_HASH_VERSION_KZG = 0x01;
+export { FIELDS_PER_BLOB };
 
 /**
  * A class to create, manage, and prove EVM blobs.
+ *
+ * @dev Note: All methods in this class do not check the encoding of the given data. It's the responsibility of other
+ * components to ensure that the blob data (which might spread across multiple blobs) was created following the protocol
+ * and is correctly encoded.
  */
 export class Blob {
   constructor(
-    /** The blob to be broadcast on L1 in bytes form. */
+    /**
+     * The data to be broadcast on L1 in bytes form.
+     */
     public readonly data: Uint8Array,
-    /** The hash of all tx effects inside the blob. Used in generating the challenge z and proving that we have included all required effects. */
-    public readonly fieldsHash: Fr,
-    /** Challenge point z (= H(H(tx_effects), kzgCommmitment). Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts). */
-    public readonly challengeZ: Fr,
-    /** Commitment to the blob C. Used in compressed BLS12 point format (48 bytes). */
+    /**
+     * Commitment to the blob data. Used in compressed BLS12 point format (48 bytes).
+     */
     public readonly commitment: Buffer,
-  ) {}
+  ) {
+    if (data.length !== BYTES_PER_BLOB) {
+      throw new Error(`Blob data must be ${BYTES_PER_BLOB} bytes. Got ${data.length}.`);
+    }
+    if (commitment.length !== BYTES_PER_COMMITMENT) {
+      throw new Error(`Blob commitment must be ${BYTES_PER_COMMITMENT} bytes. Got ${commitment.length}.`);
+    }
+  }
 
   /**
-   * The encoded version of the blob will determine the end of the blob based on the transaction encoding.
-   * This is required when the fieldsHash of a blob will contain trailing zeros.
-   *
-   * See `./encoding.ts` for more details.
-   *
-   * This method is used to create a Blob from a buffer.
-   * @param blob - The buffer to create the Blob from.
-   * @param multiBlobFieldsHash - The fields hash to use for the Blob.
+   * Create a Blob from a buffer.
+   * @param data - The buffer of the Blob.
    * @returns A Blob created from the buffer.
    *
-   * @throws If unable to deserialize the blob.
+   * @throws If data does not match the expected length (BYTES_PER_BLOB).
    */
-  static fromEncodedBlobBuffer(blob: Uint8Array, multiBlobFieldsHash?: Fr): Promise<Blob> {
-    try {
-      const fields: Fr[] = deserializeEncodedBlobToFields(blob);
-      return Blob.fromFields(fields, multiBlobFieldsHash);
-    } catch {
-      throw new BlobDeserializationError(
-        `Failed to create Blob from encoded blob buffer, this blob was likely not created by us`,
-      );
-    }
+  static fromBlobBuffer(data: Uint8Array): Blob {
+    const commitment = computeBlobCommitment(data);
+    return new Blob(data, commitment);
   }
 
   /**
    * Create a Blob from an array of fields.
    *
+   * @dev This method pads 0s to the data, extending it to the size of a full blob.
+   *
    * @param fields - The array of fields to create the Blob from.
-   * @param multiBlobFieldsHash - The fields hash to use for the Blob.
    * @returns A Blob created from the array of fields.
    */
-  static async fromFields(fields: Fr[], multiBlobFieldsHash?: Fr): Promise<Blob> {
+  static fromFields(fields: Fr[]): Blob {
     if (fields.length > FIELDS_PER_BLOB) {
-      throw new Error(`Attempted to overfill blob with ${fields.length} elements. The maximum is ${FIELDS_PER_BLOB}`);
+      throw new Error(`Attempted to overfill blob with ${fields.length} fields. The maximum is ${FIELDS_PER_BLOB}.`);
     }
 
     const data = Buffer.concat([serializeToBuffer(fields)], BYTES_PER_BLOB);
+    const commitment = computeBlobCommitment(data);
+    return new Blob(data, commitment);
+  }
 
-    // This matches the output of SpongeBlob.squeeze() in the blob circuit
-    const fieldsHash = multiBlobFieldsHash ? multiBlobFieldsHash : await poseidon2Hash(fields);
-    const commitment = Buffer.from(kzg.blobToKzgCommitment(data));
-    const challengeZ = await poseidon2Hash([fieldsHash, ...commitmentToFields(commitment)]);
-
-    return new Blob(data, fieldsHash, challengeZ, commitment);
+  /**
+   * Get the fields from the blob data.
+   *
+   * @dev WARNING: this method returns all fields
+   *
+   * @returns The fields from the blob.
+   */
+  toFields(): Fr[] {
+    const reader = BufferReader.asReader(this.data);
+    const numTotalFields = this.data.length / Fr.SIZE_IN_BYTES;
+    return reader.readArray(numTotalFields, Fr);
   }
 
   /**
@@ -79,30 +84,23 @@ export class Blob {
    * the beacon chain via `getBlobSidecars`
    * https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getBlobSidecars
    *
-   * @dev WARNING: by default json deals with encoded buffers
-   *
    * @param json - The JSON object to create the Blob from.
    * @returns A Blob created from the JSON object.
    */
-  static async fromJson(json: BlobJson): Promise<Blob> {
+  static fromJson(json: BlobJson): Blob {
     const blobBuffer = Buffer.from(json.blob.slice(2), 'hex');
-
-    const blob = await Blob.fromEncodedBlobBuffer(blobBuffer);
+    const blob = Blob.fromBlobBuffer(blobBuffer);
 
     if (blob.commitment.toString('hex') !== json.kzg_commitment.slice(2)) {
       throw new Error('KZG commitment does not match');
     }
 
-    // We do not check the proof, as it will be different if the challenge is shared
-    // across multiple blobs
-
     return blob;
   }
 
   /**
    * Get the JSON representation of the blob.
    *
-   * @dev WARNING: by default json deals with encoded buffers
    * @param index - optional - The index of the blob in the block.
    * @returns The JSON representation of the blob.
    */
@@ -115,133 +113,61 @@ export class Blob {
     };
   }
 
-  /**
-   * Get the fields from the blob.
-   *
-   * @dev WARNING: this method does not take into account trailing zeros
-   *
-   * @returns The fields from the blob.
-   */
-  toFields(): Fr[] {
-    return extractBlobFieldsFromBuffer(this.data);
-  }
-
-  /**
-   * Get the encoded fields from the blob.
-   *
-   * @dev This method takes into account trailing zeros
-   *
-   * @returns The encoded fields from the blob.
-   *
-   * @throws If unable to deserialize the blob.
-   */
-  toEncodedFields(): Fr[] {
-    try {
-      return deserializeEncodedBlobToFields(this.data);
-    } catch {
-      throw new BlobDeserializationError(
-        `Failed to deserialize encoded blob fields, this blob was likely not created by us`,
-      );
-    }
+  getEthVersionedBlobHash(): Buffer {
+    return computeEthVersionedBlobHash(this.commitment);
   }
 
   /**
-   * Get the encoded fields from multiple blobs.
-   *
-   * @dev This method takes into account trailing zeros
-   *
-   * @returns The encoded fields from the blobs.
+   * Challenge point z (= H(H(tx_effects), kzgCommitment)).
+   * Used such that p(z) = y for a single blob, used as z_i in batching (see ./blob_batching.ts).
    */
-  static toEncodedFields(blobs: Blob[]): Fr[] {
-    try {
-      return deserializeEncodedBlobToFields(Buffer.concat(blobs.map(b => b.data)));
-    } catch {
-      throw new BlobDeserializationError(
-        `Failed to deserialize encoded blob fields, this blob was likely not created by us`,
-      );
-    }
-  }
-
-  /**
-   * Get the commitment fields from the blob.
-   *
-   * The 48-byte commitment is encoded into two field elements:
-   * +------------------+------------------+
-   * | Field Element 1  | Field Element 2  |
-   * | [bytes 0-31]     | [bytes 32-47]   |
-   * +------------------+------------------+
-   * |     32 bytes     |     16 bytes    |
-   * +------------------+------------------+
-   * @returns The commitment fields from the blob.
-   */
-  commitmentToFields(): [Fr, Fr] {
-    return commitmentToFields(this.commitment);
-  }
-
-  // Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
-  getEthVersionedBlobHash(): Buffer {
-    const hash = sha256(this.commitment);
-    hash[0] = VERSIONED_HASH_VERSION_KZG;
-    return hash;
-  }
-
-  static getEthVersionedBlobHash(commitment: Buffer): Buffer {
-    const hash = sha256(commitment);
-    hash[0] = VERSIONED_HASH_VERSION_KZG;
-    return hash;
+  async computeChallengeZ(blobFieldsHash: Fr): Promise<Fr> {
+    return await computeChallengeZ(blobFieldsHash, this.commitment);
   }
 
   /**
    * Evaluate the blob at a given challenge and return the evaluation and KZG proof.
    *
-   * @param challengeZ - The challenge z at which to evaluate the blob. If not given, assume we want to evaluate at the individual blob's z.
+   * @param challengeZ - The challenge z at which to evaluate the blob.
+   * @param verifyProof - Whether to verify the KZG proof.
    *
-   * @returns -
-   *  y: Buffer -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts
+   * @returns
+   *  y: BLS12Fr -  Evaluation y = p(z), where p() is the blob polynomial. BLS12 field element, rep. as BigNum in nr, bigint in ts.
    *  proof: Buffer - KZG opening proof for y = p(z). The commitment to quotient polynomial Q, used in compressed BLS12 point format (48 bytes).
    */
-  evaluate(challengeZ?: Fr) {
-    const z = challengeZ || this.challengeZ;
-    const res = kzg.computeKzgProof(this.data, z.toBuffer());
-    if (!kzg.verifyKzgProof(this.commitment, z.toBuffer(), res[1], res[0])) {
+  evaluate(challengeZ: Fr, verifyProof = false) {
+    const res = kzg.computeKzgProof(this.data, challengeZ.toBuffer());
+    if (verifyProof && !kzg.verifyKzgProof(this.commitment, challengeZ.toBuffer(), res[1], res[0])) {
       throw new Error(`KZG proof did not verify.`);
     }
+
     const proof = Buffer.from(res[0]);
-    const y = Buffer.from(res[1]);
+    const y = BLS12Fr.fromBuffer(Buffer.from(res[1]));
     return { y, proof };
   }
 
   /**
    * Get the buffer representation of the ENTIRE blob.
    *
-   * @dev WARNING: this buffer contains all metadata aswell as the data itself
+   * @dev WARNING: this buffer contains all metadata as well as the data itself.
    *
    * @returns The buffer representation of the blob.
    */
   toBuffer(): Buffer {
-    return Buffer.from(
-      serializeToBuffer(
-        this.data.length,
-        this.data,
-        this.fieldsHash,
-        this.challengeZ,
-        this.commitment.length,
-        this.commitment,
-      ),
-    );
+    return Buffer.from(serializeToBuffer(this.data.length, this.data, this.commitment.length, this.commitment));
   }
 
   /**
    * Create a Blob from a buffer.
    *
-   * @dev WARNING: this method contains all metadata aswell as the data itself
+   * @dev WARNING: this method contains all metadata as well as the data itself.
    *
    * @param buf - The buffer to create the Blob from.
    * @returns A Blob created from the buffer.
    */
   static fromBuffer(buf: Buffer | BufferReader): Blob {
     const reader = BufferReader.asReader(buf);
-    return new Blob(reader.readUint8Array(), reader.readObject(Fr), reader.readObject(Fr), reader.readBuffer());
+    return new Blob(reader.readUint8Array(), reader.readBuffer());
   }
 
   /**
@@ -251,24 +177,6 @@ export class Blob {
     return this.data.length;
   }
 
-  /**
-   * @param blobs - The blobs to emit
-   * @returns The blobs' compressed commitments in hex prefixed by the number of blobs
-   * @dev Used for proposing blocks to validate injected blob commitments match real broadcast blobs:
-   * One byte for the number blobs + 48 bytes per blob commitment
-   */
-  static getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}` {
-    let buf = Buffer.alloc(0);
-    blobs.forEach(blob => {
-      buf = Buffer.concat([buf, blob.commitment]);
-    });
-    // We prefix the number of blobs:
-    const lenBuf = Buffer.alloc(1);
-    lenBuf.writeUint8(blobs.length);
-    buf = Buffer.concat([lenBuf, buf]);
-    return `0x${buf.toString('hex')}`;
-  }
-
   static getViemKzgInstance() {
     return {
       blobToKzgCommitment: kzg.blobToKzgCommitment.bind(kzg),
@@ -279,25 +187,4 @@ export class Blob {
       },
     };
   }
-
-  /**
-   * @param fields - Fields to broadcast in the blob(s)
-   * @returns As many blobs as we require to broadcast the given fields for a block
-   * @dev Assumes we share the fields hash between all blobs which can only be done for ONE BLOCK because the hash is calculated in block root.
-   */
-  static async getBlobsPerBlock(fields: Fr[]): Promise<Blob[]> {
-    const numBlobs = Math.max(Math.ceil(fields.length / FIELDS_PER_BLOB), 1);
-    const multiBlobFieldsHash = await poseidon2Hash(fields);
-    const res = [];
-    for (let i = 0; i < numBlobs; i++) {
-      const end = fields.length < (i + 1) * FIELDS_PER_BLOB ? fields.length : (i + 1) * FIELDS_PER_BLOB;
-      res.push(await Blob.fromFields(fields.slice(i * FIELDS_PER_BLOB, end), multiBlobFieldsHash));
-    }
-    return res;
-  }
-}
-
-// 48 bytes encoded in fields as [Fr, Fr] = [0->31, 31->48]
-function commitmentToFields(commitment: Buffer): [Fr, Fr] {
-  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, 48))];
 }