Introduction: The Adversarial Frontier of Decentralized Systems

Reentrancy Attack Flow (Vulnerable Pattern):
┌─────────────────────────────────────────────────────────────────────┐
|  1. Attacker calls withdraw() on Victim Contract.                |
|                              ▼                                    |
|  2. Victim Contract checks balance: sufficient.                  |
|                              ▼                                    |
|  3. Victim Contract transfers ETH to Attacker (EXTERNAL CALL).    |
|                              ▼                                    |
|  4. Attacker's fallback function re-calls withdraw().             |
|                              ▼                                    |
|  5. Victim Contract checks balance: STILL sufficient (not yet    |
|     updated).                                                    |
|                              ▼                                    |
|  6. Repeat steps 3-5 until pool is drained.                      |
|                              ▼                                    |
|  7. Original transaction completes → balance FINALLY updated.    |
|     Too late: funds are already gone.                           |
└─────────────────────────────────────────────────────────────────────┘

function withdraw(uint amount) external {
    require(balance[msg.sender] >= amount);
    (bool success, ) = msg.sender.call{value: amount}(""); // Transfer first
    require(success);
    balance[msg.sender] -= amount; // Update AFTER
}

function withdraw(uint amount) external {
    require(balance[msg.sender] >= amount);     // CHECK
    balance[msg.sender] -= amount;              // EFFECT (update state)
    (bool success, ) = msg.sender.call{value: amount}(""); // INTERACTION
    require(success);
}

Smart Contract Security Testing Pipeline:
┌─────────────────────────────────────────────────────────────────────┐
|  1. Static Analysis (Slither, Mythril)                           |
|  ┌─────────────────────────────────────────────────────────────┐   |
|  │  Scans bytecode/AST for known anti-patterns and            │   |
|  │  uninitialized storage pointers.                           │   |
|  └─────────────────────────────────────────────────────────────┘   |
|                              ▼                                    |
|  2. Symbolic Execution                                           |
|  ┌─────────────────────────────────────────────────────────────┐   |
|  │  Treats inputs as symbolic variables; explores ALL        │   |
|  │  possible execution paths to prove violation conditions.  │   |
|  └─────────────────────────────────────────────────────────────┘   |
|                              ▼                                    |
|  3. Fuzz & Invariant Testing (Echidna, Foundry)                |
|  ┌─────────────────────────────────────────────────────────────┐   |
|  │  Injects thousands of random inputs to stress-test         │   |
|  │  invariants (e.g., "totalSupply always equals user sum").  │   |
|  └─────────────────────────────────────────────────────────────┘   |
|                              ▼                                    |
|  4. Formal Verification (Certora, Z3)                          |
|  ┌─────────────────────────────────────────────────────────────┐   |
|  │  Mathematical theorem proving: 100% certainty that         │   |
|  │  contract satisfies formal specifications across ALL       │   |
|  │  infinite states.                                          │   |
|  └─────────────────────────────────────────────────────────────┘   |
└─────────────────────────────────────────────────────────────────────┘

Invariant Example (Uniswap V2):
"Before and after any swap, the product of reserves (x * y) must
 remain constant (k), minus the protocol fee."

Fuzz testers automatically generate adversarial test cases to try and
break these mathematical invariants.

∀ states: P(state) ⇒ S(state)

MEV Taxonomy:
┌─────────────────────────────────────────────────────────────────────┐
|  MEV Type          │  Mechanism                                   |
|─────────────────────────────────────────────────────────────────────|
|  Arbitrage MEV     │  Detects DEX price discrepancies and        |
|                    │  executes atomic risk-free trades.           |
|─────────────────────────────────────────────────────────────────────|
|  Liquidation MEV   │  Races to liquidate under-collateralized    |
|                    │  loans, earning protocol bonuses.            |
|─────────────────────────────────────────────────────────────────────|
|  Sandwich Attack   │  Front-runs a user's large trade to drive   |
|                    │  price up, executes user's trade at high    |
|                    │  price, then back-runs to sell.             |
|─────────────────────────────────────────────────────────────────────|
|  Time- Bandit     │  Reorganizes past blocks to steal rewards   |
|  Attacks          │  (requires 51% hashrate).                    |
└─────────────────────────────────────────────────────────────────────┘

Π = Q × (P_sell - P_buy) - Gas_Cost

Sandwich Attack Flow:
┌─────────────────────────────────────────────────────────────────────┐
|  1. User submits a large trade (e.g., buy 100 ETH) to mempool.   |
|                              ▼                                    |
|  2. MEV bot detects the pending transaction.                     |
|                              ▼                                    |
|  3. Bot FRONT-RUNS: Buys ETH on DEX (drives price up).           |
|                              ▼                                    |
|  4. User's trade executes at the inflated price.                 |
|                              ▼                                    |
|  5. Bot BACK-RUNS: Sells ETH at the higher price,                |
|     pocketing the spread.                                        |
|                                                                  |
|  User experiences massive price slippage and worse execution.    |
└─────────────────────────────────────────────────────────────────────┘

