Ethereum per sviluppatori web: smart contract senza l'hype

interface Transaction {
  // Chi riceve questa transazione — un indirizzo EOA o un indirizzo contratto
  to: string;      // indirizzo hex a 20 byte, o null per il deploy di contratti
  // Quanti ETH inviare (in wei)
  value: bigint;   // Può essere 0n per chiamate pure a contratti
  // Dati di chiamata funzione codificati, o vuoto per semplici trasferimenti ETH
  data: string;    // Byte codificati in hex, "0x" per trasferimenti semplici
  // Contatore sequenziale, previene attacchi replay
  nonce: number;   // Deve essere esattamente uguale al nonce attuale del mittente
  // Limite gas — gas massimo che questa tx può consumare
  gasLimit: bigint;
  // Parametri commissione EIP-1559
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  // Identificatore della chain (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"), // Converte "0.1" in wei (100000000000000000n)
});
 
console.log("Hash tx:", tx.hash);
 
// Attendi l'inclusione in un blocco
const receipt = await tx.wait();
console.log("Numero blocco:", receipt.blockNumber);
console.log("Gas usato:", receipt.gasUsed.toString());
console.log("Stato:", receipt.status); // 1 = successo, 0 = revert

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 tx:", hash);

const ERC20_ABI = [
  // Funzioni di sola lettura (view/pure — nessun costo di gas quando chiamate esternamente)
  "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)",
 
  // Funzioni che cambiano stato (richiedono una transazione, costano 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)",
 
  // Eventi (emessi durante l'esecuzione, memorizzati nei log della transazione)
  "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);
 
// Codifica una chiamata di funzione
const calldata = iface.encodeFunctionData("transfer", [
  "0xBobAddress...",
  1000000n,
]);
console.log(calldata);
// 0xa9059cbb000000000000000000000000bob...000000000000000000000000000f4240
 
// Decodifica calldata di nuovo in nome funzione e argomenti
const decoded = iface.parseTransaction({ data: calldata });
console.log(decoded.name);       // "transfer"
console.log(decoded.args[0]);    // "0xBobAddress..."
console.log(decoded.args[1]);    // 1000000n (BigInt)
 
// Decodifica i dati di ritorno di una funzione
const returnData = "0x0000000000000000000000000000000000000000000000000000000000000001";
const result = iface.decodeFunctionResult("transfer", returnData);
console.log(result[0]); // true

// Lettura dello storage slot 0 di un contratto
const slot0 = await provider.getStorage(
  "0xContractAddress...",
  0
);
console.log(slot0); // Valore hex grezzo da 32 byte

// Ascolto di eventi Transfer in tempo reale con 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)} token`);
  console.log("Blocco:", event.log.blockNumber);
  console.log("Hash tx:", event.log.transactionHash);
});
 
// Interrogazione di eventi storici
const filter = contract.filters.Transfer(null, "0xMyAddress..."); // from=qualsiasi, to=specifico
const events = await contract.queryFilter(filter, 19000000, 19100000); // intervallo di blocchi
 
for (const event of events) {
  console.log("Da:", event.args.from);
  console.log("Valore:", 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"),
});
 
// Log storici
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("Da:", log.args.from);
  console.log("A:", log.args.to);
  console.log("Valore:", log.args.value);
}
 
// Monitoraggio in tempo reale
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(`Trasferimento: ${log.args.from} -> ${log.args.to}`);
    }
  },
});
 
// Chiama unwatch() per smettere di ascoltare

// Questo è ciò che la tua libreria fa sotto il cofano
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 fallback provider
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");
 
// Interfaccia ERC-20 — solo le funzioni di lettura
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 // Nota: provider, non signer. Sola lettura.
);
 
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(`Decimali: ${decimals}`);          // 6 (NON 18!)
console.log(`Offerta totale: ${ethers.formatUnits(totalSupply, decimals)}`);
 
// Controlla il saldo di un indirizzo specifico
const balance = await erc20.balanceOf("0xSomeAddress...");
console.log(`Saldo: ${ethers.formatUnits(balance, decimals)} USDC`);

