import { initializeForProduction } from 'blobkit'

// Production: Uses official KZG trusted setup
// Download files from: https://github.com/ethereum/kzg-ceremony-sequencer
await initializeForProduction(
  '/path/to/g1.point',
  '/path/to/g2.point',
  'text'  // or 'binary'
)

import { initializeForDevelopment } from 'blobkit'

// Development: Uses mock setup - DO NOT use in production
await initializeForDevelopment()

// Custom Codec Registration
import { registerCodec } from 'blobkit'

// Create custom codec for compressed game states
const gameStateCodec = {
  encode(gameState: GameState): Uint8Array {
    const json = JSON.stringify(gameState)
    return compress(new TextEncoder().encode(json))
  },
  
  decode(data: Uint8Array): GameState {
    const decompressed = decompress(data)
    return JSON.parse(new TextDecoder().decode(decompressed))
  }
}

// Register the codec
registerCodec('application/x-gamestate+gzip', gameStateCodec)

// Use custom codec
const receipt = await blobkit.writeBlob(gameState, {
  codec: 'application/x-gamestate+gzip'
})

// Rich Metadata Support
const receipt = await blobkit.writeBlob(chatMessage, {
  appId: 'secure-chat',
  codec: 'application/json',
  ttlBlocks: 50400,      // ~1 week expiry
  timestamp: Date.now(),
  contentHash: 'auto'    // Automatically computed
})

// Metadata is cryptographically bound to blob content
const blobData = await blobkit.readBlobWithMeta(receipt.blobHash)
console.log('App ID:', blobData.meta.appId)
console.log('Expires at block:', blobData.meta.ttlBlocks)
console.log('Content hash:', blobData.meta.contentHash)

// Archive Support for Long-term Storage
const blobkit = new BlobKit({
  rpcUrl: 'https://mainnet.infura.io/v3/YOUR_KEY',
  chainId: 1,
  archiveUrl: 'https://blob-archive.service.com'  // Third-party archive
}, privateKey)

// BlobKit automatically falls back to archive if blob expired from nodes
try {
  const data = await blobkit.readBlob(oldBlobHash)  // May be months old
  console.log('Retrieved from archive:', data)
} catch (error) {
  console.log('Blob not found in nodes or archive')
}

// Automatic Compression
// BlobKit automatically compresses data when writing blobs
const blobkit = new BlobKit(config, privateKey)

// Large data is automatically compressed during write
const largeData = {
  data: new Array(10000).fill('test data'),
  metadata: { type: 'bulk_upload' }
}

// Compression happens internally
const receipt = await blobkit.writeBlob(largeData, {
  appId: 'data-processor',
  compressionLevel: 3  // Optional: control compression (0-11)
})

// Data is automatically decompressed when reading
const retrieved = await blobkit.readBlobWithMeta(receipt.blobHash)
console.log('Data restored:', retrieved.data)

import { initializeForDevelopment, initializeForProduction } from 'blobkit'

// Development (uses mock setup - DO NOT use in production)
await initializeForDevelopment()

// Production (requires official KZG ceremony files)
await initializeForProduction(
  g1Path: string,              // Path to G1 points file
  g2Path: string,              // Path to G2 points file  
  format?: 'binary' | 'text'   // File format (default: 'text')
)

// Download ceremony files from:
// https://github.com/ethereum/kzg-ceremony-sequencer

import { BlobKit, createFromEnv, createReadOnlyFromEnv } from 'blobkit'

// Recommended: From environment variables with validation
const blobkit = createFromEnv()              // Read/write client
const readOnly = createReadOnlyFromEnv()     // Read-only client

// Manual configuration
const blobkit = new BlobKit({
  rpcUrl: string,           // Ethereum RPC endpoint (validated)
  chainId?: number,         // Default: 1 (mainnet) 
  archiveUrl?: string,      // Optional blob archive service
  defaultCodec?: string,    // Default: 'application/json'
  compressionLevel?: number // Brotli level 0-11 (default: 3)
}, privateKey?: string)     // Optional for read-only operations

// EIP-4844 Blob Fee Calculation
const totalCost = baseFee + (blobGasUsed * blobGasPrice)

// Where:
// baseFee: Standard Ethereum transaction fee (21,000 gas minimum)
// blobGasUsed: 131,072 gas per blob (fixed)
// blobGasPrice: Dynamic market price (starts at 1 wei, target 3 blobs/block)

// Example calculation:
const baseFee = 0.0001 ETH        // ~20 gwei * 21,000 gas
const blobGas = 131072           // Fixed per blob
const blobGasPrice = 0.000001 ETH // ~1 gwei (varies by demand)
const totalCost = baseFee + (blobGas * blobGasPrice)
// = 0.0001 + 0.000131 = ~0.000231 ETH (~$0.50 at $2,000 ETH)

import { BlobKit } from 'blobkit'

// Set maximum blob gas price for cost control
const blobkit = new BlobKit({
  rpcUrl: process.env.RPC_URL,
  chainId: 1
}, process.env.PRIVATE_KEY)

// Write blob with fee limits
const receipt = await blobkit.writeBlob(data, {
  maxFeePerBlobGas: BigInt('2000000000'), // 2 gwei maximum
  gasLimit: BigInt('100000')              // Transaction gas limit
})

// Monitor transaction status
console.log('Transaction hash:', receipt.txHash)
console.log('Actual blob gas used:', receipt.blobGasUsed)
console.log('Actual blob gas price:', receipt.blobGasPrice)

// Real-time fee monitoring before submission
import { ethers } from 'ethers'

const provider = new ethers.JsonRpcProvider(process.env.RPC_URL)

// Get current blob base fee
const block = await provider.getBlock('latest')
const currentBlobBaseFee = block.blobGasUsed 
  ? block.excessBlobGas / 126976 // EIP-4844 formula
  : 1 // Minimum 1 wei

// Estimate total cost before submission
const estimatedCost = baseFee + (131072 * currentBlobBaseFee)
console.log('Estimated cost:', ethers.formatEther(estimatedCost), 'ETH')

// Only proceed if cost is acceptable
if (estimatedCost < maxAcceptableCost) {
  const receipt = await blobkit.writeBlob(data)
}