Send Tokens

import { parseEther } from "viem";

async function sendETH(
  walletClient: any,
  account: any,
  toAddress: `0x${string}`,
  amountInEther: string
) {
  try {
    const hash = await walletClient.sendTransaction({
      account,
      to: toAddress,
      value: parseEther(amountInEther)
    });
    
    console.log("Transaction hash:", hash);
    
    const receipt = await walletClient.waitForTransactionReceipt({ 
      hash 
    });
    console.log("Transaction confirmed in block:", receipt.blockNumber);
    
    return {
      hash,
      blockNumber: receipt.blockNumber,
      gasUsed: receipt.gasUsed.toString()
    };
  } catch (error) {
    console.error("Transaction failed:", error);
    throw error;
  }
}

import { useSendTransaction, useWaitForTransaction } from "wagmi";
import { parseEther } from "viem";

function SendETH() {
  const { 
    data: txData, 
    isLoading, 
    sendTransaction 
  } = useSendTransaction();
  
  const { 
    data: receipt, 
    isLoading: isConfirming 
  } = useWaitForTransaction({
    hash: txData?.hash
  });
  
  const handleSend = async () => {
    sendTransaction({
      to: "0x742d35Cc6634C0532925a3b844Bc9e7595f7BBB2",
      value: parseEther("0.01")
    });
  };
  
  return (
    <div>
      <button 
        onClick={handleSend}
        disabled={isLoading || isConfirming}
      >
        {isLoading ? "Sending..." : "Send 0.01 ETH"}
      </button>
      {txData && <p>Transaction Hash: {txData.hash}</p>}
      {receipt && <p>Confirmed in block: {receipt.blockNumber}</p>}
    </div>
  );
}

import { parseUnits } from "viem";

const ERC20_ABI = [
  {
    name: "transfer",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" }
    ],
    outputs: [{ type: "bool" }]
  }
] as const;

async function sendToken(
  walletClient: any,
  account: any,
  tokenAddress: `0x${string}`,
  toAddress: `0x${string}`,
  amount: string,
  decimals: number
) {
  try {
    const parsedAmount = parseUnits(amount, decimals);
    
    const { request } = await walletClient.simulateContract({
      account,
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: "transfer",
      args: [toAddress, parsedAmount]
    });
    
    const hash = await walletClient.writeContract(request);
    console.log("Transaction hash:", hash);
    
    const receipt = await walletClient.waitForTransactionReceipt({ 
      hash 
    });
    
    return {
      hash,
      blockNumber: receipt.blockNumber,
      gasUsed: receipt.gasUsed.toString()
    };
  } catch (error) {
    console.error("Token transfer failed:", error);
    throw error;
  }
}

import { useContractWrite, useWaitForTransaction } from "wagmi";
import { parseUnits } from "viem";

const ERC20_ABI = [
  {
    name: "transfer",
    type: "function",
    stateMutability: "nonpayable",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" }
    ],
    outputs: [{ type: "bool" }]
  }
] as const;

function SendToken({ 
  tokenAddress, 
  decimals 
}: { 
  tokenAddress: `0x${string}`;
  decimals: number;
}) {
  const { 
    data: txData,
    write: transfer,
    isLoading 
  } = useContractWrite({
    address: tokenAddress,
    abi: ERC20_ABI,
    functionName: "transfer"
  });
  
  const { 
    isLoading: isConfirming 
  } = useWaitForTransaction({
    hash: txData?.hash
  });
  
  const handleTransfer = () => {
    transfer({
      args: [
        "0x742d35Cc6634C0532925a3b844Bc9e7595f7BBB2",
        parseUnits("10", decimals)
      ]
    });
  };
  
  return (
    <button 
      onClick={handleTransfer}
      disabled={isLoading || isConfirming}
    >
      {isLoading ? "Sending..." : "Send 10 Tokens"}
    </button>
  );
}