import { ethers } from "ethers";
 
// Connettiti a un nodo
const provider = new ethers.JsonRpcProvider("https://...");
 
// Query base
const blockNumber = await provider.getBlockNumber();
const balance = await provider.getBalance("0xAddress...");
const block = await provider.getBlock(blockNumber);
const txCount = await provider.getTransactionCount("0xAddress...");

// Da una chiave privata (lato server, script)
const wallet = new ethers.Wallet("0xPrivateKey...", provider);
 
// Da un wallet del browser (lato client)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();
 
// Ottieni l'indirizzo
const address = await signer.getAddress();

const usdc = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, provider);
 
// Lettura (gratuita, restituisce il valore direttamente)
const balance = await usdc.balanceOf("0xSomeAddress...");
// balance è un bigint: 1000000000n (1000 USDC con 6 decimali)
 
// Per scrivere, connettiti con un signer
const usdcWithSigner = usdc.connect(signer);
 
// Scrittura (costa gas, restituisce TransactionResponse)
const tx = await usdcWithSigner.transfer("0xRecipient...", 1000000n);
const receipt = await tx.wait(); // Attendi l'inclusione nel blocco
 
if (receipt.status === 0) {
  throw new Error("Transazione revertita");
}

// Senza TypeChain — nessun controllo dei tipi
const balance = await contract.balanceOf("0x...");
// balance è 'any'. Nessun autocomplete. Facile da usare male.
 
// Con TypeChain — piena sicurezza dei tipi
import { USDC__factory } from "./typechain";
 
const usdc = USDC__factory.connect(USDC_ADDRESS, provider);
const balance = await usdc.balanceOf("0x...");
// balance è BigNumber. L'autocomplete funziona. Errori di tipo catturati a compile time.

// WebSocket per eventi in tempo reale
const wsProvider = new ethers.WebSocketProvider("wss://eth-mainnet.g.alchemy.com/v2/YOUR_KEY");
 
const contract = new ethers.Contract(USDC_ADDRESS, ERC20_ABI, wsProvider);
 
// Ascolta tutti gli eventi Transfer
contract.on("Transfer", (from, to, value, event) => {
  console.log(`Trasferimento: ${from} -> ${to}`);
  console.log(`Importo: ${ethers.formatUnits(value, 6)} USDC`);
});
 
// Ascolta trasferimenti VERSO un indirizzo specifico
const filter = contract.filters.Transfer(null, "0xMyAddress...");
contract.on(filter, (from, to, value) => {
  console.log(`Trasferimento in arrivo: ${ethers.formatUnits(value, 6)} USDC da ${from}`);
});
 
