Web Geliştiriciler İçin Ethereum: Abartı Olmadan Smart Contract

interface Transaction {
  to: string;      // 20-byte hex adres, veya contract deploy için null
  value: bigint;   // Gönderilecek ETH miktarı (wei cinsinden)
  data: string;    // Kodlanmış fonksiyon çağrısı verisi
  nonce: number;   // Sıralı sayaç, replay saldırılarını önler
  gasLimit: bigint;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  chainId: number; // 1 = mainnet, 11155111 = Sepolia, 137 = Polygon
}

const ERC20_ABI = [
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function totalSupply() view returns (uint256)",
  "function balanceOf(address owner) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "event Transfer(address indexed from, address indexed to, uint256 value)",
];

import { ethers } from "ethers";
 
const iface = new ethers.Interface(ERC20_ABI);
 
// Encode a function call
const calldata = iface.encodeFunctionData("transfer", [
  "0xBobAddress...",
  1000000n,
]);
console.log(calldata);
// 0xa9059cbb000000000000000000000000bob...000000000000000000000000000f4240
 
// Decode calldata back to function name and args
const decoded = iface.parseTransaction({ data: calldata });
console.log(decoded.name);       // "transfer"
console.log(decoded.args[0]);    // "0xBobAddress..."
console.log(decoded.args[1]);    // 1000000n (BigInt)
 
// Decode a function's return data
const returnData = "0x0000000000000000000000000000000000000000000000000000000000000001";
const result = iface.decodeFunctionResult("transfer", returnData);
console.log(result[0]); // true

import { ethers } from "ethers";
 
// Bir contract'ın slot 0'ını oku
const value = await provider.getStorage("0xContractAddress...", 0);
console.log(value); // 32 byte hex
 
// Bir mapping girişi oku (slot hesaplaması gerekir)
// mapping(address => uint256) slot 3'te ise:
const slot = ethers.keccak256(
  ethers.AbiCoder.defaultAbiCoder().encode(
    ["address", "uint256"],
    ["0xUserAddress...", 3] // anahtar, mapping'in slot numarası
  )
);
const balance = await provider.getStorage("0xContractAddress...", slot);

// Statik çağrı — anında, bedava
const balance = await contract.balanceOf("0x..."); // Değeri döndürür
 
// Transaction — gas maliyeti, onay bekler
const tx = await contract.transfer("0x...", 1000n); // Hash döndürür
const receipt = await tx.wait();                     // Dahil edilmeyi bekler
console.log(receipt.status); // 1 = başarılı, 0 = revert

// eth_call "Yetersiz bakiye" ile başarısız olursa
// HTTP yanıtı yine 200 OK gelir
// Hata response.result yerine response.error'dadır
 
// ethers.js ve viem bunu senin için halleder ve uygun şekilde fırlatır
// Ama raw fetch yapıyorsan dikkat et:
const response = await fetch(RPC_URL, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "eth_call",
    params: [{ to: "0x...", data: "0x..." }, "latest"],
  }),
});
 
const json = await response.json();
if (json.error) {
  // İşte gerçek hata!
  console.error(json.error.message);
}

import { ethers } from "ethers";
 
const provider = new ethers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
 
// ERC-20 arayüzü — sadece okuma fonksiyonları
const erc20 = new ethers.Contract(
  "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  [
    "function name() view returns (string)",
    "function symbol() view returns (string)",
    "function decimals() view returns (uint8)",
    "function totalSupply() view returns (uint256)",
    "function balanceOf(address) view returns (uint256)",
  ],
  provider // Not: provider, signer değil. Salt okunur.
);
 
const [name, symbol, decimals, totalSupply] = await Promise.all([
  erc20.name(),
  erc20.symbol(),
  erc20.decimals(),
  erc20.totalSupply(),
]);
 
console.log(`${name} (${symbol})`);           // "USD Coin (USDC)"
console.log(`Decimals: ${decimals}`);          // 6 (18 DEĞİL!)
console.log(`Total supply: ${ethers.formatUnits(totalSupply, decimals)}`);
 
// Belirli bir adresin bakiyesini kontrol et
const balance = await erc20.balanceOf("0xSomeAddress...");
console.log(`Balance: ${ethers.formatUnits(balance, decimals)} USDC`);

