BLOBKIT v2.0.0

class BlobKit {
  // Initialize BlobKit
  static async init(config: BlobKitConfig, signer?: Signer): Promise<BlobKit>
  
  // Write blob
  async writeBlob(
    data: Uint8Array | string | object,
    meta?: Partial<BlobMeta>,
    jobId?: string,
    maxRetries?: number
  ): Promise<BlobReceipt>
  
  // Read blob
  async readBlob(txHash: string, index?: number): Promise<BlobReadResult>
  async readBlobAsString(txHash: string): Promise<string>
  async readBlobAsJSON(txHash: string): Promise<any>
  
  // Cost estimation
  async estimateCost(data: Uint8Array): Promise<CostEstimate>
  
  // Proxy & escrow operations  
  async getJobStatus(jobId: string): Promise<JobStatus>
  async refundIfExpired(jobId: string): Promise<TransactionResponse>
  async getBalance(): Promise<bigint>
  async getAddress(): Promise<string>
}

interface BlobKitConfig {
  rpcUrl: string           // Ethereum RPC endpoint
  chainId?: number         // Network ID (1 = mainnet, 11155111 = sepolia)
  proxyUrl?: string        // Proxy server URL (required for wallet support)
  archiveUrl?: string      // Archive service for old blobs
  escrowContract?: string  // Custom escrow contract address
  logLevel?: 'debug' | 'info' | 'warn' | 'error'
}

interface BlobReceipt {
  jobId: string
  blobHash?: string
  blobTxHash?: string
  status: 'pending' | 'confirmed' | 'failed'
  error?: string
}

interface CostEstimate {
  blobGasPrice: string
  baseFee: string
  totalCostWei: string
  totalCostEth: string
  totalCostUsd?: string
}

import { BlobKit } from '@blobkit/sdk';

const blobkit = new BlobKit({
  // Core configuration
  rpcUrl: string,                    // Required: Ethereum RPC endpoint
  chainId?: number,                  // Chain ID (default: 1)
  archiveUrl?: string,               // Archive service URL (default: rpcUrl)
  defaultCodec?: string,             // Default data encoding (default: 'application/json')
  
  // Proxy configuration  
  proxyUrl?: string,                 // Proxy server URL (default: '')
  escrowContract?: string,           // Custom escrow address (default: auto-detected)
  maxProxyFeePercent?: number,       // Max acceptable proxy fee (default: 5)
  callbackUrl?: string,              // Webhook for async notifications (default: '')
  
  // Logging
  logLevel?: 'debug' | 'info' | 'silent',  // Log verbosity (default: 'info')
  
  // KZG setup
  kzgSetup?: {
    trustedSetupData?: Uint8Array,   // Pre-loaded setup data
    trustedSetupUrl?: string,         // URL to load setup (browser)
    trustedSetupPath?: string,        // File path to setup (Node.js)
    expectedHash?: string             // Hash for integrity check
  },
  
  // Metrics hooks
  metricsHooks?: {
    onBlobWrite?: (size: number, duration: number, success: boolean) => void,
    onBlobRead?: (size: number, duration: number, success: boolean, source: string) => void,
    onProxyRequest?: (url: string, duration: number, success: boolean) => void,
    onKzgOperation?: (operation: string, duration: number, success: boolean) => void,
    onError?: (error: Error, context: string) => void
  }
}, signer);

import { createFromEnv } from '@blobkit/sdk';
import { ethers } from 'ethers';

// Set environment variables
process.env.BLOBKIT_RPC_URL = 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY';
process.env.BLOBKIT_ARCHIVE_URL = 'https://api.blobscan.com';
process.env.BLOBKIT_CHAIN_ID = '1';
process.env.BLOBKIT_PROXY_URL = 'https://proxy.blobkit.org';
process.env.BLOBKIT_LOG_LEVEL = 'debug';
process.env.BLOBKIT_KZG_TRUSTED_SETUP_PATH = './trusted_setup.txt';

// Create BlobKit instance
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY);
const blobkit = createFromEnv(wallet);

const blobkit = new BlobKit({
  rpcUrl: '...',
  metricsHooks: {
    // Track blob writes
    onBlobWrite: (size, duration, success) => {
      console.log(`Blob write: ${size} bytes in ${duration}ms, success: ${success}`);
      // Send to your metrics service
      metrics.track('blob.write', { size, duration, success });
    },
    
    // Track blob reads
    onBlobRead: (size, duration, success, source) => {
      console.log(`Blob read: ${size} bytes from ${source} in ${duration}ms`);
      metrics.track('blob.read', { size, duration, success, source });
    },
    
    // Track proxy requests
    onProxyRequest: (url, duration, success) => {
      console.log(`Proxy request to ${url}: ${duration}ms, success: ${success}`);
      metrics.track('proxy.request', { url, duration, success });
    },
    
    // Track KZG operations
    onKzgOperation: (operation, duration, success) => {
      console.log(`KZG ${operation}: ${duration}ms, success: ${success}`);
      metrics.track('kzg.operation', { operation, duration, success });
    },
    
    // Track errors
    onError: (error, context) => {
      console.error(`Error in ${context}:`, error);
      errorReporter.report(error, { context });
    }
  }
});

// Custom archive URL
const blobkit = new BlobKit({
  rpcUrl: '...',
  archiveUrl: 'https://archive.example.com'  // Use different archive service
});

// Custom default codec
const blobkit = new BlobKit({
  rpcUrl: '...',
  defaultCodec: 'text/plain'  // Default to plain text encoding
});

import { 
  bytesToHex, 
  hexToBytes,
  formatEther,
  parseEther
} from '@blobkit/sdk';

// Convert bytes to hex string
const bytes = new Uint8Array([1, 2, 3, 4]);
const hex = bytesToHex(bytes);  // '0x01020304'

// Convert hex string to bytes
const restored = hexToBytes(hex);  // Uint8Array([1, 2, 3, 4])

// Format wei to ETH string
const wei = BigInt('1000000000000000000');
const eth = formatEther(wei);  // '1'

// Parse ETH string to wei
const weiValue = parseEther('1.5');  // 1500000000000000000n

import { 
  isValidAddress,
  validateBlobSize
} from '@blobkit/sdk';

// Validate Ethereum address
const valid = isValidAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f2bD77');  // true
const invalid = isValidAddress('not-an-address');  // false

// Validate blob size (throws if too large)
const data = new Uint8Array(100000);  // 100KB
try {
  validateBlobSize(data);  // OK
} catch (error) {
  console.error('Blob too large');
}

import { 
  generateJobId,
  calculatePayloadHash
} from '@blobkit/sdk';

// Calculate hash of payload
const data = new Uint8Array([1, 2, 3, 4]);
const hash = calculatePayloadHash(data);  // '0x...' keccak256 hash

// Generate unique job ID
const userAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f2bD77';
const jobId = generateJobId(userAddress, hash, 0);  // Unique job ID

import { 
  FIELD_ELEMENTS_PER_BLOB,
  BYTES_PER_FIELD_ELEMENT,
  BLOB_SIZE
} from '@blobkit/sdk';

console.log(FIELD_ELEMENTS_PER_BLOB);  // 4096
console.log(BYTES_PER_FIELD_ELEMENT);  // 31
console.log(BLOB_SIZE);                 // 131072