const tokenAddress = '0x...';
const balance = await sdk.vault.getBalance(tokenAddress);

console.log('Shielded:', balance.shieldedBalance);
console.log('Wallet:', balance.walletBalance);
// Returns: TokenBalance { tokenAddress, shieldedBalance, walletBalance, symbol?, decimals?, noteCount? }

const balances = await sdk.vault.getAllBalances();

for (const balance of balances) {
  console.log(`Token: ${balance.tokenAddress}`);
  console.log(`  Symbol: ${balance.symbol}`);
  console.log(`  Shielded: ${balance.shieldedBalance}`);
  console.log(`  Wallet: ${balance.walletBalance}`);
  console.log(`  Decimals: ${balance.decimals}`);
}

interface TokenBalance {
  tokenAddress: Hex;        // Token contract address
  shieldedBalance: bigint;  // Private (shielded) balance
  walletBalance: bigint;    // Public wallet balance
  symbol?: string;          // Token symbol (e.g., "USDC")
  decimals?: number;        // Token decimals (e.g., 18)
  noteCount?: number;       // Number of shielded notes backing the balance
}

// Refresh a specific token
await sdk.vault.refreshBalance('0x...token-address');

// Refresh all tracked balances
await sdk.vault.refreshBalances();

const token = await sdk.vault.getToken('0x...token-address');

console.log('Name:', token.name);        // "USD Coin"
console.log('Symbol:', token.symbol);    // "USDC"
console.log('Decimals:', token.decimals); // 6

interface TokenMetadata {
  address: Hex;
  symbol: string;
  decimals: number;
  name: string;
}

const tokens = await sdk.vault.getTokens();

for (const token of tokens) {
  console.log(`${token.symbol} (${token.address})`);
}

import { parseAmount } from '@sunnyside-io/privacy-boost';

// Parse "1.5" using a token's decimals
const usdc = parseAmount('1.5', 6);
// Returns: 1500000n

const weth = parseAmount('1.5', 18);
// Returns: 1500000000000000000n

import { formatAmount } from '@sunnyside-io/privacy-boost';

const formatted = formatAmount(1500000n, 6);
// Returns: "1.5"

const ethFormatted = formatAmount(1500000000000000000n, 18);
// Returns: "1.5"

const ETH_ADDRESS = '0x0000000000000000000000000000000000000000';

// Check if token is native ETH
import { isNativeEth } from '@sunnyside-io/privacy-boost';

if (isNativeEth(tokenAddress)) {
  console.log('This is native ETH');
}

import { useState, useEffect } from 'react';

function BalanceList() {
  const [balances, setBalances] = useState<TokenBalance[]>([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function loadBalances() {
      setLoading(true);
      await sdk.vault.refreshBalances();
      const allBalances = await sdk.vault.getAllBalances();
      setBalances(allBalances);
      setLoading(false);
    }
    loadBalances();
  }, []);

  const formatBalance = (amount: bigint, decimals: number) => {
    return formatAmount(amount, decimals);
  };

  if (loading) return <div>Loading balances...</div>;

  return (
    <table>
      <thead>
        <tr>
          <th>Token</th>
          <th>Shielded</th>
          <th>Wallet</th>
        </tr>
      </thead>
      <tbody>
        {balances.map((balance) => (
          <tr key={balance.tokenAddress}>
            <td>{balance.symbol}</td>
            <td>{formatBalance(balance.shieldedBalance, balance.decimals || 18)}</td>
            <td>{formatBalance(balance.walletBalance, balance.decimals || 18)}</td>
          </tr>
        ))}
      </tbody>
    </table>
  );
}

function useBalancePolling(intervalMs = 30000) {
  const [balances, setBalances] = useState<TokenBalance[]>([]);

  useEffect(() => {
    async function sync() {
      await sdk.vault.refreshBalances();
      setBalances(await sdk.vault.getAllBalances());
    }

    sync(); // Initial sync

    const interval = setInterval(sync, intervalMs);
    return () => clearInterval(interval);
  }, [intervalMs]);

  return balances;
}

async function getTotalValue(prices: Record<string, number>) {
  const balances = await sdk.vault.getAllBalances();

  let total = 0;
  for (const balance of balances) {
    const price = prices[balance.tokenAddress.toLowerCase()] || 0;
    const amount = Number(balance.shieldedBalance) / 10 ** (balance.decimals || 18);
    total += amount * price;
  }

  return total;
}

async function hasSufficientBalance(
  tokenAddress: Hex,
  requiredAmount: bigint
): Promise<boolean> {
  const balance = await sdk.vault.getBalance(tokenAddress);
  return balance.shieldedBalance >= requiredAmount;
}

try {
  const balance = await sdk.vault.getBalance(tokenAddress);
} catch (error) {
  switch (error.code) {
    case 'TOKEN_NOT_FOUND':
      console.log('Token not supported');
      break;
    case 'SYNC_FAILED':
      console.log('Failed to sync balance');
      break;
    default:
      console.log('Balance error:', error.message);
  }
}

const tokenCache = new Map<string, TokenMetadata>();

async function getTokenCached(address: string) {
  const key = address.toLowerCase();
  if (!tokenCache.has(key)) {
    const metadata = await sdk.vault.getToken(address);
    tokenCache.set(key, metadata);
  }
  return tokenCache.get(key)!;
}

function formatBalance(balance: TokenBalance): string {
  if (balance.shieldedBalance === 0n && balance.walletBalance === 0n) {
    return '0';
  }
  return formatAmount(balance.shieldedBalance, balance.decimals || 18);
}

async function depositWithRefresh(params: DepositParams) {
  const result = await sdk.vault.shield(params);

  // Refresh balance after deposit
  await sdk.vault.refreshBalance(params.tokenAddress);

  return result;
}