import { ethers } from "ethers";
 
// Bir node'a bağlan
const provider = new ethers.JsonRpcProvider("https://...");
 
// Temel sorgular
const blockNumber = await provider.getBlockNumber();
const balance = await provider.getBalance("0xAddress...");
const block = await provider.getBlock(blockNumber);
const txCount = await provider.getTransactionCount("0xAddress...");

// Private key'den (sunucu tarafı, script'ler)
const wallet = new ethers.Wallet("0xPrivateKey...", provider);
 
// Tarayıcı cüzdanından (istemci tarafı)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();
 
// Adresi al
const address = await signer.getAddress();

const usdc = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, provider);
 
// Okuma (bedava, değeri doğrudan döndürür)
const balance = await usdc.balanceOf("0xSomeAddress...");
// balance bir bigint: 1000000000n (6 ondalıklı 1000 USDC)
 
// Yazmak için signer ile bağla
const usdcWithSigner = usdc.connect(signer);
 
// Yazma (gas maliyeti, TransactionResponse döndürür)
const tx = await usdcWithSigner.transfer("0xRecipient...", 1000000n);
const receipt = await tx.wait(); // Blok dahil edilmesini bekle
 
if (receipt.status === 0) {
  throw new Error("Transaction revert oldu");
}

// TypeChain olmadan — tip kontrolü yok
const balance = await contract.balanceOf("0x...");
// balance 'any'. Otocompletion yok. Yanlış kullanım kolay.
 
// TypeChain ile — tam tip güvenliği
import { USDC__factory } from "./typechain";
 
const usdc = USDC__factory.connect(USDC_ADDRESS, provider);
const balance = await usdc.balanceOf("0x...");
// balance BigNumber. Otocompletion çalışır. Tip hataları derleme zamanında yakalanır.

// Gerçek zamanlı event'ler için WebSocket
const wsProvider = new ethers.WebSocketProvider("wss://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
 
const contract = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, wsProvider);
 
// Tüm Transfer event'lerini dinle
contract.on("Transfer", (from, to, value, event) => {
  console.log(`Transfer: ${from} -> ${to}`);
  console.log(`Miktar: ${ethers.formatUnits(value, 6)} USDC`);
});
 
// Belirli bir adrese yapılan transfer'leri dinle
const filter = contract.filters.Transfer(null, "0xMyAddress...");
contract.on(filter, (from, to, value) => {
  console.log(`Gelen transfer: ${ethers.formatUnits(value, 6)} USDC, gönderen: ${from}`);
});
 
// İşin bittiğinde temizle
contract.removeAllListeners();

// wagmi.config.ts
import { createConfig, http } from "wagmi";
import { mainnet, sepolia } from "wagmi/chains";
import { injected, walletConnect } from "wagmi/connectors";
 
export const config = createConfig({
  chains: [mainnet, sepolia],
  connectors: [
    injected(),
    walletConnect({ projectId: "YOUR_WALLETCONNECT_PROJECT_ID" }),
  ],
  transports: {
    [mainnet.id]: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"),
    [sepolia.id]: http("https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY"),
  },
});

// app/providers.tsx
"use client";
 
import { WagmiProvider } from "wagmi";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { config } from "./wagmi.config";
 
const queryClient = new QueryClient();
 
export function Providers({ children }: { children: React.ReactNode }) {
  return (
    <WagmiProvider config={config}>
      <QueryClientProvider client={queryClient}>
        {children}
      </QueryClientProvider>
    </WagmiProvider>
  );
}

"use client";
 
import { useReadContract } from "wagmi";
import { formatUnits } from "viem";
 
const ERC20_ABI = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "owner", type: "address" }],
    outputs: [{ name: "balance", type: "uint256" }],
  },
] as const;
 
function TokenBalance({ address }: { address: `0x${string}` }) {
  const { data: balance, isLoading, error } = useReadContract({
    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
    abi: ERC20_ABI,
    functionName: "balanceOf",
    args: [address],
  });
 
  if (isLoading) return <span>Yükleniyor...</span>;
  if (error) return <span>Hata: {error.message}</span>;
 
  // balance bigint olarak tipli çünkü ABI uint256 diyor
  return <span>{formatUnits(balance ?? 0n, 6)} USDC</span>;
}

