Crypto Exchanges

User initiates crypto purchase
              ↓
Calculate fiat amount + fees
              ↓
Create FYATU collection request
              ↓
User pays from their Fyatu wallet
              ↓
Webhook confirms payment instantly
              ↓
Execute crypto purchase/transfer
              ↓
Credit crypto to user's wallet

User initiates crypto sale
              ↓
Lock/debit crypto from wallet
              ↓
Calculate fiat payout amount
              ↓
Call FYATU Payouts API
              ↓
Fiat sent instantly to user's Fyatu wallet
              ↓
Webhook confirms delivery
              ↓
Complete transaction

// User wants to buy $100 worth of BTC
const cryptoAmount = await getCryptoPrice('BTC', 100, 'USD');

const deposit = await fyatu.collections.create({
  amount: 100.00,
  currency: 'USD',
  reference: `BUY-${userId}-${Date.now()}`,
  description: `Purchase ${cryptoAmount} BTC`,
  customer: {
    email: user.email,
    name: user.fullName,
    externalId: userId
  },
  metadata: {
    userId: userId,
    cryptoCurrency: 'BTC',
    cryptoAmount: cryptoAmount,
    exchangeRate: 100 / cryptoAmount,
    type: 'on_ramp'
  },
  redirectUrl: 'https://yourexchange.com/buy/success',
  webhookUrl: 'https://yourexchange.com/webhooks/fyatu'
});

return { checkoutUrl: deposit.checkoutUrl };

// User sells 0.005 BTC for fiat
const fiatAmount = await calculateFiatValue('BTC', 0.005, 'USD');

// First, lock the crypto
await lockCrypto(userId, 'BTC', 0.005);

// Then initiate payout to user's Fyatu wallet
const payout = await fyatu.payouts.create({
  amount: fiatAmount,
  currency: 'USD',
  reference: `SELL-${userId}-${Date.now()}`,
  description: 'Crypto sale proceeds',
  recipient: {
    accountId: user.fyatuClientId  // User's Fyatu account ID
  },
  metadata: {
    userId: userId,
    cryptoCurrency: 'BTC',
    cryptoAmount: 0.005,
    type: 'off_ramp'
  }
});

// Buyer creates order to buy BTC from a seller
const order = await createP2POrder({
  buyer: buyerId,
  seller: sellerId,
  cryptoAmount: 0.01,
  fiatAmount: 500,
  currency: 'USD'
});

// Create collection for buyer's fiat payment
const payment = await fyatu.collections.create({
  amount: 500.00,
  currency: 'USD',
  reference: `P2P-${order.id}`,
  description: `P2P BTC purchase - Order #${order.id}`,
  customer: {
    email: buyer.email,
    externalId: buyerId
  },
  metadata: {
    orderId: order.id,
    type: 'p2p_escrow'
  },
  // Auto-expire if not paid
  expiresAt: new Date(Date.now() + 30 * 60 * 1000).toISOString()
});

// Buyer pays, crypto released to buyer, fiat released to seller

// On payment confirmation, release crypto and fiat
app.post('/webhooks/fyatu', async (req, res) => {
  const event = req.body;

  if (event.type === 'collection.completed') {
    const orderId = event.data.metadata.orderId;
    const order = await getP2POrder(orderId);

    // Release crypto to buyer
    await transferCrypto(order.seller, order.buyer, order.cryptoAmount);

    // Release fiat to seller
    await fyatu.payouts.create({
      amount: order.fiatAmount * 0.99, // Minus platform fee
      currency: order.currency,
      reference: `P2P-SETTLE-${orderId}`,
      recipient: { accountId: order.seller.fyatuAccountId }
    });

    await completeOrder(orderId);
  }

  res.status(200).send('OK');
});

// Handle expired payment attempts
if (event.type === 'collection.expired') {
  const order = await getOrder(event.data.metadata.orderId);

  // Cancel the order
  await cancelOrder(order.id);

  // Notify user
  await sendNotification(order.userId, 'Payment expired. Please try again.');
}

// Handle failed off-ramp payouts
if (event.type === 'payout.failed') {
  const trade = await getTrade(event.data.metadata.tradeId);

  // Reverse the crypto sale
  await unlockCrypto(trade.userId, trade.cryptoCurrency, trade.cryptoAmount);

  // Notify user
  await sendNotification(trade.userId,
    `Payout failed: ${event.data.failureReason}. Crypto has been returned.`
  );
}