🌐 Web3 TypeScript Types

interface Token {
  address: ContractAddress;
  name: string;
  symbol: string;
  decimals: number;
  chainId: number;
  logoUrl?: string;
}

type ContractAddress = Address;
type WalletAddress = Address;
type TransactionHash = Hash;

const usdc: Token = {
  address: "0xA0b86a33E6...",
  name: "USD Coin",
  symbol: "USDC",
  decimals: 6,
  chainId: 1,
  logoUrl: "https://tokens.1inch.io/0xa0b86a33e..."
};

// Type-safe token operations
const tokenBalance = await getTokenBalance(usdc.address);
const formattedAmount = formatTokenAmount(amount, usdc.decimals);

interface TransactionStatus {
  hash: TransactionHash;
  status: "pending" | "confirmed" | "failed";
  blockNumber?: bigint;
  confirmations?: number;
}

interface ContractCall {
  address: ContractAddress;
  functionName: string;
  args?: any[];
  value?: bigint;
}

// Contract interaction
const transferCall: ContractCall = {
  address: tokenAddress,
  functionName: "transfer",
  args: [recipient, amount],
  value: BigInt(0)
};

// Monitor transaction
const txStatus: TransactionStatus = {
  hash: "0xabc...",
  status: "pending",
  blockNumber: BigInt(18500000),
  confirmations: 0
};

interface WalletState {
  isConnected: boolean;
  isConnecting: boolean;
  isReconnecting: boolean;
  address?: WalletAddress;
  chainId?: number;
  connector?: any;
}

// Wallet connection hooks
const { address, isConnected, chainId } = useAccount();
const { connect } = useConnect();
const { disconnect } = useDisconnect();

interface NetworkConfig {
  chainId: number;
  name: string;
  rpcUrl: string;
  blockExplorer: string;
  nativeCurrency: {
    name: string;
    symbol: string;
    decimals: number;
  };
}

const ethereum: NetworkConfig = {
  chainId: 1,
  name: "Ethereum Mainnet",
  rpcUrl: "https://mainnet.infura.io/v3/...",
  blockExplorer: "https://etherscan.io",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }
};

interface Web3Error {
  code: string;
  message: string;
  cause?: unknown;
}

// Common error codes
type ErrorCode =
  | "ACTION_REJECTED"
  | "INSUFFICIENT_FUNDS"
  | "NETWORK_ERROR"
  | "CONTRACT_ERROR"
  | "INVALID_ADDRESS";

function isWeb3Error(error: unknown): error is Web3Error {
  return error instanceof Error &&
    'code' in error &&
    'message' in error;
}

try {
  await contractWrite();
} catch (error) {
  if (isWeb3Error(error)) {
    switch (error.code) {
      case "ACTION_REJECTED":
        toast.error("Transaction was rejected");
        break;
      case "INSUFFICIENT_FUNDS":
        toast.error("Insufficient funds");
        break;
      default:
        toast.error(error.message);
    }
  }
}

function useWalletInfo() {
  const { address, isConnected, chainId } = useAccount();
  const { data: balance } = useBalance({ address });

  const walletState: WalletState = {
    isConnected,
    isConnecting: false,
    isReconnecting: false,
    address,
    chainId,
  };

  return {
    address,
    chainId,
    balance: balance?.value,
    formattedAddress: formatAddress(address),
    walletState,
  };
}

function useContractWrite<T extends ContractABI>(
  contract: { address: Address; abi: T }
) {
  const [status, setStatus] = useState<TransactionStatus | null>(null);

  const writeContract = async (call: ContractCall) => {
    try {
      const hash = await writeContract({
        address: call.address,
        abi: contract.abi,
        functionName: call.functionName,
        args: call.args,
        value: call.value,
      });

      setStatus({
        hash,
        status: "pending",
        confirmations: 0,
      });

      return hash;
    } catch (error) {
      if (isWeb3Error(error)) {
        throw error;
      }
      throw new Error("Unknown error");
    }
  };

  return { writeContract, status };
}