// Pulizia quando hai finito
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>Caricamento...</span>;
  if (error) return <span>Errore: {error.message}</span>;
 
  // balance è tipizzato come bigint perché l'ABI dice 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 ? "Conferma nel wallet..." : "Invia 100 USDC"}
      </button>
 
      {hash && <p>Transazione: {hash}</p>}
      {isConfirming && <p>In attesa di conferma...</p>}
      {isSuccess && <p>Trasferimento confermato!</p>}
      {error && <p>Errore: {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;
}

// Interazione a basso livello con il wallet (non dovresti farlo direttamente, ma è utile da capire)
 
// Richiedi accesso all'account
const accounts = await window.ethereum.request({
  method: "eth_requestAccounts",
});
console.log("Indirizzo connesso:", accounts[0]);
 
// Ottieni la chain corrente
const chainId = await window.ethereum.request({
  method: "eth_chainId",
});
console.log("Chain ID:", parseInt(chainId, 16)); // "0x1" -> 1 (mainnet)
 
// Ascolta i cambi di account (l'utente cambia account in MetaMask)
window.ethereum.on("accountsChanged", (accounts: string[]) => {
  if (accounts.length === 0) {
    console.log("Wallet disconnesso");
  } else {
    console.log("Passato a:", accounts[0]);
  }
});
 
// Ascolta i cambi di chain (l'utente cambia rete)
window.ethereum.on("chainChanged", (chainId: string) => {
  // L'approccio raccomandato è ricaricare la pagina
  window.location.reload();
});

// Scoperta di tutti i wallet disponibili
interface EIP6963ProviderDetail {
  info: {
    uuid: string;
    name: string;
    icon: string;
    rdns: string;  // Nome di dominio inverso, es. "io.metamask"
  };
  provider: EIP1193Provider;
}
 
const wallets: EIP6963ProviderDetail[] = [];
 
window.addEventListener("eip6963:announceProvider", (event: CustomEvent) => {
  wallets.push(event.detail);
});
 
// Richiedi a tutti i wallet di annunciarsi
window.dispatchEvent(new Event("eip6963:requestProvider"));
 
// Ora 'wallets' contiene tutti i wallet installati con nomi e icone
// Puoi mostrare una UI di selezione wallet

import { walletConnect } from "wagmi/connectors";
 
const connector = walletConnect({
  projectId: "YOUR_PROJECT_ID", // Ottienilo da 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>Per favore connetti il tuo wallet</p>;
 
  if (chain.id !== mainnet.id) {
    return (
      <div>
        <p>Per favore passa a Ethereum Mainnet</p>
        <button
          onClick={() => switchChain({ chainId: mainnet.id })}
          disabled={isPending}
        >
          {isPending ? "Cambio in corso..." : "Cambia rete"}
        </button>
      </div>
    );
  }
 
  return <>{children}</>;
}

{
  "name": "Cool NFT #42",
  "description": "Un NFT molto cool",
  "image": "ipfs://QmImageHash...",
  "attributes": [
    { "trait_type": "Sfondo", "value": "Blu" },
    { "trait_type": "Rarità", "value": "Leggendario" }
  ]
}

function ipfsToHttp(uri: string): string {
  if (uri.startsWith("ipfs://")) {
    const cid = uri.replace("ipfs://", "");
    return `https://ipfs.io/ipfs/${cid}`;
    // Oppure usa un gateway dedicato:
    // return `https://YOUR_PROJECT.mypinata.cloud/ipfs/${cid}`;
  }
  return uri;
}
 
// Recupero dei metadati 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,
  };
}

// Upload su 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}`; // Restituisce CID
}

# Schema 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")
}

// Interrogazione di un subgraph dal tuo frontend
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: Ottieni tutti i saldi dei token ERC-20 per un indirizzo
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"],
    }),
  }
);
 
// Restituisce TUTTI i saldi dei token ERC-20 in una sola chiamata
// vs. scansionare il balanceOf() di ogni possibile contratto ERC-20