"use client";
 
import { useWriteContract, useWaitForTransactionReceipt } from "wagmi";
import { parseUnits } from "viem";
 
function SendTokens() {
  const { writeContract, data: hash, isPending, error } = useWriteContract();
 
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({
    hash,
  });
 
  function handleSend() {
    writeContract({
      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      abi: ERC20_ABI,
      functionName: "transfer",
      args: [
        "0xRecipientAddress...",
        parseUnits("100", 6), // 100 USDC
      ],
    });
  }
 
  return (
    <div>
      <button onClick={handleSend} disabled={isPending}>
        {isPending ? "Cüzdanda onaylayın..." : "100 USDC Gönder"}
      </button>
 
      {hash && <p>Transaction: {hash}</p>}
      {isConfirming && <p>Onay bekleniyor...</p>}
      {isSuccess && <p>Transfer onaylandı!</p>}
      {error && <p>Hata: {error.message}</p>}
    </div>
  );
}

"use client";
 
import { useWatchContractEvent } from "wagmi";
import { useState } from "react";
import { formatUnits } from "viem";
 
interface TransferEvent {
  from: string;
  to: string;
  value: string;
}
 
function LiveTransfers() {
  const [transfers, setTransfers] = useState<TransferEvent[]>([]);
 
  useWatchContractEvent({
    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
    abi: ERC20_ABI,
    eventName: "Transfer",
    onLogs(logs) {
      const newTransfers = logs.map((log) => ({
        from: log.args.from as string,
        to: log.args.to as string,
        value: formatUnits(log.args.value as bigint, 6),
      }));
      setTransfers((prev) => [...newTransfers, ...prev].slice(0, 50));
    },
  });
 
  return (
    <ul>
      {transfers.map((t, i) => (
        <li key={i}>
          {t.from.slice(0, 8)}... → {t.to.slice(0, 8)}...: {t.value} USDC
        </li>
      ))}
    </ul>
  );
}

interface EIP1193Provider {
  request(args: { method: string; params?: unknown[] }): Promise<unknown>;
  on(event: string, handler: (...args: unknown[]) => void): void;
  removeListener(event: string, handler: (...args: unknown[]) => void): void;
}

// Düşük seviye cüzdan etkileşimi (doğrudan yapmamalısın ama anlamak faydalı)
 
// Hesap erişimi iste
const accounts = await window.ethereum.request({
  method: "eth_requestAccounts",
});
console.log("Bağlı adres:", accounts[0]);
 
// Mevcut zinciri al
const chainId = await window.ethereum.request({
  method: "eth_chainId",
});
console.log("Chain ID:", parseInt(chainId, 16)); // "0x1" -> 1 (mainnet)
 
// Hesap değişikliklerini dinle (kullanıcı MetaMask'ta hesap değiştirdiğinde)
window.ethereum.on("accountsChanged", (accounts: string[]) => {
  if (accounts.length === 0) {
    console.log("Cüzdan bağlantısı kesildi");
  } else {
    console.log("Geçilen hesap:", accounts[0]);
  }
});
 
// Zincir değişikliklerini dinle (kullanıcı ağ değiştirdiğinde)
window.ethereum.on("chainChanged", (chainId: string) => {
  // Önerilen yaklaşım sayfayı yeniden yüklemektir
  window.location.reload();
});

// Tüm mevcut cüzdanları keşfetme
interface EIP6963ProviderDetail {
  info: {
    uuid: string;
    name: string;
    icon: string;
    rdns: string;  // Ters alan adı, ör. "io.metamask"
  };
  provider: EIP1193Provider;
}
 
const wallets: EIP6963ProviderDetail[] = [];
 
window.addEventListener("eip6963:announceProvider", (event: CustomEvent) => {
  wallets.push(event.detail);
});
 
// Tüm cüzdanların kendilerini duyurmasını iste
window.dispatchEvent(new Event("eip6963:requestProvider"));
 
// Artık 'wallets' tüm kurulu cüzdanları adları ve ikonlarıyla içerir
// Cüzdan seçim arayüzü gösterebilirsin

import { walletConnect } from "wagmi/connectors";
 
