Query Wallet Balances

import { formatEther } from "viem";
import { createParaAccount } from "@getpara/viem-v2-integration";

async function getETHBalance(publicClient: any, para: any) {
  const account = await createParaAccount(para);
  const balance = await publicClient.getBalance({
    address: account.address
  });
  
  const formattedBalance = formatEther(balance);
  console.log(`ETH Balance: ${formattedBalance} ETH`);
  
  return {
    wei: balance.toString(),
    ether: formattedBalance
  };
}

import { useBalance, useAccount } from "wagmi";

function ETHBalance() {
  const { address } = useAccount();
  const { data, isError, isLoading } = useBalance({
    address: address
  });
  
  if (isLoading) return <div>Loading balance...</div>;
  if (isError) return <div>Error fetching balance</div>;
  
  return (
    <div>
      <p>ETH Balance: {data?.formatted} {data?.symbol}</p>
      <p>Wei: {data?.value.toString()}</p>
    </div>
  );
}

import { formatUnits } from "viem";

const ERC20_ABI = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "owner", type: "address" }],
    outputs: [{ type: "uint256" }]
  },
  {
    name: "decimals",
    type: "function",
    stateMutability: "view",
    inputs: [],
    outputs: [{ type: "uint8" }]
  },
  {
    name: "symbol",
    type: "function",
    stateMutability: "view",
    inputs: [],
    outputs: [{ type: "string" }]
  }
] as const;

async function getTokenBalance(
  publicClient: any,
  account: any,
  tokenAddress: `0x${string}`
) {
  const [balance, decimals, symbol] = await Promise.all([
    publicClient.readContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: "balanceOf",
      args: [account.address]
    }),
    publicClient.readContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: "decimals"
    }),
    publicClient.readContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: "symbol"
    })
  ]);
  
  const formattedBalance = formatUnits(balance, decimals);
  console.log(`${symbol} Balance: ${formattedBalance}`);
  
  return {
    raw: balance.toString(),
    formatted: formattedBalance,
    symbol,
    decimals
  };
}

import { useAccount, useContractReads } from "wagmi";

const ERC20_ABI = [
  {
    name: "balanceOf",
    type: "function",
    stateMutability: "view",
    inputs: [{ name: "owner", type: "address" }],
    outputs: [{ type: "uint256" }]
  },
  {
    name: "decimals",
    type: "function",
    stateMutability: "view",
    inputs: [],
    outputs: [{ type: "uint8" }]
  },
  {
    name: "symbol",
    type: "function",
    stateMutability: "view",
    inputs: [],
    outputs: [{ type: "string" }]
  }
] as const;

function TokenBalance({ tokenAddress }: { tokenAddress: `0x${string}` }) {
  const { address } = useAccount();
  
  const { data, isLoading } = useContractReads({
    contracts: [
      {
        address: tokenAddress,
        abi: ERC20_ABI,
        functionName: "balanceOf",
        args: [address!]
      },
      {
        address: tokenAddress,
        abi: ERC20_ABI,
        functionName: "decimals"
      },
      {
        address: tokenAddress,
        abi: ERC20_ABI,
        functionName: "symbol"
      }
    ]
  });
  
  if (isLoading) return <div>Loading token balance...</div>;
  
  const balance = data?.[0]?.result;
  const decimals = data?.[1]?.result;
  const symbol = data?.[2]?.result;
  
  if (!balance || !decimals) return <div>No balance data</div>;
  
  const formatted = (Number(balance) / 10 ** decimals).toFixed(4);
  
  return (
    <div>
      <p>{symbol} Balance: {formatted}</p>
    </div>
  );
}