Π_sandwich = Q_bot × (P_after - P_before) - Gas_Cost

MEV-Boost Architecture:
┌─────────────────────────────────────────────────────────────────────┐
|  1. Searchers: Discover MEV opportunities (arbitrage, liquida-    |
|     tions) and bundle transactions.                              |
|                              ▼                                    |
|  2. Builders: Aggregate bundles into full blocks. Submit sealed  |
|     blocks to relayers.                                          |
|                              ▼                                    |
|  3. Relayers: Verify block validity and relay to validators.      |
|                              ▼                                    |
|  4. Validators: Choose the highest-paying block (via auction)    |
|     and propose it to the network.                               |
|                              ▼                                    |
|  5. Validators earn: Block rewards + MEV auction proceeds.       |
|     Users benefit from privacy and reduced front-running.       |
└─────────────────────────────────────────────────────────────────────┘

import random
import math
from typing import Dict, List, Tuple

# -------------------- 1. REENTRANCY VULNERABILITY SIMULATION --------------------
class VulnerableBank:
    """
    Simulates a bank contract vulnerable to reentrancy.
    """
    def __init__(self):
        self.balances = {}  # address -> balance (in wei)
        self.total_deposits = 0
    
    def deposit(self, address: str, amount: float):
        self.balances[address] = self.balances.get(address, 0) + amount
        self.total_deposits += amount
    
    def withdraw_vulnerable(self, address: str, amount: float):
        """VULNERABLE: Transfers before updating balance."""
        if self.balances.get(address, 0) < amount:
            raise ValueError("Insufficient balance")
        
        # SIMULATE external call (reentrancy)
        # In real attack, this would re-call withdraw()
        self._external_transfer(address, amount)
        
        # Balance updated AFTER transfer (vulnerable!)
        self.balances[address] = self.balances.get(address, 0) - amount
        self.total_deposits -= amount
    
    def withdraw_secure(self, address: str, amount: float):
        """SECURE: Updates balance before transfer (Checks-Effects-Interactions)."""
        if self.balances.get(address, 0) < amount:
            raise ValueError("Insufficient balance")
        
        # EFFECT: Update balance first
        self.balances[address] = self.balances.get(address, 0) - amount
        self.total_deposits -= amount
        
        # INTERACTION: Transfer after state update
        self._external_transfer(address, amount)
    
    def _external_transfer(self, address: str, amount: float):
        """Simulates sending funds to external address."""
        # In a real attack, this would be a reentrant call
        pass

# Simulate reentrancy attack
def simulate_reentrancy():
    print("=" * 60)
    print("REENTRANCY ATTACK SIMULATION")
    print("=" * 60)
    
    bank = VulnerableBank()
    attacker = "0xATTACKER"
    victim = "0xVICTIM"
    
    # Victim deposits funds
    bank.deposit(victim, 1000)
    print(f"Victim balance: {bank.balances[victim]:.2f} ETH")
    
    # Attacker deposits to get a balance
    bank.deposit(attacker, 1)
    
    # Simulate attack: reentrant call (simplified)
    print("\nSimulating reentrancy attack on vulnerable withdraw...")
    try:
        # In real attack, the attacker's fallback would call withdraw again
        bank.withdraw_vulnerable(attacker, 1)
        print(f"Attacker balance after exploit: {bank.balances[attacker]:.2f} ETH")
        print(f"Total deposits remaining: {bank.total_deposits:.2f} ETH")
        print("✅ EXPLOIT SUCCESSFUL! (Vulnerable pattern)")
    except:
        print("❌ Exploit failed (secure pattern prevents it)")

# -------------------- 2. INTEGER OVERFLOW SIMULATION --------------------
def simulate_overflow():
    print("\n" + "=" * 60)
    print("INTEGER OVERFLOW SIMULATION")
    print("=" * 60)
    
    # Simulate vulnerable uint8 (max = 255)
    max_uint8 = 255
    print(f"Max uint8 value: {max_uint8}")
    
    # Overflow example
    overflow_val = max_uint8 + 1
    print(f"255 + 1 = {overflow_val} (wraps to 0 in uint8)")
    
    # Underflow example
    underflow_val = 0 - 1
    print(f"0 - 1 = {underflow_val} (wraps to 255 in uint8)")
    
    # Precision loss example
    interest_rate = 0.035  # 3.5% APR
    principal = 1000
    # Integer division would truncate
    print(f"Principal: {principal}, Interest Rate: {interest_rate*100:.2f}%")
    print(f"Accurate interest: {principal * interest_rate:.2f}")
    print(f"If using integer division: {int(principal * interest_rate * 100) / 100:.2f} (truncated)")
    print("⚠️ Over multiple iterations, precision loss compounds.")