const connector = walletConnect({
  projectId: "YOUR_PROJECT_ID", // cloud.walletconnect.com'dan al
  showQrModal: true,
});

"use client";
 
import { useAccount, useSwitchChain } from "wagmi";
import { mainnet } from "wagmi/chains";
 
function NetworkGuard({ children }: { children: React.ReactNode }) {
  const { chain } = useAccount();
  const { switchChain, isPending } = useSwitchChain();
 
  if (!chain) return <p>Lütfen cüzdanınızı bağlayın</p>;
 
  if (chain.id !== mainnet.id) {
    return (
      <div>
        <p>Lütfen Ethereum Mainnet'e geçin</p>
        <button
          onClick={() => switchChain({ chainId: mainnet.id })}
          disabled={isPending}
        >
          {isPending ? "Geçiş yapılıyor..." : "Ağ Değiştir"}
        </button>
      </div>
    );
  }
 
  return <>{children}</>;
}

{
  "name": "Cool NFT #42",
  "description": "A very cool NFT",
  "image": "ipfs://QmImageHash...",
  "attributes": [
    { "trait_type": "Background", "value": "Blue" },
    { "trait_type": "Rarity", "value": "Legendary" }
  ]
}

function ipfsToHttp(uri: string): string {
  if (uri.startsWith("ipfs://")) {
    const cid = uri.replace("ipfs://", "");
    return `https://ipfs.io/ipfs/${cid}`;
    // Veya adanmış bir gateway kullan:
    // return `https://YOUR_PROJECT.mypinata.cloud/ipfs/${cid}`;
  }
  return uri;
}
 
// NFT metadata'sı getirme
async function getNftMetadata(
  contractAddress: string,
  tokenId: bigint,
  provider: ethers.Provider
) {
  const contract = new ethers.Contract(
    contractAddress,
    ["function tokenURI(uint256 tokenId) view returns (string)"],
    provider
  );
 
  const tokenUri = await contract.tokenURI(tokenId);
  const httpUri = ipfsToHttp(tokenUri);
 
  const response = await fetch(httpUri);
  const metadata = await response.json();
 
  return {
    name: metadata.name,
    description: metadata.description,
    image: ipfsToHttp(metadata.image),
    attributes: metadata.attributes,
  };
}

// Pinata'ya yükleme
async function pinToIpfs(file: File): Promise<string> {
  const formData = new FormData();
  formData.append("file", file);
 
  const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${PINATA_JWT}`,
    },
    body: formData,
  });
 
  const result = await response.json();
  return `ipfs://${result.IpfsHash}`; // CID döndürür
}

# Subgraph şeması (schema.graphql)
type Transfer @entity {
  id: Bytes!
  from: Bytes!
  to: Bytes!
  value: BigInt!
  blockNumber: BigInt!
  timestamp: BigInt!
}
 
type Account @entity {
  id: Bytes!
  balance: BigInt!
  transfersFrom: [Transfer!]! @derivedFrom(field: "from")
  transfersTo: [Transfer!]! @derivedFrom(field: "to")
}

// Frontend'inden bir subgraph sorgulama
const SUBGRAPH_URL =
  "https://api.studio.thegraph.com/query/YOUR_ID/YOUR_SUBGRAPH/v0.0.1";
 
async function getRecentTransfers(address: string) {
  const query = `
    query GetTransfers($address: Bytes!) {
      transfers(
        where: { from: $address }
        orderBy: blockNumber
        orderDirection: desc
        first: 100
      ) {
        id
        from
        to
        value
        blockNumber
        timestamp
      }
    }
  `;
 
  const response = await fetch(SUBGRAPH_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ query, variables: { address } }),
  });
 
  const { data } = await response.json();
  return data.transfers;
}

// Alchemy: Bir adresin tüm ERC-20 token bakiyelerini al
const response = await fetch(
  `https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "alchemy_getTokenBalances",
      params: ["0xAddress...", "erc20"],
    }),
  }
);
 
// Tek çağrıda TÜM ERC-20 token bakiyelerini döndürür
// vs. olası her ERC-20 contract'ın balanceOf()'unu taramak

// Alchemy: Bir adresin sahip olduğu tüm NFT'leri al
const response = await fetch(
  `https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY/getNFTs?owner=0xAddress...`
);
 
const { ownedNfts } = await response.json();
for (const nft of ownedNfts) {
  console.log(`${nft.title} - ${nft.contract.address}#${nft.tokenId}`);
}

