Ethereum لمطوري الويب: العقود الذكية بدون الضجة

interface Transaction {
  // من يستقبل هذه المعاملة — عنوان EOA أو عنوان عقد
  to: string;      // عنوان hex من 20 بايت، أو null لنشر العقود
  // كمية ETH للإرسال (بالـ wei)
  value: bigint;   // يمكن أن تكون 0n لاستدعاءات العقود الصرفة
  // بيانات استدعاء الدالة المرمّزة، أو فارغة لتحويلات ETH البسيطة
  data: string;    // بايتات مرمّزة بـ hex، "0x" للتحويلات البسيطة
  // عدّاد تسلسلي، يمنع هجمات الإعادة
  nonce: number;   // يجب أن يساوي بالضبط nonce المرسل الحالي
  // حد Gas — الحد الأقصى لـ gas يمكن أن تستهلكه هذه المعاملة
  gasLimit: bigint;
  // معاملات رسوم EIP-1559
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  // معرّف السلسلة (1 = الشبكة الرئيسية، 11155111 = Sepolia، 137 = Polygon)
  chainId: number;
}

import { ethers } from "ethers";
 
const provider = new ethers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
const wallet = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);
 
const tx = await wallet.sendTransaction({
  to: "0xRecipientAddress...",
  value: ethers.parseEther("0.1"), // يحوّل "0.1" إلى wei (100000000000000000n)
});
 
console.log("Tx hash:", tx.hash);
 
// انتظر الإدراج في كتلة
const receipt = await tx.wait();
console.log("Block number:", receipt.blockNumber);
console.log("Gas used:", receipt.gasUsed.toString());
console.log("Status:", receipt.status); // 1 = نجاح، 0 = إعادة

import { createWalletClient, http, parseEther } from "viem";
import { mainnet } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
 
const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");
 
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"),
});
 
const hash = await client.sendTransaction({
  to: "0xRecipientAddress...",
  value: parseEther("0.1"),
});
 
console.log("Tx hash:", hash);

const ERC20_ABI = [
  // دوال للقراءة فقط (view/pure — بدون تكلفة gas عند الاستدعاء الخارجي)
  "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 allowance(address owner, address spender) view returns (uint256)",
 
  // دوال تغيير الحالة (تتطلب معاملة، تكلف gas)
  "function transfer(address to, uint256 amount) returns (bool)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "function transferFrom(address from, address to, uint256 amount) returns (bool)",
 
  // الأحداث (تُصدر أثناء التنفيذ، تُخزن في سجلات المعاملات)
  "event Transfer(address indexed from, address indexed to, uint256 value)",
  "event Approval(address indexed owner, address indexed spender, uint256 value)",
] as const;

import { ethers } from "ethers";
 
const iface = new ethers.Interface(ERC20_ABI);
 
// ترميز استدعاء دالة
const calldata = iface.encodeFunctionData("transfer", [
  "0xBobAddress...",
  1000000n,
]);
console.log(calldata);
// 0xa9059cbb000000000000000000000000bob...000000000000000000000000000f4240
 
// فك رموز calldata إلى اسم الدالة والمعاملات
const decoded = iface.parseTransaction({ data: calldata });
console.log(decoded.name);       // "transfer"
console.log(decoded.args[0]);    // "0xBobAddress..."
console.log(decoded.args[1]);    // 1000000n (BigInt)
 
// فك رموز بيانات إرجاع الدالة
const returnData = "0x0000000000000000000000000000000000000000000000000000000000000001";
const result = iface.decodeFunctionResult("transfer", returnData);
console.log(result[0]); // true

// قراءة فتحة التخزين 0 لعقد
const slot0 = await provider.getStorage(
  "0xContractAddress...",
  0
);
console.log(slot0); // قيمة hex خام من 32 بايت

// الاستماع لأحداث Transfer في الوقت الحقيقي مع ethers.js
const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
 
contract.on("Transfer", (from, to, value, event) => {
  console.log(`${from} -> ${to}: ${ethers.formatUnits(value, 18)} tokens`);
  console.log("Block:", event.log.blockNumber);
  console.log("Tx hash:", event.log.transactionHash);
});
 
// الاستعلام عن الأحداث التاريخية
const filter = contract.filters.Transfer(null, "0xMyAddress..."); // من=أي، إلى=محدد
const events = await contract.queryFilter(filter, 19000000, 19100000); // نطاق الكتل
 
for (const event of events) {
  console.log("From:", event.args.from);
  console.log("Value:", event.args.value.toString());
}

import { createPublicClient, http, parseAbiItem } from "viem";
import { mainnet } from "viem/chains";
 
const client = createPublicClient({
  chain: mainnet,
  transport: http("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"),
});
 
