@aztec/blob-lib 1.0.0-nightly.20250608 → 1.0.0-nightly.20250610

package/dest/blob_batching_public_inputs.js

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

package/dest/index.d.ts

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

package/dest/index.d.ts.map

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

package/dest/index.js

@@ -1,10 +1,11 @@
 import cKzg from 'c-kzg';
 const { loadTrustedSetup } = cKzg;
 export * from './blob.js';
+export * from './blob_batching.js';
 export * from './encoding.js';
 export * from './interface.js';
 export * from './errors.js';
-export * from './blob_public_inputs.js';
+export * from './blob_batching_public_inputs.js';
 export * from './sponge_blob.js';
 try {
     loadTrustedSetup();

package/dest/testing.d.ts

@@ -1,6 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
-import { BlobPublicInputs, BlockBlobPublicInputs } from './blob_public_inputs.js';
+import { BatchedBlobAccumulator } from './blob_batching.js';
+import { BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
 import { SpongeBlob } from './sponge_blob.js';
 /**
  * Makes arbitrary poseidon sponge for blob inputs.
@@ -10,12 +11,12 @@ import { SpongeBlob } from './sponge_blob.js';
  */
 export declare function makeSpongeBlob(seed?: number): SpongeBlob;
 /**
- * Makes arbitrary blob public inputs.
+ * Makes arbitrary blob public accumulator.
  * Note: will not verify inside the circuit.
- * @param seed - The seed to use for generating the blob inputs.
- * @returns A blob public inputs instance.
+ * @param seed - The seed to use for generating the blob accumulator.
+ * @returns A blob accumulator instance.
  */
-export declare function makeBlobPublicInputs(seed?: number): BlobPublicInputs;
+export declare function makeBatchedBlobAccumulator(seed?: number): BatchedBlobAccumulator;
 /**
  * Makes arbitrary block blob public inputs.
  * Note: will not verify inside the circuit.

package/dest/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAElF,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,SAAI,GAAG,gBAAgB,CAM/D;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,SAAI,GAAG,qBAAqB,CAEzE;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAA+B,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAEzE,OAAO,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAI,GAAG,UAAU,CAWnD;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAW3E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,SAAI,GAAG,qBAAqB,CAOzE;AAmBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjE"}

package/dest/testing.js

@@ -1,9 +1,9 @@
-import { BLOBS_PER_BLOCK } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
-import { Fr } from '@aztec/foundation/fields';
+import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 import { Blob } from './blob.js';
-import { BlobPublicInputs, BlockBlobPublicInputs } from './blob_public_inputs.js';
+import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
+import { BlockBlobPublicInputs } from './blob_batching_public_inputs.js';
 import { TX_START_PREFIX, TX_START_PREFIX_BYTES_LENGTH } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 /**
@@ -15,12 +15,12 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
     return new SpongeBlob(new Poseidon2Sponge(makeTuple(3, (i)=>new Fr(i)), makeTuple(4, (i)=>new Fr(i)), 1, false), seed, seed + 1);
 }
 /**
- * Makes arbitrary blob public inputs.
+ * Makes arbitrary blob public accumulator.
  * Note: will not verify inside the circuit.
- * @param seed - The seed to use for generating the blob inputs.
- * @returns A blob public inputs instance.
- */ export function makeBlobPublicInputs(seed = 1) {
-    return new BlobPublicInputs(new Fr(seed), BigInt(seed + 1), makeTuple(2, (i)=>new Fr(i)));
+ * @param seed - The seed to use for generating the blob accumulator.
+ * @returns A blob accumulator instance.
+ */ 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)));
 }
 /**
  * Makes arbitrary block blob public inputs.
@@ -28,7 +28,8 @@ import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
  * @param seed - The seed to use for generating the blob inputs.
  * @returns A block blob public inputs instance.
  */ export function makeBlockBlobPublicInputs(seed = 1) {
-    return new BlockBlobPublicInputs(makeTuple(BLOBS_PER_BLOCK, ()=>makeBlobPublicInputs(seed)));
+    const startBlobAccumulator = makeBatchedBlobAccumulator(seed);
+    return new BlockBlobPublicInputs(startBlobAccumulator.toBlobAccumulatorPublicInputs(), makeBatchedBlobAccumulator(seed + 1).toBlobAccumulatorPublicInputs(), startBlobAccumulator.finalBlobChallenges);
 }
 // TODO: copied form stdlib tx effect
 function encodeFirstField(length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/blob-lib",
-  "version": "1.0.0-nightly.20250608",
+  "version": "1.0.0-nightly.20250610",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -25,8 +25,8 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/constants": "1.0.0-nightly.20250608",
-    "@aztec/foundation": "1.0.0-nightly.20250608",
+    "@aztec/constants": "1.0.0-nightly.20250610",
+    "@aztec/foundation": "1.0.0-nightly.20250610",
     "c-kzg": "4.0.0-alpha.1",
     "tslib": "^2.4.0"
   },

package/src/blob.ts

@@ -2,7 +2,7 @@ import { poseidon2Hash, sha256 } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-// Importing directly from 'c-kzg' does not work, ignoring import/no-named-as-default-member err:
+// Importing directly from 'c-kzg' does not work:
 import cKzg from 'c-kzg';
 import type { Blob as BlobBuffer } from 'c-kzg';
 
@@ -301,6 +301,18 @@ export class Blob {
     return `0x${buf.toString('hex')}`;
   }
 
+  static getPrefixedEthBlobCommitments(blobs: Blob[]): `0x${string}` {
+    let buf = Buffer.alloc(0);
+    blobs.forEach(blob => {
+      buf = Buffer.concat([buf, blob.commitment]);
+    });
+    // For multiple blobs, 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: cKzg.blobToKzgCommitment,
@@ -310,6 +322,8 @@ export class Blob {
 
   // Returns as many blobs as we require to broadcast the given fields
   // Assumes we share the fields hash between all blobs
+  // TODO(MW): Rename to more accurate getBlobsPerBlock() - the items here share a fields hash,
+  // which can only be done for one block because the hash is calculated in block root.
   static async getBlobs(fields: Fr[]): Promise<Blob[]> {
     const numBlobs = Math.max(Math.ceil(fields.length / FIELD_ELEMENTS_PER_BLOB), 1);
     const multiBlobFieldsHash = await poseidon2Hash(fields);