Production में On-Chain Data: जो कोई नहीं बताता

Blockchain data न तो साफ है, न भरोसेमंद, न आसान। RPC rate limits, chain reorgs, BigInt bugs, और indexing tradeoffs — असली DeFi प्रोडक्ट्स ship करने से सीखे कठिन सबक।

एक कल्पना है कि on-chain data स्वाभाविक रूप से भरोसेमंद है। Immutable ledger। Transparent state। बस पढ़ो और हो गया।

मैं भी यही मानता था। फिर मैंने एक DeFi dashboard production में ship किया और तीन हफ्ते यह समझने में बिताए कि हमारे token balances गलत क्यों थे, हमारी event history में gaps क्यों थे, और हमारे database में ऐसे blocks के transactions क्यों थे जो अब exist ही नहीं करते।

On-chain data raw, hostile, और ऐसे edge cases से भरा है जो आपकी application को ऐसे तरीकों से तोड़ेंगे जो आपको तब तक पता नहीं चलेंगे जब तक कोई user bug report file नहीं करता। यह पोस्ट वह सब cover करती है जो मैंने कठिन तरीके से सीखा।

भरोसेमंद Data का भ्रम#

यह रही पहली बात जो कोई नहीं बताता: blockchain आपको data नहीं देता। यह आपको state transitions देता है। कोई SELECT * FROM transfers WHERE user = '0x...' नहीं है। Logs हैं, receipts हैं, storage slots हैं, और call traces हैं — सब ऐसे formats में encoded जिन्हें decode करने के लिए context चाहिए।

typescript

import { createPublicClient, fallback, http } from "viem";
import { mainnet } from "viem/chains";
 
const client = createPublicClient({
  chain: mainnet,
  transport: fallback(
    [
      http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY", {
        retryCount: 3,
        retryDelay: 1500,
        timeout: 15_000,
      }),
      http("https://mainnet.infura.io/v3/YOUR_KEY", {
        retryCount: 3,
        retryDelay: 1500,
        timeout: 15_000,
      }),
      http("https://rpc.ankr.com/eth", {
        retryCount: 2,
        retryDelay: 2000,
        timeout: 20_000,
      }),
    ],
    { rank: true },
  ),
});

typescript

interface IndexedBlock {
  number: bigint;
  hash: `0x${string}`;
  parentHash: `0x${string}`;
}
 
async function detectReorg(
  client: PublicClient,
  lastIndexed: IndexedBlock,
): Promise<{ reorged: boolean; depth: number }> {
  const currentBlock = await client.getBlock({
    blockNumber: lastIndexed.number,
  });
 
  if (currentBlock.hash === lastIndexed.hash) {
    return { reorged: false, depth: 0 };
  }
 
  // पीछे चलकर पता करें कि chain कहां diverge हुई
  let depth = 1;
  let checkNumber = lastIndexed.number - 1n;
 
  while (checkNumber > 0n && depth < 128) {
    const onChain = await client.getBlock({ blockNumber: checkNumber });
    const inDb = await getIndexedBlock(checkNumber); // आपका DB lookup
 
    if (onChain.hash === inDb?.hash) {
      return { reorged: true, depth };
    }
 
    depth++;
    checkNumber--;
  }
 
  return { reorged: true, depth };
}

typescript

import type { PublicClient, Log, AbiEvent } from "viem";
 
async function fetchLogsInChunks<T extends AbiEvent>(
  client: PublicClient,
  params: {
    address: `0x${string}`;
    event: T;
    fromBlock: bigint;
    toBlock: bigint;
    maxBlockRange?: bigint;
  },
): Promise<Log<bigint, number, false, T, true>[]> {
  const { address, event, fromBlock, toBlock, maxBlockRange = 2000n } = params;
  const allLogs: Log<bigint, number, false, T, true>[] = [];
 
  let currentFrom = fromBlock;
 
  while (currentFrom <= toBlock) {
    const currentTo = currentFrom + maxBlockRange - 1n > toBlock ? toBlock : currentFrom + maxBlockRange - 1n;
 
    try {
      const logs = await client.getLogs({
        address,
        event,
        fromBlock: currentFrom,
        toBlock: currentTo,
      });
 
      allLogs.push(...logs);
      currentFrom = currentTo + 1n;
    } catch (error) {
      // अगर range बहुत बड़ी है (बहुत ज़्यादा results), इसे आधे में split करें
      if (isRangeTooLargeError(error) && currentTo > currentFrom) {
        const mid = currentFrom + (currentTo - currentFrom) / 2n;
        const firstHalf = await fetchLogsInChunks(client, {
          address,
          event,
          fromBlock: currentFrom,
          toBlock: mid,
          maxBlockRange,
        });
        const secondHalf = await fetchLogsInChunks(client, {
          address,
          event,
          fromBlock: mid + 1n,
          toBlock: currentTo,
          maxBlockRange,
        });
        allLogs.push(...firstHalf, ...secondHalf);
        currentFrom = currentTo + 1n;
      } else {
        throw error;
      }
    }
  }
 
  return allLogs;
}
 
