> ## Documentation Index
> Fetch the complete documentation index at: https://www.dynamic.xyz/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# useExchangeAccounts

<Card title="Recommended: JavaScript SDK with React Hooks" icon="react" color="#4779FE">
  For new React apps, we recommend the JavaScript SDK with React Hooks (`@dynamic-labs-sdk/react-hooks`) instead of the legacy React SDK documented here. The JS SDK comes with many benefits such as a much smaller bundle size and other optimizations. Use the [React quickstart (JavaScript SDK)](/docs/javascript/reference/react-quickstart) to get started.
</Card>

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, fetch whitelisted transfer destinations (for exchanges that enforce whitelisting), and execute transfers.

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

<Note>
  This hook supports the [Fund from Exchange](/docs/react/money-and-funding/fund-from-exchange) feature, allowing users to transfer funds directly from their exchange accounts to their wallets.
</Note>

### Available Methods

* **[exchangeTransfer](#exchangetransfer)** - Execute transfers between exchange accounts
* **[getExchangeTransactions](#getexchangetransactions)** - Retrieve transaction history for exchange accounts
* **[getExchangeWhitelistedDestinations](#getexchangewhitelisteddestinations)** - Retrieve available destinations that a user may transfer to for a specific exchange
* **[getExchangeUserAccounts](#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.

Note: Kraken does not support specifying the network that a transfer will take place on. The `networkObject` that you pass into a Kraken transfer will have no effect.

**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`                                     | (Deprecated: use networkObject instead) The blockchain network (e.g., 'ethereum') |
| `networkObject` | `CreateExchangeTransferRequestNetworkObject` | The networkId and chain that the transaction will occur on                        |
| `description`   | `string`                                     | Optional description of the transfer                                              |
| `mfaCode`       | `string`                                     | Optional MFA verification code                                                    |

**CreateExchangeTransferRequestNetworkObject**:

| Field       | Type        | Description                                                            |
| ----------- | ----------- | ---------------------------------------------------------------------- |
| `networkId` | `string`    | The networkId that the transfer should take place on (e.g., '1')       |
| `chainName` | `ChainEnum` | The chain that the transfer should take place on (e.g., ChainEnum.Evm) |

**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**:

```typescript theme={"system"}
{
  id: 'tx-1',
  exchangeAccountId: '123',
  status: 'pending',
  amount: 1,
  currency: 'USDC',
  createdAt: new Date(),
}
```

**Example**:

```typescript theme={"system"}
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**:

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

**Example**:

```typescript theme={"system"}
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',
});
```

### getExchangeWhitelistedDestinations

**Summary**: Retrieves available destinations that a user may transfer to for a specific exchange

**Inputs**:

| Parameter  | Type              | Description                      |
| ---------- | ----------------- | -------------------------------- |
| `exchange` | `ExchangeKeyEnum` | The exchange platform identifier |

**Outputs**:

| Field   | Type                                   | Description                                                                                                               |
| ------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Returns | `Promise<TransferDestinationResponse>` | A promise that resolves to an array of available destinations and an attribute whether this exchange enforces a whitelist |

**TransferDestinationResponse Fields**:

| Field                      | Type                    | Description                                                                                              |
| -------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------- |
| `destinations`             | `TransferDestination[]` | An array of destinations available for transfer                                                          |
| `enforcesAddressWhitelist` | `boolean`               | A boolean whether this exchange has a whitelist. If false, then all addresses are available for transfer |

**TransferDestination Fields**:

| Field     | Type       | Description                                                                                                                                                 |
| --------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `address` | `string`   | The address included on the whitelist                                                                                                                       |
| `tokens`  | `string[]` | A list of tokens that the whitelist allows for transferring to the address with. If this field is undefined, then the address is whitelisted for all tokens |

**Example Response**:

```typescript theme={"system"}
[
  {
    destinations: {
      address: '0xabc',
      tokens: ['USDC', 'ETH'],
    },
    enforcesAddressWhitelist: true,
  },
];
```

**Example**:

```typescript theme={"system"}
const { getExchangeWhitelistedDestinations } = useExchangeAccounts();

// Get the whitelisted destinations for an exchange
const destinations = await getExchangeWhitelistedDestinations({
  exchange: ExchangeKeyEnum.Kraken,
});
```

### 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**:

```typescript theme={"system"}
[
  {
    id: 'acc-1',
    exchange: ExchangeKeyEnum.Coinbase,
    balances: [
      {
        currency: 'USDC',
        balance: 1,
      },
    ],
  },
  {
    id: 'acc-2',
    exchange: ExchangeKeyEnum.Coinbase,
    balances: [
      {
        currency: 'BTC',
        balance: 1,
      },
    ],
  },
];
```

**Example**:

```typescript theme={"system"}
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

```typescript theme={"system"}
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