EIP-4844 Specification

import { Blob } from 'tevm';

console.log(Blob.SIZE);                    // 131,072 bytes (128 KB)
console.log(Blob.FIELD_ELEMENTS_PER_BLOB); // 4,096 elements
console.log(Blob.BYTES_PER_FIELD_ELEMENT); // 32 bytes per element

// Total: 4,096 * 32 = 131,072 bytes

Modulus (p):
0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001

Decimal:
52435875175126190479447740508185965837690552500527637822603658699938581184513

interface BlobTransaction {
  type: '0x03';
  chainId: bigint;
  nonce: bigint;
  maxPriorityFeePerGas: bigint;
  maxFeePerGas: bigint;
  gas: bigint;
  to: Address;
  value: bigint;
  data: Uint8Array;
  accessList: AccessList;
  maxFeePerBlobGas: bigint;              // Blob-specific
  blobVersionedHashes: VersionedHash[];  // Blob-specific
  // Signature fields
  v: bigint;
  r: bigint;
  s: bigint;
}

interface BlobSidecar {
  blobs: Blob[];              // Not on-chain
  commitments: Commitment[];  // Not on-chain
  proofs: Proof[];            // Not on-chain
}

import { Blob } from 'tevm';

// Prepare blob data
const data = new TextEncoder().encode("Rollup batch");
const blob = Blob.fromData(data);
const commitment = Blob.toCommitment(blob);
const proof = Blob.toProof(blob);
const versionedHash = Blob.Commitment.toVersionedHash(commitment);

// Create transaction
const tx = {
  type: '0x03',
  chainId: 1n,
  nonce: 42n,
  maxPriorityFeePerGas: 1_000_000_000n,  // 1 gwei
  maxFeePerGas: 30_000_000_000n,         // 30 gwei
  gas: 21000n,
  to: '0xYourContract',
  value: 0n,
  data: '0x',
  accessList: [],
  maxFeePerBlobGas: 100_000_000n,        // 100 gwei
  blobVersionedHashes: [versionedHash],  // On-chain
  // Sidecar (mempool only)
  blobs: [blob],
  commitments: [commitment],
  proofs: [proof],
};

import { Blob } from 'tevm';

console.log(Blob.GAS_PER_BLOB);        // 131,072 (2^17)
console.log(Blob.TARGET_GAS_PER_BLOCK); // 393,216 (3 blobs)

// Maximum per block: 6 blobs
const maxGas = Blob.GAS_PER_BLOB * 6;
console.log(maxGas); // 786,432

Target: 3 blobs per block (393,216 gas)
Max: 6 blobs per block (786,432 gas)

If excess_blob_gas > 0:
  blob_base_fee increases

If excess_blob_gas < 0:
  blob_base_fee decreases

# EIP-4844 fee adjustment
BLOB_BASE_FEE_UPDATE_FRACTION = 3338477

def fake_exponential(factor, numerator, denominator):
    """Approximation of e^(factor * numerator / denominator)"""
    i = 1
    output = 0
    numerator_accumulator = factor * denominator
    while numerator_accumulator > 0:
        output += numerator_accumulator
        numerator_accumulator = (numerator_accumulator * numerator) // (denominator * i)
        i += 1
    return output // denominator

def get_blob_base_fee(excess_blob_gas):
    """Calculate blob base fee from excess gas"""
    return fake_exponential(
        1,  # MIN_BASE_FEE_PER_BLOB_GAS
        excess_blob_gas,
        BLOB_BASE_FEE_UPDATE_FRACTION
    )

import { Blob } from 'tevm';

// Block with 2 blobs (below target of 3)
const usedGas = Blob.calculateGas(2);
const targetGas = Blob.TARGET_GAS_PER_BLOCK;

if (usedGas < targetGas) {
  console.log('Next block: fee decreases');
  // excess_blob_gas becomes more negative
}

// Block with 5 blobs (above target)
const highUsage = Blob.calculateGas(5);

if (highUsage > targetGas) {
  console.log('Next block: fee increases');
  // excess_blob_gas becomes more positive
}

┌─────────────┬──────────────────────────────────────┐
│  Version    │  SHA256(commitment)[1:32]            │
├─────────────┼──────────────────────────────────────┤
│  0x01       │  31 bytes from hash                  │
└─────────────┴──────────────────────────────────────┘

import { Blob } from 'tevm';
import { sha256 } from '@noble/hashes/sha256';

const blob = Blob.fromData(data);
const commitment = Blob.toCommitment(blob);

// SHA256 of commitment
const hash = sha256(commitment);

