import {
  createCoinbaseExchangeTransfer,
  getCoinbaseAccounts,
} from '@dynamic-labs-sdk/client';

// Get the user's Coinbase accounts
const accounts = await getCoinbaseAccounts();

// Create a transfer from the first account. Include any recipient info you
// already have as travelRuleData. See below for why.
const transfer = await createCoinbaseExchangeTransfer({
  accountId: accounts[0].id,
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 0.5,
  currency: 'ETH',
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
});

console.log('Transfer ID:', transfer.id);
console.log('Status:', transfer.status);

type ExchangeTransferResponse = {
  id: string;                  // Unique transfer ID
  exchangeAccountId?: string;  // The Coinbase account ID
  status?: string;             // Transfer status: 'pending', 'completed', 'failed', etc.
  amount: number;              // Amount transferred
  currency: string;            // Currency code
  createdAt?: Date;            // When the transfer was created
};

import {
  createCoinbaseExchangeTransfer,
  CoinbaseTransferMfaRequiredError,
} from '@dynamic-labs-sdk/client';

const transferParams = {
  accountId,
  amount: 0.5,
  currency: 'USDC',
  to,
  // Send known recipient info upfront. See Travel Rule information below.
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
};

try {
  await createCoinbaseExchangeTransfer(transferParams);
} catch (error) {
  if (error instanceof CoinbaseTransferMfaRequiredError) {
    // Coinbase already sent a code to the account holder. Prompt for it.
    const mfaCode = await promptUserForCoinbase2faCode();
    await createCoinbaseExchangeTransfer({ ...transferParams, mfaCode });
  }
}

type CoinbaseTravelRuleData = {
  beneficiaryWalletType?: 'WALLET_TYPE_SELF_HOSTED' | 'WALLET_TYPE_EXCHANGE'; // Is the destination wallet self-custody, or held at another exchange?
  isSelfTransfer?: 'IS_SELF_TRUE' | 'IS_SELF_FALSE'; // Is the destination wallet also the sender's own?
  beneficiaryName?: string;                 // Recipient's full legal name
  beneficiaryCountry?: string;               // Recipient's country, as an ISO 3166-1 alpha-2 code (e.g. "US")
  beneficiaryFinancialInstitution?: string;  // Recipient exchange's VASP ID (only needed if beneficiaryWalletType is 'WALLET_TYPE_EXCHANGE')
  beneficiaryAddress?: {
    address1?: string;
    city?: string;
    country?: string;
    postalCode?: string;
    state?: string;
  };
  transferPurpose?: string;                  // Free-text reason for the transfer (e.g. "Rent")
};

import {
  createCoinbaseExchangeTransfer,
  CoinbaseTravelRuleRequiredError,
} from '@dynamic-labs-sdk/client';

// Good: include any known recipient info from the start.
const transferParams = {
  accountId,
  amount: 0.5,
  currency: 'USDC',
  to,
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
};

try {
  await createCoinbaseExchangeTransfer(transferParams);
} catch (error) {
  if (error instanceof CoinbaseTravelRuleRequiredError) {
    // e.g. [{ name: 'BENEFICIARY_WALLET_TYPE', description: '...' }, ...]
    const travelRuleData = await promptUserForTravelRuleFields(error.missingFields);
    await createCoinbaseExchangeTransfer({
      ...transferParams,
      travelRuleData: { ...transferParams.travelRuleData, ...travelRuleData },
    });
  }
}

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

// Transfer USDC to Polygon
const transfer = await createCoinbaseExchangeTransfer({
  accountId: 'acc_123',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 100,
  currency: 'USDC',
  networkObject: {
    chainName: 'EVM',
    networkId: '137', // Polygon
  },
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
});

import { createCoinbaseExchangeTransfer } from '@dynamic-labs-sdk/client';
import { v4 as uuidv4 } from 'uuid';

const createSafeTransfer = async (params) => {
  const transfer = await createCoinbaseExchangeTransfer({
    ...params,
    id: uuidv4(), // Idempotency key
  });

  return transfer;
};

// If the network fails and you retry, the same transfer is returned
// instead of creating a duplicate
const transfer = await createSafeTransfer({
  accountId: 'acc_123',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 0.5,
  currency: 'ETH',
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
});

import {
  createCoinbaseExchangeTransfer,
  CoinbaseTransferMfaRequiredError,
  CoinbaseTransferMfaFailedError,
  CoinbaseTravelRuleRequiredError,
} from '@dynamic-labs-sdk/client';

const executeTransfer = async (baseParams) => {
  let params = { ...baseParams };

  // Up to 3 attempts: the original request, plus one retry per extra
  // requirement Coinbase reports back.
  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      return await createCoinbaseExchangeTransfer(params);
    } catch (error) {
      if (error instanceof CoinbaseTransferMfaRequiredError) {
        const mfaCode = await promptUserForCoinbase2faCode();
        params = { ...params, mfaCode };
      } else if (error instanceof CoinbaseTransferMfaFailedError) {
        // Wrong or expired code. Drop it so Coinbase sends a fresh one.
        const { mfaCode, ...rest } = params;
        params = rest;
      } else if (error instanceof CoinbaseTravelRuleRequiredError) {
        const travelRuleData = await promptUserForTravelRuleFields(
          error.missingFields
        );
        // Body changed. Coinbase invalidates any mfaCode issued for the
        // previous version of this request, so drop it too.
        const { mfaCode, ...rest } = params;
        params = {
          ...rest,
          travelRuleData: { ...rest.travelRuleData, ...travelRuleData },
        };
      } else {
        throw error;
      }
    }
  }

  throw new Error('Transfer did not complete after 3 attempts');
};

// Usage
const transfer = await executeTransfer({
  accountId: accounts[0].id,
  amount: 0.5,
  currency: 'ETH',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  // Sending known recipient info upfront skips a Travel Rule round trip
  // entirely when it's the only extra thing this transfer needs.
  travelRuleData: { beneficiaryName: 'Jane Doe', beneficiaryCountry: 'US' },
});

import { useState } from 'react';
import { createCoinbaseExchangeTransfer } from '@dynamic-labs-sdk/client';

const TransferButton = ({
  accountId,
  currency,
  destination,
  amount,
  recipientInfo, // Optional: { beneficiaryName, beneficiaryCountry, ... }
  onSuccess,
  onError,
}) => {
  const [submitting, setSubmitting] = useState(false);

  const handleTransfer = async () => {
    setSubmitting(true);

    try {
      const transfer = await createCoinbaseExchangeTransfer({
        accountId,
        to: destination,
        amount: parseFloat(amount),
        currency,
        travelRuleData: recipientInfo,
      });

      onSuccess(transfer);
    } catch (error) {
      onError(error);
    } finally {
      setSubmitting(false);
    }
  };

  return (
    <button onClick={handleTransfer} disabled={submitting}>
      {submitting ? 'Processing...' : `Transfer ${amount} ${currency}`}
    </button>
  );
};