Withdrawal Operations

curl -X POST "https://api.example.com/v1/wallet/internal/withdraw" \
  -H "x-client-key: YOUR_PUBLIC_KEY" \
  -H "Authorization: Bearer USER_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "100.50",
    "recipientAddrss": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    "recipientMemo": null,
    "sourceAddress": "0x0a4b21fa733e9aeaddbf070302a85c559de13c4d",
    "sourceMemo": null,
    "currency": "usdc"
  }'

curl -X GET "https://api.example.com/v1/wallet/internal" \
  -H "x-client-key: YOUR_PUBLIC_KEY" \
  -H "Authorization: Bearer USER_ACCESS_TOKEN"

curl -X GET "https://api.example.com/v1/wallet/history?walletId=098aeb90&walletType=INTERNAL&walletCurrency=usdc&page=0" \
  -H "x-client-key: YOUR_PUBLIC_KEY" \
  -H "Authorization: Bearer USER_ACCESS_TOKEN"

async function withdrawToWhitelist(userToken, currency, amount, recipientIndex = 0) {
  // 1. Get internal wallets
  const walletsResponse = await fetch(
    'https://api.example.com/v1/wallet/internal',
    {
      headers: {
        'x-client-key': 'YOUR_PUBLIC_KEY',
        'Authorization': `Bearer ${userToken}`
      }
    }
  );
  const wallets = await walletsResponse.json();

  // 2. Find source wallet
  const sourceWallet = wallets.find(w => w.currency === currency);
  if (!sourceWallet) {
    throw new Error(`No ${currency} wallet found`);
  }

  // 3. Check balance
  if (parseFloat(sourceWallet.balance) < parseFloat(amount)) {
    throw new Error('Insufficient balance');
  }

  // 4. Get whitelisted addresses
  const whitelistResponse = await fetch(
    `https://api.example.com/v1/wallet/whitelist?currency=${currency}`,
    {
      headers: {
        'x-client-key': 'YOUR_PUBLIC_KEY',
        'Authorization': `Bearer ${userToken}`
      }
    }
  );
  const whitelisted = await whitelistResponse.json();

  if (whitelisted.length === 0) {
    throw new Error('No whitelisted addresses. Please add one first.');
  }

  const recipient = whitelisted[recipientIndex];

  // 5. Execute withdrawal
  const withdrawResponse = await fetch(
    'https://api.example.com/v1/wallet/internal/withdraw',
    {
      method: 'POST',
      headers: {
        'x-client-key': 'YOUR_PUBLIC_KEY',
        'Authorization': `Bearer ${userToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        amount: amount.toString(),
        recipientAddrss: recipient.walletAddress,
        recipientMemo: recipient.walletMemo,
        sourceAddress: sourceWallet.address,
        sourceMemo: sourceWallet.addressMemo,
        currency: currency
      })
    }
  );

  if (!withdrawResponse.ok) {
    const error = await withdrawResponse.json();
    throw new Error(error.message);
  }

  return await withdrawResponse.json();
}

// Usage
try {
  const result = await withdrawToWhitelist(userToken, 'usdc', '100.50');
  console.log('Withdrawal successful:', result);
} catch (error) {
  console.error('Withdrawal failed:', error.message);
}

import { useState, useEffect } from 'react';

function WithdrawalForm({ userToken, currency }) {
  const [wallets, setWallets] = useState([]);
  const [whitelisted, setWhitelisted] = useState([]);
  const [amount, setAmount] = useState('');
  const [selectedAddress, setSelectedAddress] = useState('');
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

  useEffect(() => {
    fetchData();
  }, [currency]);

  const fetchData = async () => {
    const [walletsRes, whitelistRes] = await Promise.all([
      fetch('https://api.example.com/v1/wallet/internal', {
        headers: {
          'x-client-key': 'YOUR_PUBLIC_KEY',
          'Authorization': `Bearer ${userToken}`
        }
      }),
      fetch(`https://api.example.com/v1/wallet/whitelist?currency=${currency}`, {
        headers: {
          'x-client-key': 'YOUR_PUBLIC_KEY',
          'Authorization': `Bearer ${userToken}`
        }
      })
    ]);

    const walletsData = await walletsRes.json();
    const whitelistData = await whitelistRes.json();

    setWallets(walletsData.filter(w => w.currency === currency));
    setWhitelisted(whitelistData);
  };

  const handleWithdraw = async (e) => {
    e.preventDefault();
    setLoading(true);
    setError('');

    try {
      const sourceWallet = wallets[0];
      const recipient = whitelisted.find(w => w.id === selectedAddress);

      if (parseFloat(amount) > parseFloat(sourceWallet.balance)) {
        throw new Error('Insufficient balance');
      }

      const response = await fetch(
        'https://api.example.com/v1/wallet/internal/withdraw',
        {
          method: 'POST',
          headers: {
            'x-client-key': 'YOUR_PUBLIC_KEY',
            'Authorization': `Bearer ${userToken}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            amount: amount,
            recipientAddrss: recipient.walletAddress,
            recipientMemo: recipient.walletMemo,
            sourceAddress: sourceWallet.address,
            sourceMemo: sourceWallet.addressMemo,
            currency: currency
          })
        }
      );

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.message);
      }

      alert('Withdrawal successful!');
      setAmount('');
      setSelectedAddress('');
      await fetchData();
    } catch (err) {
      setError(err.message);
    } finally {
      setLoading(false);
    }
  };

  const sourceWallet = wallets[0];

  return (
    <div className="withdrawal-form">
      <h3>Withdraw {currency.toUpperCase()}</h3>

      {sourceWallet && (
        <div className="balance-display">
          <label>Available Balance</label>
          <span className="balance">
            {sourceWallet.balance} {currency.toUpperCase()}
          </span>
        </div>
      )}

      {whitelisted.length === 0 ? (
        <div className="warning">
          No whitelisted addresses. Please add one before withdrawing.
        </div>
      ) : (
        <form onSubmit={handleWithdraw}>
          <div className="form-field">
            <label>Amount</label>
            <input
              type="number"
              step="0.01"
              value={amount}
              onChange={(e) => setAmount(e.target.value)}
              placeholder="0.00"
              required
            />
          </div>

          <div className="form-field">
            <label>Destination Address</label>
            <select
              value={selectedAddress}
              onChange={(e) => setSelectedAddress(e.target.value)}
              required
            >
              <option value="">Select address...</option>
              {whitelisted.map(addr => (
                <option key={addr.id} value={addr.id}>
                  {addr.name} - {addr.walletAddress.slice(0, 10)}...
                  {addr.walletMemo && ` (Memo: ${addr.walletMemo})`}
                </option>
              ))}
            </select>
          </div>

          {error && <div className="error">{error}</div>}

          <button type="submit" disabled={loading || !amount || !selectedAddress}>
            {loading ? 'Processing...' : 'Withdraw'}
          </button>
        </form>
      )}
    </div>
  );
}