// Versioned hash: 0x01 + hash[1:32]
const versionedHash = Bytes32();
versionedHash[0] = 0x01; // KZG version
versionedHash.set(hash.slice(1), 1);

// Verify
const auto = Blob.Commitment.toVersionedHash(commitment);
console.log(Blob.equals(versionedHash, auto)); // true

import { Blob } from 'tevm';

console.log(Blob.COMMITMENT_VERSION_KZG); // 0x01

// Future versions (not yet used)
// 0x02 = Future commitment scheme
// 0x03 = Another scheme

// Constants
const MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS = 4096;
const SECONDS_PER_EPOCH = 384; // 32 slots * 12 seconds
const RETENTION_SECONDS = MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS * SECONDS_PER_EPOCH;
const RETENTION_DAYS = RETENTION_SECONDS / 86400;

console.log(`Retention: ~${RETENTION_DAYS} days`); // ~18 days

import { Blob } from 'tevm';

class L2DataManager {
  async storeBlock(blockNumber: number, blobs: Blob[]) {
    // Download blobs from beacon chain
    const data = Blob.joinData(blobs);

    // Store in local database
    await this.db.put(`block:${blockNumber}`, data);

    console.log(`Stored block ${blockNumber}: ${data.length} bytes`);
  }

  async getBlock(blockNumber: number): Promise<Uint8Array> {
    // Retrieve from local storage
    const data = await this.db.get(`block:${blockNumber}`);

    if (!data) {
      throw new Error(`Block ${blockNumber} not available (pruned)`);
    }

    return data;
  }
}

import { Blob } from 'tevm';

// Different data = different commitments
const blob1 = Blob.fromData(data1);
const blob2 = Blob.fromData(data2);

const commitment1 = blob1.toCommitment();
const commitment2 = blob2.toCommitment();

console.log(Blob.equals(commitment1, commitment2)); // false

// Cannot create valid proof for wrong blob
const proof1 = blob1.toProof();
console.log(Blob.verify(blob1, commitment1, proof1)); // true
console.log(Blob.verify(blob2, commitment1, proof1)); // false

import { Blob } from 'tevm';

class BlobValidator {
  verifyTransaction(tx: BlobTransaction): boolean {
    // Verify arrays match
    if (
      tx.blobs.length !== tx.commitments.length ||
      tx.blobs.length !== tx.proofs.length ||
      tx.blobs.length !== tx.blobVersionedHashes.length
    ) {
      return false;
    }

    // Verify blob count
    if (tx.blobs.length > Blob.MAX_PER_TRANSACTION) {
      return false;
    }

    // Batch verify KZG 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;
  }
}

import { Blob } from 'tevm';

// Execution gas (normal transaction)
const executionGas = 21000n;
const executionBaseFee = 30_000_000_000n; // 30 gwei
const executionCost = executionGas * executionBaseFee;

// Blob gas (separate market)
const blobCount = 2;
const blobBaseFee = 50_000_000n; // 50 gwei
const blobGas = Blob.calculateGas(blobCount);
const blobCost = BigInt(blobGas) * blobBaseFee;

// Total
const totalCost = executionCost + blobCost;

console.log(`Execution: ${executionCost / 10n**9n} gwei`);
console.log(`Blobs: ${blobCost / 10n**9n} gwei`);
console.log(`Total: ${totalCost / 10n**9n} gwei`);

import { Blob } from 'tevm';

// Blob transaction (2 blobs = ~256 KB)
const blobBytes = Blob.SIZE * 2;
const blobGas = Blob.calculateGas(2);
const blobBaseFee = 50_000_000n;
const blobCost = BigInt(blobGas) * blobBaseFee;

// Equivalent calldata
const calldataGas = BigInt(blobBytes) * 16n; // 16 gas per byte
const executionBaseFee = 30_000_000_000n;
const calldataCost = calldataGas * executionBaseFee;

console.log(`Blob cost: ${blobCost / 10n**9n} gwei`);
console.log(`Calldata cost: ${calldataCost / 10n**9n} gwei`);

const savings = ((1 - Number(blobCost) / Number(calldataCost)) * 100).toFixed(1);
console.log(`Savings: ${savings}%`);

// Fetch blobs for transaction (beacon node)
const response = await fetch(
  `http://beacon-node/eth/v1/beacon/blob_sidecars/${slot}`
);
const sidecars = await response.json();

// Each sidecar contains:
// - blob: 131,072 bytes
// - kzg_commitment: 48 bytes
// - kzg_proof: 48 bytes