Cryptocurrency Exchange Platform

1pub struct MatchingEngine {
2    order_books: HashMap<TradingPair, OrderBook>,
3    execution_queue: LockFreeQueue<Execution>,
4    risk_manager: Arc<RiskManager>,
5}
6
7impl MatchingEngine {
8    pub async fn process_order(&mut self, order: Order) -> Result<OrderResponse> {
9        // Pre-trade risk check (non-blocking)
10        self.risk_manager.validate(&order).await?;
11        
12        // Match order (lock-free)
13        let book = self.order_books
14            .get_mut(&order.pair)
15            .ok_or(Error::InvalidPair)?;
16        
17        let executions = book.match_order(order)?;
18        
19        // Queue executions for settlement
20        for exec in executions {
21            self.execution_queue.push(exec)?;
22        }
23        
24        Ok(OrderResponse::Filled)
25    }
26}
27

1// Cache-optimized price level
2#[repr(align(64))]
3struct PriceLevel {
4    price: Decimal,
5    total_quantity: Decimal,
6    orders: VecDeque<Order>,
7}
8
9pub struct OrderBook {
10    bids: BTreeMap<Decimal, PriceLevel>,  // Descending
11    asks: BTreeMap<Decimal, PriceLevel>,  // Ascending
12    last_match_time: AtomicU64,
13}
14
15impl OrderBook {
16    pub fn match_order(&mut self, order: Order) -> Vec<Execution> {
17        let mut executions = Vec::new();
18        let mut remaining = order.quantity;
19        
20        let levels = match order.side {
21            Side::Buy => &mut self.asks,
22            Side::Sell => &mut self.bids,
23        };
24        
25        while remaining > Decimal::ZERO {
26            let level = match levels.first_entry() {
27                Some(entry) if can_match(&order, entry.key()) => entry,
28                _ => break,
29            };
30            
31            let matched = level.get_mut().match_quantity(remaining);
32            executions.push(Execution {
33                order_id: order.id,
34                price: *level.key(),
35                quantity: matched,
36                timestamp: now_nanos(),
37            });
38            
39            remaining -= matched;
40            
41            if level.get().total_quantity == Decimal::ZERO {
42                level.remove();
43            }
44        }
45        
46        executions
47    }
48}
49

1pub struct HotWallet {
2    // Hierarchical deterministic wallet
3    master_key: Arc<ExtendedKey>,
4    
5    // Per-currency balance limits
6    limits: HashMap<Currency, Decimal>,
7    
8    // Real-time monitoring
9    monitor: WalletMonitor,
10}
11
12impl HotWallet {
13    pub async fn process_withdrawal(
14        &self,
15        withdrawal: Withdrawal,
16    ) -> Result<Transaction> {
17        // Check balance limit
18        let balance = self.get_balance(withdrawal.currency).await?;
19        if balance < withdrawal.amount {
20            return Err(Error::InsufficientFunds);
21        }
22        
23        // Check daily limit
24        let limit = self.limits.get(&withdrawal.currency)
25            .ok_or(Error::CurrencyNotSupported)?;
26        
27        let daily_total = self.get_daily_withdrawals(withdrawal.currency).await?;
28        if daily_total + withdrawal.amount > *limit {
29            // Move to cold wallet approval queue
30            return self.queue_for_cold_wallet(withdrawal).await;
31        }
32        
33        // Create and sign transaction
34        let tx = self.create_transaction(withdrawal).await?;
35        let signed = self.sign_transaction(tx).await?;
36        
37        // Broadcast to blockchain
38        self.broadcast(signed).await
39    }
40}
41

