Build Web3 Wallet Integration

import { Redis } from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);

interface WalletState {
  connected: boolean;
  address: string | null;
  chainId: number | null;
  chainName: string | null;
  balance: string;
  tokens: TokenBalance[];
  nfts: NFTItem[];
}

interface TokenBalance { symbol: string; name: string; balance: string; decimals: number; contractAddress: string; usdValue: number; }
interface NFTItem { tokenId: string; name: string; image: string; collection: string; contractAddress: string; }
interface TransactionRequest { to: string; value: string; data?: string; chainId: number; }
interface TransactionResult { hash: string; status: "pending" | "confirmed" | "failed"; blockNumber?: number; gasUsed?: string; }

const CHAINS: Record<number, { name: string; rpcUrl: string; explorer: string; nativeCurrency: { name: string; symbol: string; decimals: number } }> = {
  1: { name: "Ethereum", rpcUrl: "https://eth.llamarpc.com", explorer: "https://etherscan.io", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 } },
  137: { name: "Polygon", rpcUrl: "https://polygon-rpc.com", explorer: "https://polygonscan.com", nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18 } },
  42161: { name: "Arbitrum", rpcUrl: "https://arb1.arbitrum.io/rpc", explorer: "https://arbiscan.io", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 } },
  8453: { name: "Base", rpcUrl: "https://mainnet.base.org", explorer: "https://basescan.org", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 } },
  10: { name: "Optimism", rpcUrl: "https://mainnet.optimism.io", explorer: "https://optimistic.etherscan.io", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 } },
};

// Connect wallet (server-side verification)
export async function verifyWalletSignature(address: string, message: string, signature: string): Promise<boolean> {
  // In production: use ethers.verifyMessage or viem.verifyMessage
  // Simplified: check signature format
  if (!signature.startsWith("0x") || signature.length !== 132) return false;
  // Store verified session
  await redis.setex(`wallet:session:${address.toLowerCase()}`, 86400, JSON.stringify({ address, verifiedAt: Date.now() }));
  return true;
}

// Get wallet balance via RPC
export async function getBalance(address: string, chainId: number): Promise<string> {
  const chain = CHAINS[chainId];
  if (!chain) throw new Error(`Unsupported chain: ${chainId}`);

  const cacheKey = `wallet:balance:${chainId}:${address}`;
  const cached = await redis.get(cacheKey);
  if (cached) return cached;

  const response = await fetch(chain.rpcUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_getBalance", params: [address, "latest"] }),
  });
  const { result } = await response.json();
  const balanceWei = BigInt(result || "0");
  const balanceEth = (Number(balanceWei) / 1e18).toFixed(6);

  await redis.setex(cacheKey, 30, balanceEth);
  return balanceEth;
}

// Get ERC-20 token balances
export async function getTokenBalances(address: string, chainId: number, tokenContracts: string[]): Promise<TokenBalance[]> {
  const chain = CHAINS[chainId];
  if (!chain) return [];

  const balances: TokenBalance[] = [];
  // balanceOf(address) selector = 0x70a08231
  const selector = "0x70a08231";
  const paddedAddress = address.slice(2).padStart(64, "0");

  for (const contract of tokenContracts) {
    try {
      const response = await fetch(chain.rpcUrl, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [{ to: contract, data: `${selector}${paddedAddress}` }, "latest"] }),
      });
      const { result } = await response.json();
      const balance = BigInt(result || "0");
      if (balance > 0n) {
        balances.push({ symbol: "TOKEN", name: "Token", balance: balance.toString(), decimals: 18, contractAddress: contract, usdValue: 0 });
      }
    } catch {}
  }

  return balances;
}

// Verify NFT ownership
export async function verifyNFTOwnership(address: string, contractAddress: string, chainId: number): Promise<{ owns: boolean; tokenIds: string[] }> {
  const chain = CHAINS[chainId];
  if (!chain) return { owns: false, tokenIds: [] };

  // balanceOf(address) for ERC-721
  const selector = "0x70a08231";
  const paddedAddress = address.slice(2).padStart(64, "0");

  const response = await fetch(chain.rpcUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [{ to: contractAddress, data: `${selector}${paddedAddress}` }, "latest"] }),
  });
  const { result } = await response.json();
  const balance = parseInt(result || "0", 16);

  return { owns: balance > 0, tokenIds: [] };
}

// Generate sign-in message (EIP-4361 / SIWE)
export function generateSIWEMessage(address: string, domain: string, nonce: string): string {
  return `${domain} wants you to sign in with your Ethereum account:\n${address}\n\nSign in to ${domain}\n\nURI: https://${domain}\nVersion: 1\nChain ID: 1\nNonce: ${nonce}\nIssued At: ${new Date().toISOString()}`;
}

// Track transaction
export async function trackTransaction(hash: string, chainId: number): Promise<TransactionResult> {
  const chain = CHAINS[chainId];
  if (!chain) throw new Error(`Unsupported chain: ${chainId}`);

  const response = await fetch(chain.rpcUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_getTransactionReceipt", params: [hash] }),
  });
  const { result } = await response.json();

  if (!result) return { hash, status: "pending" };
  return {
    hash,
    status: result.status === "0x1" ? "confirmed" : "failed",
    blockNumber: parseInt(result.blockNumber, 16),
    gasUsed: parseInt(result.gasUsed, 16).toString(),
  };
}

// Middleware: require wallet authentication
export function requireWallet() {
  return async (c: any, next: any) => {
    const address = c.req.header("X-Wallet-Address");
    if (!address) return c.json({ error: "Wallet address required" }, 401);
    const session = await redis.get(`wallet:session:${address.toLowerCase()}`);
    if (!session) return c.json({ error: "Wallet not verified. Sign a message first." }, 401);
    c.set("walletAddress", address.toLowerCase());
    await next();
  };
}