// السجلات التاريخية
const logs = await client.getLogs({
  address: "0xTokenAddress...",
  event: parseAbiItem(
    "event Transfer(address indexed from, address indexed to, uint256 value)"
  ),
  args: {
    to: "0xMyAddress...",
  },
  fromBlock: 19000000n,
  toBlock: 19100000n,
});
 
for (const log of logs) {
  console.log("From:", log.args.from);
  console.log("To:", log.args.to);
  console.log("Value:", log.args.value);
}
 
// المراقبة في الوقت الحقيقي
const unwatch = client.watchEvent({
  address: "0xTokenAddress...",
  event: parseAbiItem(
    "event Transfer(address indexed from, address indexed to, uint256 value)"
  ),
  onLogs: (logs) => {
    for (const log of logs) {
      console.log(`Transfer: ${log.args.from} -> ${log.args.to}`);
    }
  },
});
 
// استدعِ unwatch() لإيقاف الاستماع

// هذا ما تفعله مكتبتك خلف الكواليس
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: "eth_call",
    params: [
      {
        to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
        data: "0x70a08231000000000000000000000000d8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
        // balanceOf(vitalik.eth)
      },
      "latest",
    ],
  }),
});
 
const result = await response.json();
console.log(result);
// { jsonrpc: "2.0", id: 1, result: "0x000000000000000000000000000000000000000000000000000000174876e800" }

import { ethers } from "ethers";
 
// مزود احتياطي ethers.js v6
const provider = new ethers.FallbackProvider([
  {
    provider: new ethers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/KEY1"),
    priority: 1,
    stallTimeout: 2000,
    weight: 2,
  },
  {
    provider: new ethers.JsonRpcProvider("https://mainnet.infura.io/v3/KEY2"),
    priority: 2,
    stallTimeout: 2000,
    weight: 1,
  },
]);

import { ethers } from "ethers";
 
const provider = new ethers.JsonRpcProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
 
// واجهة ERC-20 — فقط دوال القراءة
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 // ملاحظة: provider، وليس signer. قراءة فقط.
);
 
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!)
console.log(`Total supply: ${ethers.formatUnits(totalSupply, decimals)}`);
 
// التحقق من رصيد عنوان محدد
const balance = await erc20.balanceOf("0xSomeAddress...");
console.log(`Balance: ${ethers.formatUnits(balance, decimals)} USDC`);

import { ethers } from "ethers";
 
// الاتصال بعقدة
const provider = new ethers.JsonRpcProvider("https://...");
 
// استعلامات أساسية
const blockNumber = await provider.getBlockNumber();
const balance = await provider.getBalance("0xAddress...");
const block = await provider.getBlock(blockNumber);
const txCount = await provider.getTransactionCount("0xAddress...");

// من مفتاح خاص (جانب الخادم، السكربتات)
const wallet = new ethers.Wallet("0xPrivateKey...", provider);
 
// من محفظة المتصفح (جانب العميل)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();
 
// الحصول على العنوان
const address = await signer.getAddress();

const usdc = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, provider);
 
// قراءة (مجانية، تُرجع القيمة مباشرة)
const balance = await usdc.balanceOf("0xSomeAddress...");
// balance هو bigint: 1000000000n (1000 USDC مع 6 أعشار)
 
// للكتابة، اتصل بـ signer
const usdcWithSigner = usdc.connect(signer);
 
// كتابة (تكلف gas، تُرجع TransactionResponse)
const tx = await usdcWithSigner.transfer("0xRecipient...", 1000000n);
const receipt = await tx.wait(); // انتظر الإدراج في كتلة
 
if (receipt.status === 0) {
  throw new Error("المعاملة عادت");
}

// بدون TypeChain — لا فحص أنواع
const balance = await contract.balanceOf("0x...");
// balance هو 'any'. لا إكمال تلقائي. سهل الاستخدام الخاطئ.
 
// مع TypeChain — أمان أنواع كامل
import { USDC__factory } from "./typechain";
 
const usdc = USDC__factory.connect(USDC_ADDRESS, provider);
const balance = await usdc.balanceOf("0x...");
// balance هو BigNumber. الإكمال التلقائي يعمل. أخطاء الأنواع تُلتقط وقت التجميع.

// 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);
 
// الاستماع لكل أحداث Transfer
contract.on("Transfer", (from, to, value, event) => {
  console.log(`Transfer: ${from} -> ${to}`);
  console.log(`Amount: ${ethers.formatUnits(value, 6)} USDC`);
});
 
// الاستماع للتحويلات إلى عنوان محدد
const filter = contract.filters.Transfer(null, "0xMyAddress...");
contract.on(filter, (from, to, value) => {
  console.log(`تحويل وارد: ${ethers.formatUnits(value, 6)} USDC من ${from}`);
});
 
