useExchangeAccounts

The useExchangeAccounts hook provides functionality for managing exchange accounts and performing exchange-related operations. It allows users to retrieve their exchange accounts, view transaction history, and execute transfers between exchange accounts.

This hook integrates with the Dynamic SDK to handle exchange operations across different blockchain networks and exchange platforms.

This hook supports the Fund from Exchange feature, allowing users to transfer funds directly from their exchange accounts to their wallets.

Available Methods

• exchangeTransfer - Execute transfers between exchange accounts
• getExchangeTransactions - Retrieve transaction history for exchange accounts
• getExchangeUserAccounts - Get all user accounts for a specific exchange

Methods

exchangeTransfer

Summary: Executes a transfer between exchange accounts. The method automatically finds the appropriate account based on the currency being transferred and creates the transfer request.

Inputs:

Parameter	Type	Description
exchange	ExchangeKeyEnum	The exchange platform identifier (e.g., Coinbase, Binance, etc.)
transferRequest	CreateExchangeTransferRequest	The transfer request object containing transfer details

CreateExchangeTransferRequest Fields:

Field	Type	Description
to	string	The recipient address (e.g., ‘0xRecipientAddr’)
amount	number	The amount to transfer (e.g., 0.25)
currency	string	The currency code (e.g., ‘ETH’, ‘USDC’)
network	string	The blockchain network (e.g., ‘ethereum’)
description	string	Optional description of the transfer
mfaCode	string	Optional MFA verification code

Outputs:

Field	Type	Description
Returns	Promise<ExchangeTransferResponse>	A promise that resolves to the transfer response containing transfer status and details

ExchangeTransferResponse Fields:

Field	Type	Description
id	string	Unique transfer identifier (e.g., ‘tx-1’)
exchangeAccountId	string	ID of the exchange account used for transfer
status	string	Transfer status (e.g., ‘pending’, ‘completed’, ‘failed’)
amount	number	The transferred amount
currency	string	The currency that was transferred
createdAt	Date	Timestamp when the transfer was created

Example Response:

{
  id: 'tx-1',
  exchangeAccountId: '123',
  status: 'pending',
  amount: 1,
  currency: 'USDC',
  createdAt: new Date(),
}

Example:

const { exchangeTransfer } = useExchangeAccounts();

const result = await exchangeTransfer({
  exchange: ExchangeKeyEnum.Coinbase,
  transferRequest: {
    to: '0xRecipient',
    amount: 1,
    currency: 'USDC',
    network: 'ethereum',
  },
});

getExchangeTransactions

Summary: Retrieves transaction history for exchange accounts. Can fetch transactions for a specific account or all accounts if no accountId is provided.

Inputs:

Parameter	Type	Description
exchange	ExchangeKeyEnum	The exchange platform identifier
accountId	string | undefined	Optional account ID to filter transactions for a specific account

Outputs:

Field	Type	Description
Returns	Promise<ExchangeTransaction[]>	A promise that resolves to an array of exchange transactions

ExchangeTransaction Fields:

Field	Type	Description
transactionId	string	Unique transaction identifier (e.g., ‘tx-123’)
transactionHash	string	Blockchain transaction hash (e.g., ‘0xabc’)
status	string	Transaction status (e.g., ‘pending’, ‘completed’, ‘failed’)
amount	number	Transaction amount
currency	string	Currency involved in the transaction
createdAt	Date	Timestamp when the transaction was created

Example Response:

[
  {
    transactionId: 'tx-123',
    transactionHash: '0xabc',
    status: 'pending',
    amount: 0.5,
    currency: 'ETH',
    createdAt: new Date('2025-06-25T12:00:00Z'),
  },
];

Example:

const { getExchangeTransactions } = useExchangeAccounts();

// Get all transactions for an exchange
const allTransactions = await getExchangeTransactions({
  exchange: ExchangeKeyEnum.Coinbase,
});

// Get transactions for a specific account
const accountTransactions = await getExchangeTransactions({
  exchange: ExchangeKeyEnum.Coinbase,
  accountId: 'acc-1',
});

getExchangeUserAccounts

Summary: Retrieves all exchange accounts associated with the current user for a specific exchange platform. Returns accounts with their balances and currency information.

Inputs:

Parameter	Type	Description
exchange	ExchangeKeyEnum	The exchange platform identifier

Outputs:

Field	Type	Description
Returns	Promise<Account[]>	A promise that resolves to an array of user accounts with balance information

Account Fields:

Field	Type	Description
id	string	Unique account identifier (e.g., ‘acc-1’, ‘acc-2’)
exchange	ExchangeKeyEnum	The exchange platform this account belongs to
balances	Array<Balance>	Array of balance objects for different currencies

Balance Fields:

Field	Type	Description
currency	string	Currency code (e.g., ‘USDC’, ‘BTC’, ‘ETH’)
balance	number	Available balance amount

Example Response:

[
  {
    id: 'acc-1',
    exchange: ExchangeKeyEnum.Coinbase,
    balances: [
      {
        currency: 'USDC',
        balance: 1,
      },
    ],
  },
  {
    id: 'acc-2',
    exchange: ExchangeKeyEnum.Coinbase,
    balances: [
      {
        currency: 'BTC',
        balance: 1,
      },
    ],
  },
];

Example:

const { getExchangeUserAccounts } = useExchangeAccounts();

const accounts = await getExchangeUserAccounts({
  exchange: ExchangeKeyEnum.Coinbase,
});

// Each account contains:
// - id: string (e.g., 'acc-1', 'acc-2')
// - exchange: ExchangeKeyEnum
// - balances: Array of balance objects with currency and balance
//   Example: [{ currency: 'USDC', balance: 1 }, { currency: 'BTC', balance: 1 }]

Usage Example

import { useExchangeAccounts } from '@dynamic-labs/sdk-react-core';
import { ExchangeKeyEnum } from '@dynamic-labs/sdk-api-core';

function ExchangeComponent() {
  const { exchangeTransfer, getExchangeTransactions, getExchangeUserAccounts } =
    useExchangeAccounts();

  const handleTransfer = async () => {
    try {
      const result = await exchangeTransfer({
        exchange: ExchangeKeyEnum.Coinbase,
        transferRequest: {
          to: '0xRecipient',
          amount: 1,
          currency: 'USDC',
          network: 'ethereum',
        },
      });
      console.log('Transfer successful:', result);
    } catch (error) {
      console.error('Transfer failed:', error);
    }
  };

  const loadAccounts = async () => {
    const accounts = await getExchangeUserAccounts({
      exchange: ExchangeKeyEnum.Coinbase,
    });
    console.log('User accounts:', accounts);
  };

  const loadTransactions = async () => {
    const transactions = await getExchangeTransactions({
      exchange: ExchangeKeyEnum.Coinbase,
    });
    console.log('Transactions:', transactions);
  };

  return (
    <div>
      <button onClick={handleTransfer}>Transfer</button>
      <button onClick={loadAccounts}>Load Accounts</button>
      <button onClick={loadTransactions}>Load Transactions</button>
    </div>
  );
}

Error Handling

The hook throws DynamicError with specific error codes when operations fail:

• UnprocessableEntityErrorCode.InvalidTransferCurrency: Thrown when no account is found for the specified currency during transfer operations.

Dependencies

This hook depends on:

• useInternalDynamicContext for accessing wallet and network information
• Dynamic SDK data layer for API calls
• Environment configuration for API endpoints