// YANLIŞ — sessiz hassasiyet kaybı
const balance = 1000000000000000000; // wei cinsinden 1 ETH
const double = balance * 2;
console.log(double); // 2000000000000000000 — doğru görünüyor ama...
 
const largeBalance = 99999999999999999999; // ~100 ETH
console.log(largeBalance);          // 100000000000000000000 — YANLIŞ! Yukarı yuvarlanmış.
console.log(largeBalance === 100000000000000000000); // true — veri bozulması
 
// DOĞRU — BigInt kullan
const balance = 1000000000000000000n;
const double = balance * 2n;
console.log(double.toString()); // "2000000000000000000" — doğru
 
const largeBalance = 99999999999999999999n;
console.log(largeBalance.toString()); // "99999999999999999999" — doğru

import { formatUnits, parseUnits } from "viem";
 
// Görüntüleme: BigInt → okunabilir string
const weiAmount = 1500000000000000000n; // 1.5 ETH
const display = formatUnits(weiAmount, 18); // "1.5"
 
// Girdi: okunabilir string → BigInt
const userInput = "1.5";
const wei = parseUnits(userInput, 18); // 1500000000000000000n
 
// USDC'nin 6 ondalığı var, 18 değil
const usdcAmount = 100000000n; // 100 USDC
const usdcDisplay = formatUnits(usdcAmount, 6); // "100.0"

// Kullanıcı herhangi bir cüzdan istemini reddedebilir
try {
  const tx = await writeContract({
    address: contractAddress,
    abi: ERC20_ABI,
    functionName: "approve",
    args: [spenderAddress, amount],
  });
} catch (error) {
  if (error.code === 4001) {
    // Kullanıcı cüzdanındaki transaction'ı reddetti
    // Bu normal — raporlanacak bir hata değil
    showToast("Transaction iptal edildi");
  } else if (error.code === -32603) {
    // Dahili JSON-RPC hatası — genellikle transaction'ın revert olacağı anlamına gelir
    showToast("Transaction başarısız olur. Bakiyenizi kontrol edin.");
  } else {
    // Beklenmeyen hata
    console.error("Transaction hatası:", error);
    showToast("Bir şeyler ters gitti. Lütfen tekrar deneyin.");
  }
}

// Savunmacı zincir kontrolü
import { useAccount, useChainId } from "wagmi";
 
function useRequireChain(requiredChainId: number) {
  const chainId = useChainId();
  const { isConnected } = useAccount();
 
  if (!isConnected) {
    return { ready: false, error: "Lütfen cüzdanınızı bağlayın" };
  }
 
  if (chainId !== requiredChainId) {
    return {
      ready: false,
      error: `Lütfen ${getChainName(requiredChainId)} ağına geçin. Şu anda ${getChainName(chainId)} ağındasınız.`,
    };
  }
 
  return { ready: true, error: null };
}

// Uniswap tarzı swap'ta slippage toleransı ayarlama
const amountOutMin = expectedOutput * 995n / 1000n; // %0,5 slippage toleransı
 
// Uzun ömürlü bekleyen transaction'ları önlemek için deadline kullanma
const deadline = BigInt(Math.floor(Date.now() / 1000) + 60 * 20); // 20 dakika
 
await router.swapExactTokensForTokens(
  amountIn,
  amountOutMin,  // Kabul edilebilir minimum çıktı — daha az alırsak revert et
  [tokenA, tokenB],
  userAddress,
  deadline,       // 20 dakika içinde çalıştırılmazsa revert et
);

// RPC endpoint olarak Flashbots Protect kullanma
const provider = new ethers.JsonRpcProvider("https://rpc.flashbots.net");

async function formatTokenAmount(
  tokenAddress: string,
  rawAmount: bigint,
  provider: ethers.Provider
): Promise<string> {
  const contract = new ethers.Contract(
    tokenAddress,
    ["function decimals() view returns (uint8)", "function symbol() view returns (string)"],
    provider
  );
 
  const [decimals, symbol] = await Promise.all([
    contract.decimals(),
    contract.symbol(),
  ]);
 
  return `${ethers.formatUnits(rawAmount, decimals)} ${symbol}`;
}
 