# -------------------- 3. MEV SANDWICH ATTACK SIMULATION --------------------
class MEV_Sandwich_Simulator:
    def __init__(self, pool_reserve_x: float, pool_reserve_y: float):
        self.reserve_x = pool_reserve_x
        self.reserve_y = pool_reserve_y
        self.k = pool_reserve_x * pool_reserve_y
    
    def get_price(self) -> float:
        """Current price of Token X in terms of Token Y."""
        return self.reserve_y / self.reserve_x
    
    def simulate_swap(self, delta_x: float, fee: float = 0.003) -> float:
        """
        Simulate a swap of delta_x of Token X for Token Y.
        Returns: amount of Token Y received.
        """
        delta_x_fee = delta_x * (1 - fee)
        delta_y = (self.reserve_y * delta_x_fee) / (self.reserve_x + delta_x_fee)
        return delta_y
    
    def sandwich_attack(self, user_delta_x: float) -> Dict:
        """
        Simulate a sandwich attack on a user's trade.
        """
        # 1. Store initial state
        initial_price = self.get_price()
        
        # 2. Front-run: Bot buys before user
        bot_frontrun_size = user_delta_x * 0.2  # 20% of user trade
        self.reserve_x += bot_frontrun_size
        self.reserve_y -= self.simulate_swap(bot_frontrun_size)
        price_after_frontrun = self.get_price()
        
        # 3. User trade executes
        user_delta_y = self.simulate_swap(user_delta_x)
        self.reserve_x += user_delta_x
        self.reserve_y -= user_delta_y
        price_after_user = self.get_price()
        
        # 4. Back-run: Bot sells for profit
        bot_backrun_size = bot_frontrun_size
        self.reserve_x -= bot_backrun_size
        self.reserve_y += self.simulate_swap(bot_backrun_size)
        final_price = self.get_price()
        
        # 5. Calculate profits
        bot_profit = (price_after_frontrun - initial_price) * bot_frontrun_size
        user_slippage = (price_after_user - initial_price) / initial_price * 100
        
        return {
            'bot_profit': bot_profit,
            'user_slippage_pct': user_slippage,
            'initial_price': initial_price,
            'price_after_frontrun': price_after_frontrun,
            'price_after_user': price_after_user,
            'final_price': final_price,
            'sandwich_successful': bot_profit > 0
        }

def simulate_mev():
    print("\n" + "=" * 60)
    print("MEV SANDWICH ATTACK SIMULATION")
    print("=" * 60)
    
    # Pool with 100 ETH and 200,000 USDC
    pool = MEV_Sandwich_Simulator(
        pool_reserve_x=100,
        pool_reserve_y=200_000
    )
    
    print(f"Initial ETH/USDC price: {pool.get_price():.2f}")
    
    # User wants to buy 10 ETH
    user_trade = 10
    result = pool.sandwich_attack(user_trade)
    
    print(f"\nUser trade size: {user_trade} ETH")
    print(f"Bot front-run size: {user_trade * 0.2:.1f} ETH")
    print(f"\nBot profit from sandwich: ${result['bot_profit']:.2f}")
    print(f"User price slippage: {result['user_slippage_pct']:.2f}%")
    print(f"Sandwich successful: {'✅ YES' if result['sandwich_successful'] else '❌ NO'}")
    
    # Show price progression
    print("\nPrice Progression:")
    print(f"  Initial:           ${result['initial_price']:.2f}")
    print(f"  After front-run:   ${result['price_after_frontrun']:.2f}")
    print(f"  After user trade:  ${result['price_after_user']:.2f}")
    print(f"  Final (back-run):  ${result['final_price']:.2f}")

# -------------------- 4. INVARIANT TESTING SIMULATION --------------------
def invariant_test():
    print("\n" + "=" * 60)
    print("INVARIANT TESTING SIMULATION")
    print("=" * 60)
    
    # Define invariant: User balances MUST equal total pool
    def invariant_check(balances: Dict[str, float], total: float) -> bool:
        return sum(balances.values()) == total
    
    # Simulate fuzz testing
    balances = {'user1': 100, 'user2': 200, 'user3': 50}
    total = 350
    
    print(f"Initial balances: {balances}")
    print(f"Total: {total}")
    print(f"Invariant holds: {invariant_check(balances, total)}")
    
    # Fuzz: Randomly perturb balances and test invariant
    for i in range(5):
        # Simulate a transfer
        sender = random.choice(list(balances.keys()))
        receiver = random.choice([k for k in balances.keys() if k != sender])
        amount = random.uniform(1, 10)
        
        balances[sender] -= amount
        balances[receiver] += amount
        
        # Invariant should hold after any valid operation
        holds = invariant_check(balances, total)
        print(f"After transfer {amount:.2f} from {sender} to {receiver}: Invariant = {holds}")
        if not holds:
            print("🚨 INVARIANT BROKEN! Vulnerability detected.")
            break

# -------------------- 5. EXECUTION --------------------
if __name__ == "__main__":
    simulate_reentrancy()
    simulate_overflow()
    simulate_mev()
    invariant_test()