Ethereum для веб-разработчиков: смарт-контракты без хайпа

interface Transaction {
  // Кто получает эту транзакцию — адрес EOA или адрес контракта
  to: string;      // 20-байтовый hex-адрес, или null для деплоя контракта
  // Сколько ETH отправить (в wei)
  value: bigint;   // Может быть 0n для чистых вызовов контракта
  // Закодированные данные вызова функции, или пусто для простых переводов ETH
  data: string;    // Hex-кодированные байты, "0x" для простых переводов
  // Последовательный счётчик, предотвращает атаки повторного воспроизведения
  nonce: number;   // Должен точно совпадать с текущим nonce отправителя
  // Лимит газа — максимальный gas, который может потребить эта транзакция
  gasLimit: bigint;
  // Параметры комиссий EIP-1559
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  // Идентификатор цепочки (1 = mainnet, 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);
 
// Ожидаем включения в блок
const receipt = await tx.wait();
console.log("Номер блока:", receipt.blockNumber);
console.log("Потрачено gas:", receipt.gasUsed.toString());
console.log("Статус:", 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("Хеш транзакции:", hash);

const ERC20_ABI = [
  // Read-only функции (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); // Сырое 32-байтовое hex-значение

// Подписка на события 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)} токенов`);
  console.log("Блок:", event.log.blockNumber);
  console.log("Хеш транзакции:", event.log.transactionHash);
});
 
// Запрос исторических событий
const filter = contract.filters.Transfer(null, "0xMyAddress..."); // from=любой, to=конкретный
const events = await contract.queryFilter(filter, 19000000, 19100000); // диапазон блоков
 
for (const event of events) {
  console.log("От:", event.args.from);
  console.log("Сумма:", 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("От:", log.args.from);
  console.log("Кому:", log.args.to);
  console.log("Сумма:", 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(`Перевод: ${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";
 
// Fallback-провайдер 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}`);          // 6 (НЕ 18!)
console.log(`Общее предложение: ${ethers.formatUnits(totalSupply, decimals)}`);
 
// Проверяем баланс конкретного адреса
const balance = await erc20.balanceOf("0xSomeAddress...");
console.log(`Баланс: ${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(`Перевод: ${from} -> ${to}`);
  console.log(`Сумма: ${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 (mainnet)
 
// Подписка на смену аккаунта (пользователь переключает аккаунт в 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' содержит все установленные кошельки с их именами и иконками
// Можно показать UI выбора кошелька

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": "Очень крутой 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
}

# Схема субграфа (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")
}

// Запрос к субграфу из фронтенда
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 токенов в одном вызове
// vs. сканирование balanceOf() каждого возможного ERC-20 контракта

// Alchemy: получить все NFT, принадлежащие адресу
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("");
 
  // Чтение баланса — выполняется только когда address определён
  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>
  );
}