Withdrawals

curl -X POST "https://api.dcepay.io/api/withdrawals" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "100.50",
    "currency": "USDT",
    "network": "TRX",
    "destination": "TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5",
    "description": "Payout for order 123",
    "referenceId": "order_123"
  }'

{
  "success": true,
  "message": "Withdrawal request received and will begin processing",
  "withdrawalId": "cmdl8u2xq0001abcd1234efgh",
  "status": "PENDING",
  "amount": "100.5",
  "currency": "USDT",
  "network": "TRX",
  "destination": "TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5",
  "feeInfo": {
    "grossAmount": "100.5",
    "netAmount": "98.5",
    "totalFees": "2",
    "feeBreakdown": {
      "baseFee": "1",
      "markupRate": "0",
      "markupAmount": "1",
      "networkFee": "1",
      "totalFee": "2"
    }
  }
}

async function createWithdrawal(currency, network, amount, destination, referenceId) {
  const response = await fetch('https://api.dcepay.io/api/withdrawals', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.DCE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      currency,
      network,
      amount,     // decimal string, e.g. "100.50"
      destination,
      referenceId
    })
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Withdrawal creation failed: ${error.message || error.error}`);
  }

  return response.json();
}

// Usage
const withdrawal = await createWithdrawal('USDT', 'TRX', '100.50',
  'TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5', 'order_123');

console.log('Withdrawal ID:', withdrawal.withdrawalId);
console.log('Total fees (charged on top):', withdrawal.feeInfo.totalFees);

curl -X GET "https://api.dcepay.io/api/withdrawals?status=CONFIRMED&page=1&limit=10" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "withdrawals": [
    {
      "id": "cmdl8u2xq0001abcd1234efgh",
      "amount": "100.5",
      "currency": "USDT",
      "status": "CONFIRMED",
      "createdAt": "2026-07-19T10:30:00Z",
      "destination": "TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5",
      "processedAt": "2026-07-19T10:31:12Z",
      "network": "TRX",
      "description": "Payout for order 123",
      "fee": "0",
      "commission": "1",
      "commissionRate": "0"
    }
  ],
  "pagination": {
    "total": 75,
    "page": 1,
    "limit": 10,
    "pages": 8
  }
}

curl -X GET "https://api.dcepay.io/api/balance" \
  -H "Authorization: Bearer YOUR_API_KEY"

{
  "balances": [
    {
      "currency": "USDT",
      "network": "TRX",
      "available": "250.75",
      "pending": "10",
      "withdrawalEnabled": true,
      "networkFee": "1",
      "maxWithdrawable": "249.75",
      "lastUpdatedAt": "2026-07-19T10:30:00Z"
    }
  ]
}

async function validateWithdrawalBalance(currency, network, amount) {
  const response = await fetch('https://api.dcepay.io/api/balance', {
    headers: {
      'Authorization': `Bearer ${process.env.DCE_API_KEY}`
    }
  });

  const { balances } = await response.json();
  const balance = balances.find(b => b.currency === currency && b.network === network);

  if (!balance) {
    throw new Error(`No ${currency} balance on ${network}`);
  }

  // Remember: total debit = amount + commission + networkFee
  if (parseFloat(balance.maxWithdrawable) < parseFloat(amount)) {
    throw new Error(`Insufficient balance on ${network}. Max withdrawable: ${balance.maxWithdrawable} ${currency}`);
  }

  return true;
}

// For a 100 USDT withdrawal on TRX with a 1 USDT flat commission
// and a 1 USDT network fee:
const amount = 100;
const commission = 1;   // flat per-network fee (or amount × rate if percentage)
const networkFee = 1;   // quoted from the asset matrix at submission
const totalDebit = amount + commission + networkFee; // 102 USDT debited
// Destination receives the full 100 USDT

GET /api/admin/withdrawal-fees
Authorization: Bearer <admin-api-key>

POST /api/admin/withdrawal-fees
Authorization: Bearer <admin-api-key>
Content-Type: application/json

{
  "baseFee": "1.5",
  "markupRate": "0.02",
  "enabled": true
}

{
  "feeInfo": {
    "grossAmount": "100",
    "netAmount": "98",
    "totalFees": "2",
    "feeBreakdown": {
      "baseFee": "1",
      "markupRate": "0",
      "markupAmount": "1",
      "networkFee": "1",
      "totalFee": "2"
    }
  }
}

{
  "type": "withdrawal",
  "withdrawalId": "cmdl8u2xq0001abcd1234efgh",
  "amount": "100.5",
  "currency": "USDT",
  "status": "confirmed",
  "txHash": "3f7a9c...",
  "referenceId": "order_123",
  "address": "TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5",
  "identifier": "order_123",
  "feeCharges": {
    "amount": "1",
    "percentage": "0",
    "type": "FIXED_AMOUNT",
    "networkFee": "1"
  },
  "receivableAmount": "99.5",
  "eventId": "cmdl8u2xq0002abcd1234efgh"
}

{
  "type": "withdrawal",
  "withdrawalId": "cmdl8u2xq0001abcd1234efgh",
  "amount": "100.5",
  "currency": "USDT",
  "status": "failed",
  "reason": "Withdrawal failed",
  "txHash": "3f7a9c...",
  "referenceId": "order_123",
  "address": "TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5",
  "identifier": "order_123",
  "eventId": "cmdl8u2xq0003abcd1234efgh"
}

{
  "error": "Insufficient balance",
  "message": "Insufficient USDT balance on TRX. Deposits and withdrawals are per-chain: funds on other networks cannot be used.",
  "available": "50.25",
  "requested": "100.50",
  "currency": "USDT",
  "network": "TRX",
  "feeInfo": {
    "grossAmount": "100.5",
    "netAmount": "98.5",
    "totalFees": "2",
    "feeBreakdown": {
      "baseFee": "1",
      "markupRate": "0",
      "markupAmount": "1",
      "networkFee": "1",
      "totalFee": "2"
    }
  }
}

{
  "error": "Duplicate referenceId",
  "message": "A withdrawal with this referenceId already exists for your merchant account. Use a new referenceId to submit a new withdrawal."
}

function validateAddress(network, address) {
  const patterns = {
    'TRX': /^T[a-zA-Z0-9]{33}$/,
    'ETH': /^0x[a-fA-F0-9]{40}$/,
    'BNB': /^0x[a-fA-F0-9]{40}$/
  };

  const pattern = patterns[network];
  if (!pattern) {
    throw new Error(`Unsupported network: ${network}`);
  }

  if (!pattern.test(address)) {
    throw new Error(`Invalid ${network} address: ${address}`);
  }

  return true;
}

async function safeWithdrawal(currency, network, amount, destination, referenceId) {
  // 1. Validate address
  validateAddress(network, destination);

  // 2. Check balance on the target chain
  await validateWithdrawalBalance(currency, network, amount);

  // 3. Create withdrawal
  const withdrawal = await createWithdrawal(currency, network, amount, destination, referenceId);

  // 4. Log withdrawal
  console.log(`Withdrawal created: ${withdrawal.withdrawalId}`);
  console.log(`Amount: ${withdrawal.amount} ${currency} on ${network}`);
  console.log(`Fees (on top): ${withdrawal.feeInfo.totalFees} ${currency}`);

  return withdrawal;
}

async function createWithdrawalIdempotent(currency, network, amount, destination, orderId) {
  const response = await fetch('https://api.dcepay.io/api/withdrawals', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.DCE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      currency,
      network,
      amount,
      destination,
      referenceId: orderId  // your idempotency key, unique per merchant
    })
  });

  if (response.status === 409) {
    // Already submitted — do NOT retry with a new referenceId unless you
    // intend to create a second payout.
    console.log(`Withdrawal for ${orderId} already exists`);
    return null;
  }

  return response.json();
}

app.post('/webhooks', async (req, res) => {
  const event = req.headers['x-webhook-event'];
  const payload = req.body;

  // Deduplicate — the same eventId may be delivered more than once
  if (await alreadyProcessed(payload.eventId)) {
    return res.status(200).json({ ok: true });
  }

  switch (event) {
    case 'withdrawal.confirmed':
      await handleWithdrawalConfirmed(payload);
      break;
    case 'withdrawal.failed':
      await handleWithdrawalFailed(payload);
      break;
    default:
      console.log(`Unhandled webhook event: ${event}`);
  }

  res.status(200).json({ ok: true });
});

async function handleWithdrawalConfirmed(payload) {
  const { withdrawalId, referenceId, amount, address, txHash } = payload;

  // referenceId is YOUR reference from the original request
  await updateWithdrawalStatus(referenceId, 'confirmed', txHash);
}

async function handleWithdrawalFailed(payload) {
  const { referenceId, reason } = payload;

  await updateWithdrawalStatus(referenceId, 'failed', null, reason);
  // Safe to retry the payout with the same referenceId
}

class WithdrawalService {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.dcepay.io/api';
  }

  async createWithdrawal(currency, network, amount, destination, referenceId, description) {
    const response = await fetch(`${this.baseUrl}/withdrawals`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        currency,
        network,
        amount,       // decimal string
        destination,
        referenceId,  // idempotency key, unique per merchant
        description
      })
    });

    const body = await response.json();

    if (response.status === 409) {
      throw new Error(`Duplicate referenceId: ${referenceId}`);
    }
    if (!response.ok) {
      throw new Error(`Withdrawal creation failed: ${body.message || body.error}`);
    }

    return body;
  }

  async getWithdrawals(filters = {}) {
    const params = new URLSearchParams(filters); // status, page, limit
    const response = await fetch(`${this.baseUrl}/withdrawals?${params}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    return response.json();
  }

  async getBalances() {
    const response = await fetch(`${this.baseUrl}/balance`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`
      }
    });

    return response.json();
  }
}

// Usage
const withdrawalService = new WithdrawalService(process.env.DCE_API_KEY);

try {
  const withdrawal = await withdrawalService.createWithdrawal(
    'USDT', 'TRX', '100.50',
    'TXYZa1b2c3d4e5f6g7h8i9j0k1l2m3n4o5',
    'order_123'
  );

  console.log('Withdrawal created:', withdrawal.withdrawalId);
  console.log('Fees charged on top:', withdrawal.feeInfo.totalFees);
} catch (error) {
  console.error('Withdrawal failed:', error.message);
}