1pub struct SecurityMiddleware {
2    rate_limiter: Arc<RateLimiter>,
3    fraud_detector: Arc<FraudDetector>,
4    audit_logger: Arc<AuditLogger>,
5}
6
7impl SecurityMiddleware {
8    pub async fn validate_request(
9        &self,
10        request: &Request,
11    ) -> Result<()> {
12        // Rate limiting
13        self.rate_limiter.check(request.user_id).await?;
14        
15        // Fraud detection
16        let risk_score = self.fraud_detector
17            .assess(request)
18            .await?;
19        
20        if risk_score > FRAUD_THRESHOLD {
21            self.audit_logger.log_suspicious(request).await;
22            return Err(Error::SuspiciousActivity);
23        }
24        
25        // Device fingerprinting
26        if !self.verify_device(request).await? {
27            // Require 2FA re-authentication
28            return Err(Error::DeviceVerificationRequired);
29        }
30        
31        Ok(())
32    }
33}
34

1class MarketDataBroadcaster {
2  private connections = new Map<string, Set<WebSocket>>();
3  private orderBooks = new Map<string, OrderBookSnapshot>();
4  
5  subscribe(ws: WebSocket, tradingPair: string) {
6    if (!this.connections.has(tradingPair)) {
7      this.connections.set(tradingPair, new Set());
8    }
9    this.connections.get(tradingPair)!.add(ws);
10    
11    // Send current order book snapshot
12    const snapshot = this.orderBooks.get(tradingPair);
13    if (snapshot) {
14      ws.send(JSON.stringify({
15        type: 'snapshot',
16        data: snapshot
17      }));
18    }
19  }
20  
21  broadcast(tradingPair: string, update: MarketUpdate) {
22    const subscribers = this.connections.get(tradingPair);
23    if (!subscribers) return;
24    
25    const message = JSON.stringify({
26      type: 'update',
27      data: update,
28      timestamp: Date.now()
29    });
30    
31    // Broadcast to all subscribers
32    for (const ws of subscribers) {
33      if (ws.readyState === WebSocket.OPEN) {
34        ws.send(message);
35      }
36    }
37  }
38}
39

1// Pre-compute likely price levels
2pub struct PredictiveCache {
3    cache: LruCache<(TradingPair, Decimal), PriceLevel>,
4    predictor: PricePredictor,
5}
6
7impl PredictiveCache {
8    pub fn warm_cache(&mut self, pair: TradingPair) {
9        let predictions = self.predictor.predict_levels(pair);
10        
11        for price in predictions {
12            let level = self.fetch_or_create(pair, price);
13            self.cache.put((pair, price), level);
14        }
15    }
16}
17

1// Settle executions across multiple chains simultaneously
2pub struct ParallelSettler {
3    workers: Vec<SettlementWorker>,
4    coordinator: Arc<Coordinator>,
5}
6
7impl ParallelSettler {
8    pub async fn settle_batch(
9        &self,
10        executions: Vec<Execution>,
11    ) -> Result<Vec<Settlement>> {
12        // Group by currency
13        let grouped = self.group_by_currency(executions);
14        
15        // Settle each currency in parallel
16        let futures: Vec<_> = grouped
17            .into_iter()
18            .map(|(currency, execs)| {
19                let worker = self.get_worker(currency);
20                worker.settle(execs)
21            })
22            .collect();
23        
24        // Wait for all settlements
25        let results = join_all(futures).await;
26        
27        // Aggregate results
28        results.into_iter()
29            .collect::<Result<Vec<_>>>()?
30    }
31}
32

1pub struct AdaptiveRateLimiter {
2    base_limit: u32,
3    current_limit: AtomicU32,
4    load_monitor: Arc<LoadMonitor>,
5}
6
7impl AdaptiveRateLimiter {
8    pub async fn check(&self, user_id: UserId) -> Result<()> {
9        let current_load = self.load_monitor.get_load().await;
10        
11        // Adjust limit based on system load
12        let limit = if current_load > 0.8 {
13            self.base_limit / 2  // Reduce during high load
14        } else if current_load < 0.4 {
15            self.base_limit * 2  // Increase during low load
16        } else {
17            self.base_limit
18        };
19        
20        self.current_limit.store(limit, Ordering::Relaxed);
21        
22        // Check against current limit
23        self.check_limit(user_id, limit).await
24    }
25}
26