Currency Exchange Rate Slippage: How Real-Time APIs Reduce Trading Losses by 78%

// Slippage monitoring and calculation
interface SlippageMetrics {
  quotedRate: number;
  executedRate: number;
  slippagePercent: number;
  slippageAmount: number;
  timestamp: number;
}

export function calculateSlippage(
  quotedRate: number,
  executedRate: number,
  amount: number
): SlippageMetrics {
  const slippagePercent = ((executedRate - quotedRate) / quotedRate) * 100;
  const slippageAmount = (amount * Math.abs(executedRate - quotedRate));

  return {
    quotedRate,
    executedRate,
    slippagePercent,
    slippageAmount,
    timestamp: Date.now()
  };
}

// Track slippage over time for analysis
const slippageHistory: SlippageMetrics[] = [];

export function recordSlippage(metrics: SlippageMetrics) {
  slippageHistory.push(metrics);

  // Alert if slippage exceeds threshold
  if (Math.abs(metrics.slippagePercent) > 0.5) {
    console.warn(`High slippage detected: ${metrics.slippagePercent.toFixed(4)}%`);
  }
}

export function getAverageSlippage(timeWindowMs: number = 3600000): number {
  const cutoff = Date.now() - timeWindowMs;
  const recent = slippageHistory.filter(m => m.timestamp > cutoff);

  if (recent.length === 0) return 0;

  const total = recent.reduce((sum, m) => sum + Math.abs(m.slippagePercent), 0);
  return total / recent.length;
}

// Rate locking mechanism to prevent slippage
import { CurrencyExchangeClient } from '@currency-exchange/sdk';

const client = new CurrencyExchangeClient({
  apiKey: process.env.CURRENCY_API_KEY,
  timeout: 50 // Sub-50ms for real-time accuracy
});

interface LockedRate {
  rate: number;
  pair: string;
  lockedAt: number;
  expiresAt: number;
  lockId: string;
}

// Rate lock storage (use Redis in production)
const rateLocks = new Map<string, LockedRate>();

export async function getLockedRate(
  from: string,
  to: string,
  lockDurationMs: number = 30000 // 30-second default lock
): Promise<LockedRate> {
  const pair = `${from}/${to}`;

  // Check for existing valid lock
  const existing = rateLocks.get(pair);
  if (existing && existing.expiresAt > Date.now()) {
    return existing;
  }

  // Fetch fresh rate
  const response = await client.getRate({
    from,
    to,
    amount: 1
  });

  const lock: LockedRate = {
    rate: response.rate,
    pair,
    lockedAt: Date.now(),
    expiresAt: Date.now() + lockDurationMs,
    lockId: crypto.randomUUID()
  };

  rateLocks.set(pair, lock);
  return lock;
}

export function validateRateLock(lock: LockedRate): boolean {
  return lock.expiresAt > Date.now();
}