// Alchemy: Ottieni tutti gli NFT posseduti da un indirizzo
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}`);
}

// SBAGLIATO — perdita di precisione silenziosa
const balance = 1000000000000000000; // 1 ETH in wei
const double = balance * 2;
console.log(double); // 2000000000000000000 — sembra giusto, ma...
 
const largeBalance = 99999999999999999999; // ~100 ETH
console.log(largeBalance);          // 100000000000000000000 — SBAGLIATO! Arrotondato per eccesso.
console.log(largeBalance === 100000000000000000000); // true — corruzione dati
 
// GIUSTO — usa BigInt
const balance = 1000000000000000000n;
const double = balance * 2n;
console.log(double.toString()); // "2000000000000000000" — corretto
 
const largeBalance = 99999999999999999999n;
console.log(largeBalance.toString()); // "99999999999999999999" — corretto

import { formatUnits, parseUnits } from "viem";
 
// Visualizzazione: BigInt → stringa leggibile
const weiAmount = 1500000000000000000n; // 1.5 ETH
const display = formatUnits(weiAmount, 18); // "1.5"
 
// Input: stringa leggibile → BigInt
const userInput = "1.5";
const wei = parseUnits(userInput, 18); // 1500000000000000000n
 
// USDC ha 6 decimali, non 18
const usdcAmount = 100000000n; // 100 USDC
const usdcDisplay = formatUnits(usdcAmount, 6); // "100.0"

// L'utente può rifiutare qualsiasi prompt del wallet
try {
  const tx = await writeContract({
    address: contractAddress,
    abi: ERC20_ABI,
    functionName: "approve",
    args: [spenderAddress, amount],
  });
} catch (error) {
  if (error.code === 4001) {
    // L'utente ha rifiutato la transazione nel wallet
    // Questo è normale — non è un errore da segnalare
    showToast("Transazione annullata");
  } else if (error.code === -32603) {
    // Errore interno JSON-RPC — spesso significa che la transazione revertirebbe
    showToast("La transazione fallirebbe. Controlla il tuo saldo.");
  } else {
    // Errore inaspettato
    console.error("Errore transazione:", error);
    showToast("Qualcosa è andato storto. Per favore riprova.");
  }
}

// Controllo difensivo della chain
import { useAccount, useChainId } from "wagmi";
 
function useRequireChain(requiredChainId: number) {
  const chainId = useChainId();
  const { isConnected } = useAccount();
 
  if (!isConnected) {
    return { ready: false, error: "Per favore connetti il tuo wallet" };
  }
 
  if (chainId !== requiredChainId) {
    return {
      ready: false,
      error: `Per favore passa a ${getChainName(requiredChainId)}. Sei su ${getChainName(chainId)}.`,
    };
  }
 
  return { ready: true, error: null };
}

// Impostazione della tolleranza allo slippage su uno swap tipo Uniswap
const amountOutMin = expectedOutput * 995n / 1000n; // 0.5% di tolleranza allo slippage
 
// Usando una deadline per prevenire transazioni in attesa di lunga durata
const deadline = BigInt(Math.floor(Date.now() / 1000) + 60 * 20); // 20 minuti
 
await router.swapExactTokensForTokens(
  amountIn,
  amountOutMin,  // Output minimo accettabile — reverte se otteniamo meno
  [tokenA, tokenB],
  userAddress,
  deadline,       // Reverte se non eseguito entro 20 minuti
);

// Uso di Flashbots Protect come endpoint 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; // Nessun errore — la transazione avrebbe successo
  } catch (error) {
    // Decodifica il motivo del revert
    if (error.data) {
      // Stringhe di revert comuni
      if (error.data.startsWith("0x08c379a0")) {
        // Error(string) — revert standard con messaggio
        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("");
 
  // Leggi il saldo — si esegue solo quando l'indirizzo è definito
  const { data: balance, refetch: refetchBalance } = useReadContract({
    address: USDC_ADDRESS,
    abi: USDC_ABI,
    functionName: "balanceOf",
    args: address ? [address] : undefined,
    query: { enabled: !!address },
  });
 
  // Scrivi: trasferisci token
  const {
    writeContract,
    data: txHash,
    isPending: isSigning,
    error: writeError,
  } = useWriteContract();
 
  // Attendi la conferma
  const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({
    hash: txHash,
  });
 
  // Aggiorna il saldo dopo la conferma
  if (isSuccess) {
    refetchBalance();
  }
 
  if (!isConnected) {
    return (
      <button onClick={() => connect({ connector: injected() })}>
        Connetti wallet
      </button>
    );
  }
 
  return (
    <div>
      <p>Connesso: {address}</p>
      <p>
        Saldo USDC:{" "}
        {balance !== undefined ? formatUnits(balance, 6) : "Caricamento..."}
      </p>
 
      <div>
        <input
          placeholder="Indirizzo destinatario (0x...)"
          value={recipient}
          onChange={(e) => setRecipient(e.target.value)}
        />
        <input
          placeholder="Importo (es. 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
            ? "Conferma nel wallet..."
            : isConfirming
              ? "Confermando..."
              : "Invia USDC"}
        </button>
      </div>
 
      {writeError && <p style={{ color: "red" }}>{writeError.message}</p>}
      {isSuccess && <p style={{ color: "green" }}>Trasferimento confermato!</p>}
      {txHash && (
        <a
          href={`https://etherscan.io/tx/${txHash}`}
          target="_blank"
          rel="noopener noreferrer"
        >
          Visualizza su Etherscan
        </a>
      )}
 
      <button onClick={() => disconnect()}>Disconnetti</button>
    </div>
  );
}