# CEX risk: Your funds sit in the exchange's wallet
# If the exchange goes down (FTX, Mt. Gox), you lose everything

# DEX advantage: Funds stay in YOUR wallet until the swap executes
# Smart contract is audited and immutable
# No single point of failure

# Example: Check if your funds are actually in escrow
from web3 import Web3
w3 = Web3(Web3.HTTPProvider(rpc_url))
contract = w3.eth.contract(address=escrow_addr, abi=abi)

# Verify on-chain — don't trust, verify
locked_amount = contract.functions.getOrderAmount(order_id).call()
print(f"Verified on-chain: {locked_amount / 1e6} USDC locked")

# Flash loan → Swap on DEX A → Swap on DEX B → Repay
# This is impossible on centralized exchanges

# Example: Check arbitrage between two DEX pools
def check_arb(pool_a_reserves, pool_b_reserves, amount):
    out_a = calculate_output(pool_a_reserves, amount)
    out_b = calculate_output(pool_b_reserves, out_a)
    profit = out_b - amount
    return profit if profit > gas_cost else 0

CEX order flow:
  Client → API → Matching Engine → Confirmation
  Total: 1-10ms

DEX order flow:
  Client → Sign TX → Broadcast → Mempool → Block → Confirmation
  Total: 2,000-15,000ms (2-15 seconds)

class HybridTradingEngine:
    def __init__(self):
        self.cex = CentralizedClient()  # For execution
        self.dex = DecentralizedClient()  # For settlement

    async def execute_strategy(self, signal):
        # Fast execution on CEX
        if signal.urgency == 'high':
            await self.cex.place_order(signal)

        # Trustless settlement on DEX
        elif signal.requires_escrow:
            await self.dex.swap_with_escrow(signal)

        # Arbitrage between CEX and DEX
        elif signal.type == 'arb':
            await asyncio.gather(
                self.cex.place_order(signal.cex_leg),
                self.dex.swap(signal.dex_leg),
            )