import { Mina } from '@siphoyawe/mina-sdk';

const mina = new Mina({ integrator: 'my-app' });

// Get all tokens on Arbitrum
const { tokens, isStale, cachedAt } = await mina.getTokens(42161);

console.log(`Found ${tokens.length} tokens on Arbitrum`);
tokens.forEach(token => {
  console.log(`${token.symbol}: ${token.address}`);
});

// Get tokens that can actually be bridged to HyperEVM
const { tokens } = await mina.getBridgeableTokens(42161);

console.log(`Found ${tokens.length} bridgeable tokens`);
tokens.forEach(token => {
  console.log(`${token.symbol} - $${token.priceUsd?.toFixed(2) ?? 'N/A'}`);
});

interface TokensResponse {
  /** Array of token data */
  tokens: Token[];
  /** Whether the data is from stale cache */
  isStale: boolean;
  /** Timestamp when data was cached (null if fresh from API) */
  cachedAt: number | null;
}

interface Token {
  /** Token contract address */
  address: string;
  /** Token symbol (e.g., "USDC") */
  symbol: string;
  /** Token name (e.g., "USD Coin") */
  name: string;
  /** Token decimals (e.g., 6 for USDC) */
  decimals: number;
  /** URL to token logo image */
  logoUrl: string;
  /** Current USD price (optional) */
  priceUsd?: number;
  /** Chain ID this token is on */
  chainId: number;
}

const NATIVE_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000';

// Check if a token is the native token
function isNativeToken(token: Token): boolean {
  return token.address.toLowerCase() === NATIVE_TOKEN_ADDRESS;
}

// Get native token for a chain
const { tokens } = await mina.getTokens(42161);
const nativeToken = tokens.find(isNativeToken);
console.log(nativeToken?.symbol); // "ETH" on Arbitrum

// HyperEVM USDC address
const HYPEREVM_USDC_ADDRESS = '0xb88339cb7199b77e23db6e890353e22632ba630f';

// Get destination tokens
const destinationTokens = mina.getDestinationTokens();
// Returns USDC and HYPE tokens on HyperEVM

import { Mina, Token } from '@siphoyawe/mina-sdk';

const mina = new Mina({ integrator: 'my-app' });

interface TokenOption {
  address: string;
  symbol: string;
  name: string;
  logo: string;
  priceUsd: number | null;
  decimals: number;
}

async function getTokenOptions(chainId: number): Promise<TokenOption[]> {
  const { tokens } = await mina.getBridgeableTokens(chainId);

  return tokens.map(token => ({
    address: token.address,
    symbol: token.symbol,
    name: token.name,
    logo: token.logoUrl,
    priceUsd: token.priceUsd ?? null,
    decimals: token.decimals,
  }));
}

// Usage
const arbitrumTokens = await getTokenOptions(42161);
// [
//   { address: '0x...', symbol: 'USDC', name: 'USD Coin', ... },
//   { address: '0x...', symbol: 'USDT', name: 'Tether', ... },
//   ...
// ]

function calculateUsdValue(
  token: Token,
  amountInSmallestUnit: string
): number | null {
  if (!token.priceUsd) return null;

  const amount = BigInt(amountInSmallestUnit);
  const divisor = BigInt(10 ** token.decimals);
  const tokenAmount = Number(amount) / Number(divisor);

  return tokenAmount * token.priceUsd;
}

// Usage
const { tokens } = await mina.getBridgeableTokens(42161);
const usdc = tokens.find(t => t.symbol === 'USDC');

if (usdc) {
  const usdValue = calculateUsdValue(usdc, '1000000'); // 1 USDC
  console.log(`Value: $${usdValue?.toFixed(2)}`); // "Value: $1.00"
}

const { tokens, isStale, cachedAt } = await mina.getBridgeableTokens(42161);

if (isStale) {
  console.warn('Using cached token data from:', new Date(cachedAt!));
}

import { TokenFetchError } from '@siphoyawe/mina-sdk';

try {
  const { tokens } = await mina.getBridgeableTokens(42161);
} catch (error) {
  if (error instanceof TokenFetchError) {
    console.error(`Failed to fetch tokens for chain ${error.chainId}:`, error.message);

    if (error.cachedAvailable) {
      console.log('Stale cache may be available');
    }
  }
}