🔐 DeFi & Blockchain Security Architecture

// Lending Pool Core Logic
contract LendingPool {
    struct Reserve {
        uint128 liquidityRate;
        uint128 borrowRate;
        uint128 liquidityIndex;
        uint40 lastUpdateTimestamp;
        address aTokenAddress;
    }
    
    mapping(address => Reserve) public reserves;
    
    function deposit(address asset, uint256 amount) external {
        Reserve storage reserve = reserves[asset];
        
        // Update reserve state
        updateState(reserve);
        
        // Transfer tokens
        IERC20(asset).transferFrom(msg.sender, aToken, amount);
        
        // Mint aTokens
        IAToken(reserve.aTokenAddress).mint(msg.sender, amount);
        
        emit Deposit(asset, msg.sender, amount);
    }
    
    function borrow(
        address asset,
        uint256 amount,
        address onBehalfOf
    ) external {
        Reserve storage reserve = reserves[asset];
        
        // Check collateral
        require(
            getUserCollateralValue(onBehalfOf) >= 
            amount * reserve.collateralFactor,
            "Insufficient collateral"
        );
        
        // Execute borrow
        IERC20(asset).transfer(msg.sender, amount);
        updateDebt(onBehalfOf, amount);
    }
}

// Uniswap V3 Concentrated Liquidity
contract UniswapV3Pool {
    struct Position {
        uint128 liquidity;
        uint256 feeGrowthInside0LastX128;
        uint256 feeGrowthInside1LastX128;
        uint128 tokensOwed0;
        uint128 tokensOwed1;
    }
    
    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96
    ) external returns (int256 amount0, int256 amount1) {
        // Lock for reentrancy
        require(unlocked, "LOCKED");
        unlocked = false;
        
        SwapState memory state = SwapState({
            amountSpecifiedRemaining: amountSpecified,
            amountCalculated: 0,
            sqrtPriceX96: slot0.sqrtPriceX96,
            tick: slot0.tick,
            liquidity: liquidity
        });
        
        // Execute swap through ticks
        while (state.amountSpecifiedRemaining != 0) {
            // Cross tick if necessary
            // Calculate amounts
            // Update state
        }
        
        unlocked = true;
        return (amount0, amount1);
    }
}

// Universal DEX Router
contract UniversalRouter {
    struct Route {
        address[] pools;
        uint24[] fees;
        address[] tokens;
    }
    
    function universalSwap(
        Route calldata route,
        uint256 amountIn,
        uint256 amountOutMin
    ) external returns (uint256 amountOut) {
        // MEV Protection
        require(tx.gasprice <= maxGasPrice, "Gas too high");
        
        for (uint i = 0; i < route.pools.length; i++) {
            if (isUniswapV2(route.pools[i])) {
                amountOut = _v2Swap(route.pools[i], amountIn);
            } else if (isUniswapV3(route.pools[i])) {
                amountOut = _v3Swap(route.pools[i], amountIn, route.fees[i]);
            } else if (isCurve(route.pools[i])) {
                amountOut = _curveSwap(route.pools[i], amountIn);
            }
            amountIn = amountOut;
        }
        
        require(amountOut >= amountOutMin, "Slippage");
        return amountOut;
    }
}

// Storage Packing
contract GasOptimized {
    // Pack in single slot (32 bytes)
    struct User {
        uint128 balance;    // 16 bytes
        uint64 lastUpdate;  // 8 bytes  
        uint32 id;          // 4 bytes
        bool active;        // 1 byte
        // Total: 29 bytes < 32 bytes (1 slot)
    }
    
    // Use calldata for read-only arrays
    function process(uint[] calldata data) external {
        // More efficient than memory
    }
    
    // Cache storage reads
    function efficient() external {
        uint256 cached = expensive;  // 1 SLOAD
        // Use cached multiple times
    }
    
    // Use custom errors (cheaper than strings)
    error InsufficientBalance(uint256 required, uint256 available);
    
    // Unchecked when overflow impossible
    function increment(uint256 x) external pure returns (uint256) {
        unchecked {
            return x + 1; // Save gas when safe
        }
    }
}

contract SecureBridge {
    mapping(bytes32 => bool) public processedMessages;
    mapping(uint256 => bytes32) public chainRoots;
    
    modifier nonReplayable(bytes32 messageHash) {
        require(!processedMessages[messageHash], "Replayed");
        processedMessages[messageHash] = true;
        _;
    }
    
    function processBridgeMessage(
        BridgeMessage calldata message,
        bytes32[] calldata proof
    ) external nonReplayable(message.hash) {
        // Verify message authenticity
        require(
            message.hash == keccak256(abi.encode(
                message.nonce,
                message.sender,
                message.recipient,
                message.amount,
                message.srcChain,
                message.dstChain
            )),
            "Invalid hash"
        );
        
        // Verify merkle proof
        require(
            MerkleProof.verify(
                proof,
                chainRoots[message.srcChain],
                message.hash
            ),
            "Invalid proof"
        );
        
        // Execute transfer
        _mintOrUnlock(message.token, message.recipient, message.amount);
    }
}

contract SecureOracle {
    uint256 constant STALENESS = 3600; // 1 hour
    uint256 constant MAX_DEVIATION = 500; // 5%
    
    function getSecurePrice(address token) 
        external view returns (uint256) {
        uint256[] memory prices = new uint256[](3);
        
        // Get from multiple oracles
        prices[0] = chainlink.latestAnswer();
        prices[1] = uniswapTWAP.consult(token);
        prices[2] = band.getReferenceData(token);
        
        // Calculate median
        uint256 median = getMedian(prices);
        
        // Check for manipulation
        for (uint i = 0; i < prices.length; i++) {
            uint256 deviation = abs(prices[i] - median) * 10000 / median;
            require(deviation <= MAX_DEVIATION, "Price manipulation");
        }
        
        return median;
    }
}

// Flash Loan Defense Mechanisms
contract FlashLoanProtected {
    bool private locked;
    uint256 private lastBlock;
    
    modifier noFlashLoan() {
        // Block same-block interactions
        require(lastBlock != block.number, "Same block");
        lastBlock = block.number;
        _;
    }
    
    modifier nonReentrant() {
        require(!locked, "Reentrant");
        locked = true;
        _;
        locked = false;
    }
    
    // Use TWAP instead of spot price
    function resistantPrice() view returns (uint256) {
        uint256 spot = getSpotPrice();
        uint256 twap = getTWAPPrice();
        
        // Weight towards TWAP
        return (spot * 3 + twap * 7) / 10;
    }
}

# Install security tools
npm install -g @ethereum/solidity-analyzer
pip install slither-analyzer mythril

# Run Slither analysis
slither contracts/ --print human-summary

# Run Mythril analysis
myth analyze contracts/MyContract.sol

# Foundry fuzzing
forge test --fuzz-runs 10000

# Generate coverage report
hardhat coverage

# Deploy with verification
hardhat deploy --network mainnet --verify