// formatTokenAmount(USDC, 1000000n, provider) → "1.0 USDC"
// formatTokenAmount(WETH, 1000000000000000000n, provider) → "1.0 WETH"
// formatTokenAmount(WBTC, 100000000n, provider) → "1.0 WBTC"

import { createPublicClient, http, decodeFunctionResult } from "viem";
 
async function simulateAndGetError(client: ReturnType<typeof createPublicClient>, tx: object) {
  try {
    await client.call({
      account: tx.from,
      to: tx.to,
      data: tx.data,
      value: tx.value,
    });
    return null; // Hata yok — transaction başarılı olur
  } catch (error) {
    // Revert nedenini decode et
    if (error.data) {
      // Yaygın revert string'leri
      if (error.data.startsWith("0x08c379a0")) {
        // Error(string) — mesajlı standart revert
        const reason = decodeAbiParameters(
          [{ type: "string" }],
          `0x${error.data.slice(10)}`
        );
        return `Revert: ${reason[0]}`;
      }
    }
    return error.message;
  }
}

"use client";
 
import { useAccount, useConnect, useDisconnect, useReadContract, useWriteContract, useWaitForTransactionReceipt } from "wagmi";
import { injected } from "wagmi/connectors";
import { formatUnits, parseUnits } from "viem";
import { useState } from "react";
 
const USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
 
const USDC_ABI = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "account", type: "address" }],
    outputs: [{ name: "", type: "uint256" }],
  },
  {
    name: "transfer",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    outputs: [{ name: "", type: "bool" }],
  },
] as const;
 
export function TokenDashboard() {
  const { address, isConnected } = useAccount();
  const { connect } = useConnect();
  const { disconnect } = useDisconnect();
 
  const [recipient, setRecipient] = useState("");
  const [amount, setAmount] = useState("");
 
  // Bakiye oku — sadece address tanımlıyken çalışır
  const { data: balance, refetch: refetchBalance } = useReadContract({
    address: USDC_ADDRESS,
    abi: USDC_ABI,
    functionName: "balanceOf",
    args: address ? [address] : undefined,
    query: { enabled: !!address },
  });
 
  // Yazma: token transfer et
  const {
    writeContract,
    data: txHash,
    isPending: isSigning,
    error: writeError,
  } = useWriteContract();
 
  // Onay bekle
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({
    hash: txHash,
  });
 
  // Onaydan sonra bakiyeyi yeniden getir
  if (isSuccess) {
    refetchBalance();
  }
 
  if (!isConnected) {
    return (
      <button onClick={() => connect({ connector: injected() })}>
        Cüzdan Bağla
      </button>
    );
  }
 
  return (
    <div>
      <p>Bağlı: {address}</p>
      <p>
        USDC Bakiye:{" "}
        {balance !== undefined ? formatUnits(balance, 6) : "Yükleniyor..."}
      </p>
 
      <div>
        <input
          placeholder="Alıcı adresi (0x...)"
          value={recipient}
          onChange={(e) => setRecipient(e.target.value)}
        />
        <input
          placeholder="Miktar (ör. 100)"
          value={amount}
          onChange={(e) => setAmount(e.target.value)}
        />
        <button
          onClick={() => {
            writeContract({
              address: USDC_ADDRESS,
              abi: USDC_ABI,
              functionName: "transfer",
              args: [recipient as `0x${string}`, parseUnits(amount, 6)],
            });
          }}
          disabled={isSigning || isConfirming}
        >
          {isSigning
            ? "Cüzdanda onaylayın..."
            : isConfirming
              ? "Onaylanıyor..."
              : "USDC Gönder"}
        </button>
      </div>
 
      {writeError && <p style={{ color: "red" }}>{writeError.message}</p>}
      {isSuccess && <p style={{ color: "green" }}>Transfer onaylandı!</p>}
      {txHash && (
        <a
          href={`https://etherscan.io/tx/${txHash}`}
          target="_blank"
          rel="noopener noreferrer"
        >
          Etherscan'de Görüntüle
        </a>
      )}
 
      <button onClick={() => disconnect()}>Bağlantıyı Kes</button>
    </div>
  );
}