// التنظيف عند الانتهاء
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>جاري التحميل...</span>;
  if (error) return <span>خطأ: {error.message}</span>;
 
  // balance مُنمّط كـ bigint لأن ABI يقول uint256
  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 ? "تأكيد في المحفظة..." : "إرسال 100 USDC"}
      </button>
 
      {hash && <p>المعاملة: {hash}</p>}
      {isConfirming && <p>في انتظار التأكيد...</p>}
      {isSuccess && <p>تم تأكيد التحويل!</p>}
      {error && <p>خطأ: {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;
}

// تفاعل محفظة منخفض المستوى (لا يجب فعل هذا مباشرة، لكنه مفيد للفهم)
 
// طلب الوصول للحساب
const accounts = await window.ethereum.request({
  method: "eth_requestAccounts",
});
console.log("العنوان المتصل:", accounts[0]);
 
// الحصول على السلسلة الحالية
const chainId = await window.ethereum.request({
  method: "eth_chainId",
});
console.log("Chain ID:", parseInt(chainId, 16)); // "0x1" -> 1 (الشبكة الرئيسية)
 
// الاستماع لتغييرات الحساب (المستخدم يبدل الحسابات في MetaMask)
window.ethereum.on("accountsChanged", (accounts: string[]) => {
  if (accounts.length === 0) {
    console.log("المحفظة منقطعة");
  } else {
    console.log("تبديل إلى:", accounts[0]);
  }
});
 
// الاستماع لتغييرات السلسلة (المستخدم يبدل الشبكات)
window.ethereum.on("chainChanged", (chainId: string) => {
  // النهج الموصى به هو إعادة تحميل الصفحة
  window.location.reload();
});

// اكتشاف كل المحافظ المتاحة
interface EIP6963ProviderDetail {
  info: {
    uuid: string;
    name: string;
    icon: string;
    rdns: string;  // اسم النطاق العكسي، مثل "io.metamask"
  };
  provider: EIP1193Provider;
}
 
const wallets: EIP6963ProviderDetail[] = [];
 
window.addEventListener("eip6963:announceProvider", (event: CustomEvent) => {
  wallets.push(event.detail);
});
 
// طلب كل المحافظ للإعلان عن نفسها
window.dispatchEvent(new Event("eip6963:requestProvider"));
 
// الآن 'wallets' يحتوي كل المحافظ المثبتة بأسمائها وأيقوناتها
// يمكنك عرض واجهة اختيار محفظة

import { walletConnect } from "wagmi/connectors";
 
const connector = walletConnect({
  projectId: "YOUR_PROJECT_ID", // احصل عليه من cloud.walletconnect.com
  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>يرجى ربط محفظتك</p>;
 
  if (chain.id !== mainnet.id) {
    return (
      <div>
        <p>يرجى التبديل إلى Ethereum Mainnet</p>
        <button
          onClick={() => switchChain({ chainId: mainnet.id })}
          disabled={isPending}
        >
          {isPending ? "جاري التبديل..." : "تبديل الشبكة"}
        </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}`;
    // أو استخدم بوابة مخصصة:
    // return `https://YOUR_PROJECT.mypinata.cloud/ipfs/${cid}`;
  }
  return uri;
}
 
// جلب بيانات NFT الوصفية
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
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
}

# مخطط Subgraph (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")
}

// الاستعلام من subgraph في الواجهة الأمامية
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: الحصول على كل أرصدة رموز ERC-20 لعنوان
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"],
    }),
  }
);
 
// يُرجع كل أرصدة رموز ERC-20 في استدعاء واحد
// مقابل مسح balanceOf() لكل عقد ERC-20 ممكن