function isRangeTooLargeError(error: unknown): boolean {
  const message = error instanceof Error ? error.message : String(error);
  return (
    message.includes("Log response size exceeded") ||
    message.includes("query returned more than") ||
    message.includes("exceed maximum block range")
  );
}

typescript

// BUG: हानिरहित लगता है, नहीं है
function formatTokenAmount(amount: bigint, decimals: number): string {
  return (Number(amount) / Math.pow(10, decimals)).toFixed(4);
}
 
// छोटी amounts के लिए यह ठीक काम करता है:
formatTokenAmount(1000000n, 6); // "1.0000" -- सही
 
// बड़ी amounts के लिए यह चुपचाप टूट जाता है:
formatTokenAmount(123456789012345678n, 18);
// "0.1235" return करता है -- गलत, actual precision lost है
// Number(123456789012345678n) === 123456789012345680
// आखिरी दो digits IEEE 754 द्वारा round हो गए

typescript

import { formatUnits, parseUnits } from "viem";
 
// सही: BigInt पर operate करता है, string return करता है
function formatTokenAmount(amount: bigint, decimals: number, displayDecimals: number = 4): string {
  const formatted = formatUnits(amount, decimals);
 
  // formatUnits पूरी precision string return करता है जैसे "0.123456789012345678"
  // desired display precision तक truncate (round नहीं) करें
  const [whole, fraction = ""] = formatted.split(".");
  const truncated = fraction.slice(0, displayDecimals).padEnd(displayDecimals, "0");
 
  return `${whole}.${truncated}`;
}
 
// यह भी critical है: user input के लिए parseUnits उपयोग करें, parseFloat कभी नहीं
function parseTokenInput(input: string, decimals: number): bigint {
  // parseUnits string-to-BigInt conversion सही तरीके से handle करता है
  return parseUnits(input, decimals);
}

typescript

// API response serializer
function serializeForApi(data: Record<string, unknown>): string {
  return JSON.stringify(data, (_, value) => (typeof value === "bigint" ? value.toString() : value));
}

typescript

import { LRUCache } from "lru-cache";
 
const memoryCache = new LRUCache<string, unknown>({
  max: 10_000,
  ttl: 1000 * 60, // 1 minute default
});
 
type CacheTier = "immutable" | "short" | "volatile";
 
const TTL_MAP: Record<CacheTier, number> = {
  immutable: 1000 * 60 * 60 * 24, // memory में 24 hours, Redis में permanent
  short: 1000 * 60 * 5, // 5 minutes
  volatile: 1000 * 15, // 15 seconds
};
 
async function cachedRpcCall<T>(key: string, tier: CacheTier, fetcher: () => Promise<T>): Promise<T> {
  // पहले memory check करें
  const cached = memoryCache.get(key) as T | undefined;
  if (cached !== undefined) return cached;
 
  // फिर Redis (अगर आपके पास है)
  // const redisCached = await redis.get(key);
  // if (redisCached) { ... }
 
  const result = await fetcher();
  memoryCache.set(key, result, { ttl: TTL_MAP[tier] });
 
  return result;
}
 
// उपयोग:
const receipt = await cachedRpcCall(`receipt:${txHash}`, "immutable", () =>
  client.getTransactionReceipt({ hash: txHash }),
);

typescript

// कोई type inference नहीं — args unknown[] है, return unknown है
const result = await client.readContract({
  address: "0x...",
  abi: JSON.parse(abiString), // runtime पर parse = कोई type info नहीं
  functionName: "balanceOf",
  args: ["0x..."],
});

typescript

// पूर्ण type inference के लिए ABI को const के रूप में define करें
const erc20Abi = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "account", type: "address" }],
    outputs: [{ name: "balance", type: "uint256" }],
  },
  {
    name: "transfer",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    outputs: [{ name: "success", type: "bool" }],
  },
] as const;
 
// अब TypeScript जानता है:
// - functionName "balanceOf" | "transfer" में autocomplete होता है
// - balanceOf के args [address: `0x${string}`] है
// - balanceOf का return type bigint है
const balance = await client.readContract({
  address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
  abi: erc20Abi,
  functionName: "balanceOf",
  args: ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
});
// typeof balance = bigint -- पूरी तरह typed

Production में On-Chain Data: जो कोई नहीं बताता

भरोसेमंद Data का भ्रम#

RPC Rate Limits आपका Weekend बर्बाद करेंगे#

Reorgs: वह Bug जो आप आते नहीं देखेंगे#

Indexing समस्या: अपना दर्द चुनें#

Direct RPC Calls#

The Graph (Subgraphs)#

Custom Indexers (Ponder, Envio)#

getLogs जितना दिखता है उससे ज़्यादा खतरनाक है#

BigInt आपको विनम्र बना देगा#

Caching Strategy: क्या, कितने समय, और कब Invalidate करें#

TypeScript और Contract ABIs: सही तरीका#

असुविधाजनक सच्चाई#

संबंधित पोस्ट

TypeScript Compiler API: Building Custom Linters, Codemods, and Type Analyzers

JSON to TypeScript Guide: Create Safer API Types From Real Payloads