import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const accounts = await getKrakenAccounts();

accounts.forEach(account => {
  console.log(`Account: ${account.name || account.id}`);
  account.balances.forEach(balance => {
    console.log(`  ${balance.currency}: ${balance.balance}`);
  });
});

type KrakenAccount = {
  id: string;               // Unique account ID (use this for transfers)
  exchange: 'kraken';
  name?: string;            // User-assigned account name
  type?: string;            // Account type (e.g., 'spot')
  chain?: string;           // Blockchain network if relevant
  balances: Array<{
    currency: string;       // Currency code (e.g., 'ETH', 'BTC', 'USDC')
    balance: number;        // Total balance
    availableBalance?: number; // Balance available for withdrawal
    logoURI?: string;       // Token logo URL
  }>;
};

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const accounts = await getKrakenAccounts();

// Log all balances across all accounts
accounts.forEach(account => {
  console.log(`Account: ${account.name || account.type || account.id}`);
  account.balances.forEach(({ currency, balance, availableBalance }) => {
    console.log(`  ${currency}: ${balance}`);
    if (availableBalance && availableBalance !== balance) {
      console.log(`    Available: ${availableBalance}`);
    }
  });
});

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

// Get only EVM-compatible assets (ETH, ERC-20 tokens, etc.)
const evmAccounts = await getKrakenAccounts({ chainName: 'EVM' });

// Get only Solana assets
const solanaAccounts = await getKrakenAccounts({ chainName: 'SOL' });

// Get only Bitcoin
const bitcoinAccounts = await getKrakenAccounts({ chainName: 'BTC' });

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

// Get assets on Ethereum mainnet only
const mainnetAccounts = await getKrakenAccounts({
  chainName: 'EVM',
  networkId: 1,
});

// Get assets on Polygon
const polygonAccounts = await getKrakenAccounts({
  chainName: 'EVM',
  networkId: 137,
});

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const findBalance = async (currency) => {
  const accounts = await getKrakenAccounts();

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      return {
        accountId: account.id,
        currency: balance.currency,
        balance: balance.balance,
        available: balance.availableBalance ?? balance.balance,
      };
    }
  }

  return null;
};

// Usage
const ethBalance = await findBalance('ETH');
if (ethBalance) {
  console.log(`ETH Balance: ${ethBalance.balance}`);
  console.log(`Account ID: ${ethBalance.accountId}`);
}

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const hasSufficientBalance = async (currency, requiredAmount) => {
  const accounts = await getKrakenAccounts();

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      const available = balance.availableBalance ?? balance.balance;
      if (available >= requiredAmount) {
        return { hasBalance: true, accountId: account.id, available };
      }
    }
  }

  return { hasBalance: false, accountId: null, available: 0 };
};

// Usage
const { hasBalance, accountId, available } = await hasSufficientBalance('ETH', 0.5);

if (!hasBalance) {
  console.log(`Insufficient ETH. You have ${available} ETH available.`);
} else {
  console.log(`Ready to transfer from account ${accountId}`);
}

import { useState, useEffect } from 'react';
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const KrakenBalances = () => {
  const [accounts, setAccounts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchBalances = async () => {
      try {
        const data = await getKrakenAccounts();
        setAccounts(data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };

    fetchBalances();
  }, []);

  if (loading) return <div>Loading balances...</div>;
  if (error) return <div>Error: {error}</div>;
  if (accounts.length === 0) return <div>No Kraken accounts found</div>;

  return (
    <div>
      <h3>Your Kraken Balances</h3>
      {accounts.map(account => (
        <div key={account.id}>
          <h4>{account.name || `Account ${account.id.slice(0, 8)}`}</h4>
          <ul>
            {account.balances
              .filter(b => b.balance > 0)
              .map(balance => (
                <li key={balance.currency}>
                  <strong>{balance.currency}:</strong> {balance.balance}
                </li>
              ))}
          </ul>
        </div>
      ))}
    </div>
  );
};

import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const getTotalBalanceForCurrency = async (currency) => {
  const accounts = await getKrakenAccounts();

  let total = 0;
  const accountBreakdown = [];

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      total += balance.balance;
      accountBreakdown.push({
        accountId: account.id,
        accountName: account.name,
        balance: balance.balance,
      });
    }
  }

  return { total, accounts: accountBreakdown };
};

// Usage
const ethTotal = await getTotalBalanceForCurrency('ETH');
console.log(`Total ETH: ${ethTotal.total}`);
ethTotal.accounts.forEach(acc => {
  console.log(`  ${acc.accountName || acc.accountId}: ${acc.balance} ETH`);
});