// Alchemy: الحصول على كل NFTs المملوكة لعنوان
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}`);
}

// خطأ — فقدان دقة صامت
const balance = 1000000000000000000; // 1 ETH بالـ wei
const double = balance * 2;
console.log(double); // 2000000000000000000 — يبدو صحيحاً، لكن...
 
const largeBalance = 99999999999999999999; // ~100 ETH
console.log(largeBalance);          // 100000000000000000000 — خطأ! مُقرّب لأعلى.
console.log(largeBalance === 100000000000000000000); // true — فساد بيانات
 
// صحيح — استخدم BigInt
const balance = 1000000000000000000n;
const double = balance * 2n;
console.log(double.toString()); // "2000000000000000000" — صحيح
 
const largeBalance = 99999999999999999999n;
console.log(largeBalance.toString()); // "99999999999999999999" — صحيح

import { formatUnits, parseUnits } from "viem";
 
// العرض: BigInt → نص مقروء
const weiAmount = 1500000000000000000n; // 1.5 ETH
const display = formatUnits(weiAmount, 18); // "1.5"
 
// الإدخال: نص مقروء → BigInt
const userInput = "1.5";
const wei = parseUnits(userInput, 18); // 1500000000000000000n
 
// USDC لديها 6 أعشار، وليس 18
const usdcAmount = 100000000n; // 100 USDC
const usdcDisplay = formatUnits(usdcAmount, 6); // "100.0"

// المستخدم يمكنه رفض أي طلب محفظة
try {
  const tx = await writeContract({
    address: contractAddress,
    abi: ERC20_ABI,
    functionName: "approve",
    args: [spenderAddress, amount],
  });
} catch (error) {
  if (error.code === 4001) {
    // المستخدم رفض المعاملة في محفظته
    // هذا طبيعي — ليس خطأ يجب الإبلاغ عنه
    showToast("المعاملة ملغاة");
  } else if (error.code === -32603) {
    // خطأ JSON-RPC داخلي — غالباً يعني أن المعاملة ستعود
    showToast("المعاملة ستفشل. تحقق من رصيدك.");
  } else {
    // خطأ غير متوقع
    console.error("خطأ معاملة:", error);
    showToast("حدث خطأ. يرجى المحاولة مرة أخرى.");
  }
}

// فحص دفاعي للسلسلة
import { useAccount, useChainId } from "wagmi";
 
function useRequireChain(requiredChainId: number) {
  const chainId = useChainId();
  const { isConnected } = useAccount();
 
  if (!isConnected) {
    return { ready: false, error: "يرجى ربط محفظتك" };
  }
 
  if (chainId !== requiredChainId) {
    return {
      ready: false,
      error: `يرجى التبديل إلى ${getChainName(requiredChainId)}. أنت على ${getChainName(chainId)}.`,
    };
  }
 
  return { ready: true, error: null };
}

// ضبط تسامح الانزلاق على مبادلة بنمط Uniswap
const amountOutMin = expectedOutput * 995n / 1000n; // 0.5% تسامح انزلاق
 
// استخدام موعد نهائي لمنع المعاملات المعلقة طويلة العمر
const deadline = BigInt(Math.floor(Date.now() / 1000) + 60 * 20); // 20 دقيقة
 
await router.swapExactTokensForTokens(
  amountIn,
  amountOutMin,  // الحد الأدنى المقبول للمخرجات — يعود إذا حصلنا على أقل
  [tokenA, tokenB],
  userAddress,
  deadline,       // يعود إذا لم يُنفذ خلال 20 دقيقة
);

// استخدام Flashbots Protect كنقطة نهاية RPC
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; // لا خطأ — المعاملة ستنجح
  } catch (error) {
    // فك رموز سبب الإعادة
    if (error.data) {
      // نصوص الإعادة الشائعة
      if (error.data.startsWith("0x08c379a0")) {
        // Error(string) — إعادة قياسية مع رسالة
        const reason = decodeAbiParameters(
          [{ type: "string" }],
          `0x${error.data.slice(10)}`
        );
        return `إعادة: ${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("");
 
  // قراءة الرصيد — يعمل فقط عند تعريف العنوان
  const { data: balance, refetch: refetchBalance } = useReadContract({
    address: USDC_ADDRESS,
    abi: USDC_ABI,
    functionName: "balanceOf",
    args: address ? [address] : undefined,
    query: { enabled: !!address },
  });
 
  // كتابة: تحويل الرموز
  const {
    writeContract,
    data: txHash,
    isPending: isSigning,
    error: writeError,
  } = useWriteContract();
 
  // انتظار التأكيد
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({
    hash: txHash,
  });
 
  // إعادة جلب الرصيد بعد التأكيد
  if (isSuccess) {
    refetchBalance();
  }
 
  if (!isConnected) {
    return (
      <button onClick={() => connect({ connector: injected() })}>
        ربط المحفظة
      </button>
    );
  }
 
  return (
    <div>
      <p>متصل: {address}</p>
      <p>
        رصيد USDC:{" "}
        {balance !== undefined ? formatUnits(balance, 6) : "جاري التحميل..."}
      </p>
 
      <div>
        <input
          placeholder="عنوان المستلم (0x...)"
          value={recipient}
          onChange={(e) => setRecipient(e.target.value)}
        />
        <input
          placeholder="المبلغ (مثل 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
            ? "تأكيد في المحفظة..."
            : isConfirming
              ? "جاري التأكيد..."
              : "إرسال USDC"}
        </button>
      </div>
 
      {writeError && <p style={{ color: "red" }}>{writeError.message}</p>}
      {isSuccess && <p style={{ color: "green" }}>تم تأكيد التحويل!</p>}
      {txHash && (
        <a
          href={`https://etherscan.io/tx/${txHash}`}
          target="_blank"
          rel="noopener noreferrer"
        >
          عرض على Etherscan
        </a>
      )}
 
      <button onClick={() => disconnect()}>قطع الاتصال</button>
    </div>
  );
}