Blob.verifyBatch

Batch verify multiple blob proofs (more efficient)

Try it Live

Run Blob examples in the interactive playground

Performance

Batch verification is significantly faster than individual verification:

import { Blob } from 'tevm';

const blobs = [blob1, blob2, blob3, blob4, blob5, blob6];
const commitments = blobs.map(b => b.toCommitment());
const proofs = blobs.map(b => b.toProof());

// Individual verification (slower)
console.time('individual');
const results = blobs.map((blob, i) =>
  Blob.verify(blob, commitments[i], proofs[i])
);
const allValid1 = results.every(r => r);
console.timeEnd('individual'); // ~60ms

// Batch verification (faster)
console.time('batch');
const allValid2 = Blob.verifyBatch(blobs, commitments, proofs);
console.timeEnd('batch'); // ~20ms

console.log(allValid1 === allValid2); // true

Finding Invalid Blobs

If batch verification fails, find which blob is invalid:

import { Blob } from 'tevm';

const blobs = [blob1, blob2, blob3];
const commitments = [c1, c2, c3];
const proofs = [p1, p2, p3];

// Batch verify
const allValid = Blob.verifyBatch(blobs, commitments, proofs);

if (!allValid) {
  console.error('Batch verification failed');

  // Find invalid blob(s)
  const invalid: number[] = [];
  for (let i = 0; i < blobs.length; i++) {
    const valid = Blob.verify(blobs[i], commitments[i], proofs[i]);
    if (!valid) {
      invalid.push(i);
    }
  }

  console.error(`Invalid blobs: ${invalid.join(', ')}`);
}

Array Length Validation

import { Blob } from 'tevm';

const blobs = [blob1, blob2];
const commitments = [c1, c2, c3]; // Wrong length
const proofs = [p1, p2];

try {
  Blob.verifyBatch(blobs, commitments, proofs);
} catch (e) {
  console.error(e); // "Array lengths must match"
}

Empty Arrays

import { Blob } from 'tevm';

// Empty arrays (valid - vacuous truth)
const result = Blob.verifyBatch([], [], []);
console.log(result); // true

Use in Validators

import { Blob } from 'tevm';

class BlobTransactionValidator {
  validate(tx: BlobTransaction): boolean {
    // Check array lengths
    if (
      tx.blobs.length !== tx.commitments.length ||
      tx.blobs.length !== tx.proofs.length ||
      tx.blobs.length !== tx.blobVersionedHashes.length
    ) {
      return false;
    }

    // Batch verify proofs
    if (!Blob.verifyBatch(tx.blobs, tx.commitments, tx.proofs)) {
      return false;
    }

    // Verify versioned hashes
    for (let i = 0; i < tx.blobs.length; i++) {
      const computed = Blob.Commitment.toVersionedHash(tx.commitments[i]);
      if (!Blob.equals(computed, tx.blobVersionedHashes[i])) {
        return false;
      }
    }

    return true;
  }
}

See Also

• verify - Verify single blob
• toCommitment - Generate commitment
• toProof - Generate proof
• KZG - KZG verification details