035_Gas优化与DoS防御详解：从代码优化到2025年Layer2解决方案，构建高效抗攻击的智能合约

// 优化前：独立存储变量
contract BadStorage {
    uint256 public a; // 20000 Gas写入
    uint256 public b; // 20000 Gas写入
    bool public c;    // 20000 Gas写入
    uint8 public d;   // 20000 Gas写入
}

// 优化后：打包存储变量
contract OptimizedStorage {
    // 打包多个小变量到单个存储槽
    struct PackedData {
        uint64 a;   // 使用更小的数据类型
        uint64 b;   // 不同变量共享一个存储槽
        bool c;     // 布尔值只占1位
        uint8 d;    // 使用精确大小的数据类型
        // 总共使用不到256位，因此所有变量存储在一个槽中
    }
    PackedData public data; // 只需20000 Gas写入
}

// 优化前：使用循环计算数组和
function sumArray(uint256[] memory array) public view returns (uint256) {
    uint256 total = 0;
    for (uint256 i = 0; i < array.length; i++) {
        total += array[i];
    }
    return total;
}

// 优化后：避免不必要的存储读取和优化循环
contract OptimizedContract {
    // 缓存数组长度，避免每次循环读取存储
    function sumArrayOptimized(uint256[] memory array) public view returns (uint256) {
        uint256 total = 0;
        uint256 length = array.length; // 缓存长度
        for (uint256 i = 0; i < length; ) { // 前置条件检查
            total += array[i];
            unchecked { // 避免溢出检查
                ++i;
            }
        }
        return total;
    }
    
    // 使用映射替代数组进行频繁查询
    mapping(uint256 => bool) private elementExists;
    
    function containsElement(uint256 element) public view returns (bool) {
        return elementExists[element]; // O(1)操作，比数组遍历O(n)高效
    }
}

// 优化前：多次外部调用
function multiCallBad(address[] memory targets, uint256[] memory values) external {
    for (uint256 i = 0; i < targets.length; i++) {
        (bool success, ) = targets[i].call{value: values[i]}("");
        require(success, "Transfer failed");
    }
}

// 优化后：批量处理和错误处理优化
function multiCallOptimized(address[] calldata targets, uint256[] calldata values) external {
    uint256 length = targets.length;
    require(length == values.length, "Array length mismatch");
    
    // 使用calldata而非memory减少Gas
    for (uint256 i = 0; i < length; ) {
        // 失败时收集错误而非立即revert
        (bool success, ) = targets[i].call{value: values[i]}("");
        if (!success) {
            // 记录失败但继续处理其他调用
            failedTransfers[i] = true;
        }
        
        unchecked { ++i; }
    }
    
    // 最后检查是否有失败的转账
    for (uint256 i = 0; i < length; ) {
        require(!failedTransfers[i], "Some transfers failed");
        unchecked { ++i; }
    }
}

// 易受攻击的合约
contract VulnerableContract {
    address[] public investors;
    mapping(address => uint256) public balances;
    
    // 添加投资者
    function addInvestor(address investor) public {
        investors.push(investor);
    }
    
    // 易受DoS攻击的函数 - 随着投资者增多，Gas消耗增加
    function distributeRewards() public {
        for (uint256 i = 0; i < investors.length; i++) {
            (bool success, ) = investors[i].call{value: balances[investors[i]]}("");
            require(success, "Transfer failed");
            balances[investors[i]] = 0;
        }
    }
}

// 优化后的合约，防止DoS攻击
contract SecureContract {
    mapping(address => uint256) public balances;
    mapping(address => bool) public hasClaimed;
    uint256 public distributionIndex;
    address[] public investorList;
    
    // 保持跟踪投资者
    function addInvestor(address investor) public {
        if (!hasClaimed[investor]) {
            investorList.push(investor);
            hasClaimed[investor] = true;
        }
    }
    
    // 分批处理，避免Gas限制DoS
    function claimRewards(uint256 batchSize) public {
        uint256 currentIndex = distributionIndex;
        uint256 endIndex = currentIndex + batchSize;
        uint256 listLength = investorList.length;
        
        // 限制处理批次大小
        if (endIndex > listLength) {
            endIndex = listLength;
        }
        
        // 处理当前批次
        for (uint256 i = currentIndex; i < endIndex; ) {
            address investor = investorList[i];
            uint256 amount = balances[investor];
            
            if (amount > 0) {
                balances[investor] = 0;
                (bool success, ) = investor.call{value: amount}("");
                // 不使用require，允许部分转账失败
                if (!success) {
                    balances[investor] = amount; // 恢复余额
                }
            }
            
            unchecked { ++i; }
        }
        
        // 更新索引，下次继续处理
        distributionIndex = endIndex;
    }
    
    // 允许投资者自行提取，分散Gas负担
    function withdraw() public {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance to withdraw");
        
        balances[msg.sender] = 0;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
}

// 经济DoS防御 - 价格预言机安全
contract SecureOracle {
    // 使用时间加权平均价格(TWAP)
    uint256[] private priceObservations;
    uint256 public constant OBSERVATION_WINDOW = 1 hours;
    uint256 public lastObservationTime;
    
    // 存储价格观察值
    function updatePrice(uint256 newPrice) external onlyAuthorized {
        // 限制更新频率，防止频繁操纵
        require(block.timestamp - lastObservationTime >= 5 minutes, "Update too frequent");
        
        priceObservations.push(newPrice);
        lastObservationTime = block.timestamp;
        
        // 保持观察窗口大小
        if (priceObservations.length > 12) { // 1小时内每5分钟一个观察值
            priceObservations.shift(); // 移除最旧的观察值
        }
    }
    
    // 获取时间加权平均价格
    function getPrice() public view returns (uint256) {
        require(priceObservations.length > 0, "No price data");
        
        // 计算TWAP
        uint256 sum = 0;
        for (uint256 i = 0; i < priceObservations.length; ) {
            sum += priceObservations[i];
            unchecked { ++i; }
        }
        
        return sum / priceObservations.length;
    }
    
    // 添加价格偏差限制
    function getSecurePrice() public view returns (uint256) {
        uint256 currentPrice = getPrice();
        
        // 检查价格是否异常波动
        if (priceObservations.length > 1) {
            uint256 previousPrice = priceObservations[priceObservations.length - 2];
            uint256 deviation = currentPrice > previousPrice 
                ? currentPrice - previousPrice 
                : previousPrice - currentPrice;
            
            // 如果价格波动超过20%，拒绝更新
            if (deviation * 100 / previousPrice > 20) {
                return previousPrice;
            }
        }
        
        return currentPrice;
    }
}

// 结合ReentrancyGuard和检查-效果-交互模式
contract SecureWithdrawal {
    mapping(address => uint256) public balances;
    bool private locked;
    
    // 重入锁
    modifier nonReentrant() {
        require(!locked, "ReentrancyGuard: reentrant call");
        locked = true;
        _;
        locked = false;
    }
    
    // 安全提款 - 检查-效果-交互模式
    function withdraw(uint256 amount) external nonReentrant {
        // 1. 检查
        require(balances[msg.sender] >= amount, "Insufficient balance");
        
        // 2. 效果（先更新状态）
        balances[msg.sender] -= amount;
        
        // 3. 交互（最后进行外部调用）
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
    
    // 紧急提款功能，防止回调DoS
    function emergencyWithdraw() external {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "No balance to withdraw");
        
        // 立即清空余额
        balances[msg.sender] = 0;
        
        // 使用低级调用，不检查返回值
        // 注意：这会放弃错误检查，但可以防止回调DoS
        (bool success, ) = msg.sender.call{value: amount}("");
        // 不使用require，允许转账失败但状态已更新
    }
}

// Solidity 0.9.x新特性优化示例
contract ModernSolidityOptimizations {
    // 1. 不可变引用类型
    string public immutable CONTRACT_NAME;
    
    // 2. 自定义错误替代require字符串
    error InsufficientBalance(uint256 requested, uint256 available);
    
    constructor(string memory name) {
        CONTRACT_NAME = name; // 仅在构造时设置一次
    }
    
    // 3. 更精确的存储布局控制
    struct OptimizedLayout {
        uint128 value1;
        address owner;
        uint128 value2;
        // 紧凑存储多个变量
    }
    
    // 4. 内存优化使用
    function processData(uint256[] calldata input) public pure returns (uint256[] memory) {
        uint256 length = input.length;
        uint256[] memory result = new uint256[](length);
        
        // 单次分配内存，避免多次重新分配
        for (uint256 i = 0; i < length; ) {
            unchecked { // 5. 无检查数学运算
                result[i] = input[i] * 2;
                ++i;
            }
        }
        
        return result;
    }
    
    // 6. 使用自定义错误
    function withdraw(uint256 amount, uint256 balance) public pure {
        if (amount > balance) {
            revert InsufficientBalance({requested: amount, available: balance});
        }
    }
    
    // 7. 预计算和缓存
    mapping(address => uint256) public cachedValues;
    uint256 public lastUpdateTime;
    
    function getValue(address user) public returns (uint256) {
        // 仅在必要时更新缓存
        if (block.timestamp - lastUpdateTime > 1 hours) {
            // 执行昂贵计算并缓存结果
            cachedValues[user] = expensiveCalculation(user);
            lastUpdateTime = block.timestamp;
        }
        
        return cachedValues[user];
    }
    
    function expensiveCalculation(address user) internal pure returns (uint256) {
        // 模拟昂贵计算
        return uint256(uint160(user)) % 1000;
    }
}

// Layer2优化合约示例
contract L2OptimizedContract {
    // Layer2特定优化策略
    
    // 1. 批量提交数据
    struct BatchData {
        uint256[] values;
        address[] addresses;
        uint256 timestamp;
    }
    
    // 存储批量数据而非单个交易
    function submitBatchData(BatchData calldata batch) external {
        // 在Layer2处理批量数据
        // ...处理逻辑...
    }
    
    // 2. 链下计算，链上验证
    function verifyResult(uint256 input, uint256 expectedOutput, bytes calldata proof) external view {
        // 在Layer2上只验证哈希或零知识证明
        require(verifyProof(input, expectedOutput, proof), "Invalid proof");
    }
    
    // 3. 使用Layer2特定存储模型
    // 利用Layer2的不同存储成本特性
    mapping(uint256 => bytes32) public compressedStorage;
    
    // 4. 异步处理模式
    uint256 public pendingOperations;
    mapping(uint256 => bool) public operationCompleted;
    
    function queueOperation(uint256 id) external {
        // 在Layer2上排队操作
        pendingOperations++;
        // ...
    }
    
    function processOperations(uint256 batchSize) external {
        // 批量处理操作，优化Layer2提交成本
        // ...
    }
    
    // 辅助函数
    function verifyProof(uint256 input, uint256 output, bytes calldata proof) internal pure returns (bool) {
        // 简化的证明验证
        return true; // 实际实现会使用适当的验证逻辑
    }
}

// 示例：AI可能建议的优化模式
contract AIOptimizedContract {
    // 1. 事件数据压缩
    event TransferCompressed(uint64 indexed from, uint64 indexed to, uint128 value);
    
    // 2. 存储访问优化
    uint256 private cachedTotalSupply;
    uint256 private lastCachedBlock;
    
    function getTotalSupply() public view returns (uint256) {
        // AI可能建议的缓存策略
        if (block.number - lastCachedBlock < 10) {
            return cachedTotalSupply;
        }
        // 计算实际totalSupply
        return calculateTotalSupply();
    }
    
    // 3. 计算优化 - 使用位移替代乘除法
    function optimizedMultiplication(uint256 x, uint256 y) internal pure returns (uint256) {
        // AI识别的位移优化
        if (y == 2) return x << 1;
        if (y == 4) return x << 2;
        if (y == 8) return x << 3;
        // 对于其他情况使用乘法
        return x * y;
    }
    
    // 4. 条件分支优化
    function optimizedConditionCheck(uint256 value) internal pure returns (uint256) {
        // AI可能建议的概率分支排序
        // 先检查最可能的情况
        if (value <= 100) {
            return value * 2;
        } else if (value <= 1000) {
            return value * 3;
        } else {
            return value * 4;
        }
    }
    
    function calculateTotalSupply() internal pure returns (uint256) {
        // 模拟totalSupply计算
        return 1000000;
    }
}

// 高级存储布局优化
contract AdvancedStorageLayout {
    // 1. 存储槽打包技术
    // 使用内联汇编直接控制存储槽
    function packMultipleValues(uint256 a, uint256 b, bool c, uint8 d) external {
        assembly {
            // 打包多个值到单个存储槽
            let packedValue := or(
                shl(0, and(d, 0xFF)),    // 低8位存储d
                shl(8, c),              // 第8位存储c
                shl(9, and(b, 0x7FFFFFFFFFFFFFF)), // 接下来56位存储b
                shl(65, a)              // 剩余位存储a
            )
            sstore(0x01, packedValue) // 存储到特定槽位
        }
    }
    
    // 2. 稀疏存储模式
    mapping(uint256 => bytes32) private sparseStorage;
    
    function storeSparseData(uint256 key, uint256 value) external {
        // 仅存储非零值
        if (value != 0) {
            sparseStorage[key] = bytes32(value);
        } else {
            // 删除零值条目，节省Gas
            delete sparseStorage[key];
        }
    }
    
    // 3. 热/冷数据分离
    mapping(address => HotData) private hotData;  // 频繁访问的数据
    mapping(address => ColdData) private coldData; // 不常访问的数据
    
    struct HotData {
        uint256 balance;       // 频繁更新的值
        uint64 lastActivity;   // 最近活动时间
    }
    
    struct ColdData {
        address referrer;      // 不常访问的数据
        uint256 registrationDate;
    }
    
    // 4. 存储租赁模式
    // 临时数据使用内存，定期提交到存储
    uint256[] private pendingUpdates;
    
    function queueUpdate(uint256 value) external {
        pendingUpdates.push(value);
        
        // 达到阈值时批量提交
        if (pendingUpdates.length >= 100) {
            commitBatchUpdates();
        }
    }
    
    function commitBatchUpdates() internal {
        // 批量处理更新，减少存储操作
        // ...
    }
}

// 模块化设计的防DoS合约
contract ModularAntiDoS {
    // 核心功能分离
    CoreLogic private coreLogic;
    PaymentProcessor private paymentProcessor;
    Governance private governance;
    
    // 访问控制
    mapping(address => bool) public isAdmin;
    
    constructor(address _coreLogic, address _paymentProcessor, address _governance) {
        coreLogic = CoreLogic(_coreLogic);
        paymentProcessor = PaymentProcessor(_paymentProcessor);
        governance = Governance(_governance);
        isAdmin[msg.sender] = true;
    }
    
    // 速率限制器
    mapping(address => uint256) public lastActionTime;
    uint256 public constant ACTION_COOLDOWN = 1 minutes;
    
    modifier rateLimited() {
        require(block.timestamp >= lastActionTime[msg.sender] + ACTION_COOLDOWN, "Rate limited");
        lastActionTime[msg.sender] = block.timestamp;
        _;
    }
    
    // 批量操作接口
    function batchProcess(uint256[] calldata items) external rateLimited {
        // 限制批量操作大小
        require(items.length <= 50, "Too many items");
        
        // 处理批量请求
        for (uint256 i = 0; i < items.length; ) {
            coreLogic.processItem(items[i]);
            unchecked { ++i; }
        }
    }
    
    // 紧急停止机制
    bool public emergencyStopped;
    
    modifier notStopped() {
        require(!emergencyStopped, "Emergency stop");
        _;
    }
    
    function emergencyStop() external {
        require(isAdmin[msg.sender], "Not authorized");
        emergencyStopped = true;
    }
    
    function resume() external {
        require(isAdmin[msg.sender], "Not authorized");
        emergencyStopped = false;
    }
}

// 资源限制与边界检查合约
contract ResourceLimited {
    // 1. 操作计数与限制
    mapping(address => uint256) public operationCount;
    uint256 public constant MAX_OPERATIONS_PER_BLOCK = 10;
    
    // 2. 动态Gas限制
    uint256 public dynamicGasLimit;
    uint256 public constant BASE_GAS_LIMIT = 200000;
    
    constructor() {
        updateGasLimit();
    }
    
    // 3. 交易队列优先级
    struct Operation {
        address sender;
        uint256 value;
        uint256 timestamp;
    }
    
    Operation[] public operationsQueue;
    uint256 public constant MAX_QUEUE_SIZE = 1000;
    
    // 处理操作前检查资源限制
    function processOperation(uint256 data) external {
        // 检查操作计数
        require(operationCount[msg.sender] < MAX_OPERATIONS_PER_BLOCK, "Operation limit exceeded");
        operationCount[msg.sender]++;
        
        // 检查队列大小
        require(operationsQueue.length < MAX_QUEUE_SIZE, "Queue full");
        
        // 估算Gas需求
        uint256 estimatedGas = estimateGasRequirement(data);
        require(estimatedGas <= dynamicGasLimit, "Gas requirement too high");
        
        // 添加到队列
        operationsQueue.push(Operation({
            sender: msg.sender,
            value: data,
            timestamp: block.timestamp
        }));
    }
    
    // 估算Gas需求
    function estimateGasRequirement(uint256 data) internal pure returns (uint256) {
        // 简化的Gas估算逻辑
        return BASE_GAS_LIMIT + data * 10;
    }
    
    // 更新动态Gas限制
    function updateGasLimit() public {
        // 基于当前区块Gas限制动态调整
        dynamicGasLimit = block.gaslimit / 10; // 使用区块Gas限制的10%
    }
    
    // 清理操作计数（每个区块重置）
    function cleanOperationCounts() external {
        // 实际实现中可能需要更复杂的机制
        // 例如使用区块号追踪
    }
}

// 应急响应与恢复合约
contract EmergencyResponse {
    // 1. 多签名管理
    address[] public guardians;
    mapping(address => bool) public isGuardian;
    uint256 public constant MIN_GUARDIANS = 3;
    
    // 2. 时间锁定操作
    struct TimelockedOperation {
        uint256 operationType;
        bytes data;
        uint256 executionTime;
        mapping(address => bool) hasConfirmed;
        uint256 confirmations;
        bool executed;
    }
    
    uint256 public nextOperationId;
    mapping(uint256 => TimelockedOperation) public timelockedOperations;
    uint256 public constant TIMELOCK_PERIOD = 24 hours;
    
    // 3. 状态冻结机制
    bool public systemFrozen;
    uint256 public freezeStartTime;
    uint256 public constant MAX_FREEZE_DURATION = 7 days;
    
    constructor(address[] memory _guardians) {
        require(_guardians.length >= MIN_GUARDIANS, "Not enough guardians");
        
        for (uint256 i = 0; i < _guardians.length; ) {
            guardians.push(_guardians[i]);
            isGuardian[_guardians[i]] = true;
            unchecked { ++i; }
        }
    }
    
    // 紧急冻结
    function emergencyFreeze() external {
        require(isGuardian[msg.sender], "Not authorized");
        systemFrozen = true;
        freezeStartTime = block.timestamp;
    }
    
    // 解除冻结（需要多重确认）
    function scheduleUnfreeze() external {
        require(isGuardian[msg.sender], "Not authorized");
        
        // 创建时间锁定操作
        uint256 operationId = nextOperationId++;
        TimelockedOperation storage operation = timelockedOperations[operationId];
        operation.operationType = 1; // 1 = 解除冻结
        operation.executionTime = block.timestamp + TIMELOCK_PERIOD;
        
        // 提交者自动确认
        confirmOperation(operationId);
    }
    
    // 确认操作
    function confirmOperation(uint256 operationId) public {
        require(isGuardian[msg.sender], "Not authorized");
        
        TimelockedOperation storage operation = timelockedOperations[operationId];
        require(!operation.executed, "Operation already executed");
        require(!operation.hasConfirmed[msg.sender], "Already confirmed");
        
        operation.hasConfirmed[msg.sender] = true;
        operation.confirmations++;
    }
    
    // 执行时间锁定操作
    function executeOperation(uint256 operationId) external {
        TimelockedOperation storage operation = timelockedOperations[operationId];
        require(!operation.executed, "Operation already executed");
        require(block.timestamp >= operation.executionTime, "Timelock not expired");
        require(operation.confirmations >= MIN_GUARDIANS, "Not enough confirmations");
        
        operation.executed = true;
        
        if (operation.operationType == 1) { // 解除冻结
            systemFrozen = false;
        }
    }
    
    // 自动解除长时间冻结
    function autoUnfreeze() external {
        require(systemFrozen, "System not frozen");
        require(block.timestamp >= freezeStartTime + MAX_FREEZE_DURATION, "Freeze period not expired");
        
        systemFrozen = false;
    }
    
    // 修饰器：检查系统是否冻结
    modifier notFrozen() {
        require(!systemFrozen, "System frozen");
        _;
    }
}

// 监控与异常检测合约
contract MonitoringSystem {
    // 1. 事件监控
    event OperationExecuted(address indexed user, uint256 gasUsed, uint256 timestamp);
    event AnomalyDetected(string anomalyType, uint256 severity, uint256 timestamp);
    
    // 2. 操作统计
    struct OperationStats {
        uint256 count;
        uint256 totalGasUsed;
        uint256 maxGasUsed;
        uint256 lastExecutionTime;
    }
    
    mapping(address => OperationStats) public userStats;
    uint256 public globalOperationCount;
    uint256 public totalGasConsumed;
    
    // 3. 阈值配置
    uint256 public maxOperationsPerUser = 100;
    uint256 public maxGasPerOperation = 500000;
    uint256 public anomalyThreshold = 50; // 50%偏差视为异常
    
    // 4. 历史基线
    uint256 public avgGasBaseline;
    uint256 public lastBaselineUpdate;
    uint256 public constant BASELINE_UPDATE_INTERVAL = 1 days;
    
    // 执行操作并监控
    function executeMonitoredOperation() external returns (bool) {
        // 记录操作开始时间
        uint256 startGas = gasleft();
        
        // 检查用户操作频率
        OperationStats storage stats = userStats[msg.sender];
        require(stats.count < maxOperationsPerUser, "Operation limit exceeded");
        
        // 执行实际操作
        bool success = performOperation();
        
        // 计算Gas消耗
        uint256 gasUsed = startGas - gasleft();
        
        // 检查Gas使用异常
        if (gasUsed > maxGasPerOperation) {
            emit AnomalyDetected("ExcessiveGasUsage", 2, block.timestamp);
        }
        
        // 更新统计数据
        updateStats(msg.sender, gasUsed);
        
        // 检测异常模式
        checkForAnomalies(msg.sender, gasUsed);
        
        emit OperationExecuted(msg.sender, gasUsed, block.timestamp);
        
        return success;
    }
    
    // 执行实际操作
    function performOperation() internal returns (bool) {
        // 实际业务逻辑
        return true;
    }
    
    // 更新统计数据
    function updateStats(address user, uint256 gasUsed) internal {
        OperationStats storage stats = userStats[user];
        stats.count++;
        stats.totalGasUsed += gasUsed;
        if (gasUsed > stats.maxGasUsed) {
            stats.maxGasUsed = gasUsed;
        }
        stats.lastExecutionTime = block.timestamp;
        
        globalOperationCount++;
        totalGasConsumed += gasUsed;
        
        // 定期更新基线
        if (block.timestamp - lastBaselineUpdate > BASELINE_UPDATE_INTERVAL) {
            updateBaseline();
        }
    }
    
    // 检查异常
    function checkForAnomalies(address user, uint256 gasUsed) internal view {
        // 检查与基线的偏差
        if (avgGasBaseline > 0) {
            uint256 deviation = gasUsed > avgGasBaseline 
                ? (gasUsed - avgGasBaseline) * 100 / avgGasBaseline
                : (avgGasBaseline - gasUsed) * 100 / avgGasBaseline;
            
            if (deviation > anomalyThreshold) {
                // 注意：在实际实现中，这里应该发出事件而不是状态更改
                // 此处仅为示例
            }
        }
    }
    
    // 更新基线
    function updateBaseline() internal {
        if (globalOperationCount > 0) {
            avgGasBaseline = totalGasConsumed / globalOperationCount;
        }
        lastBaselineUpdate = block.timestamp;
    }
}

// Gas优化与DoS防御集成框架
contract OptimizedDefensiveContract {
    // 1. 存储优化
    struct OptimizedUser {
        uint64 balance;       // 使用紧凑数据类型
        uint64 lastActivity;  // 时间戳只需要64位
        uint32 nonce;         // 交易计数器
        bool active;          // 状态标志
        // 所有字段打包到单个存储槽
    }
    
    mapping(address => OptimizedUser) private users;
    
    // 2. 批量处理机制
    uint256 public constant MAX_BATCH_SIZE = 50;
    
    function processBatch(address[] calldata addresses, uint256[] calldata amounts) external {
        require(addresses.length <= MAX_BATCH_SIZE, "Batch too large");
        require(addresses.length == amounts.length, "Array length mismatch");
        
        // 批量处理更新，减少Gas消耗
        for (uint256 i = 0; i < addresses.length; ) {
            // 安全检查
            require(amounts[i] <= 1e18, "Amount too large");
            
            // 更新用户数据
            users[addresses[i]].balance += uint64(amounts[i]);
            users[addresses[i]].lastActivity = uint64(block.timestamp);
            
            unchecked { ++i; }
        }
    }
    
    // 3. 速率限制
    mapping(address => uint256) private lastActionTime;
    uint256 public constant ACTION_INTERVAL = 5 seconds;
    
    modifier rateLimited() {
        require(block.timestamp >= lastActionTime[msg.sender] + ACTION_INTERVAL, "Rate limited");
        lastActionTime[msg.sender] = block.timestamp;
        _;
    }
    
    // 4. 紧急保护
    bool public paused;
    
    modifier whenNotPaused() {
        require(!paused, "Contract paused");
        _;
    }
    
    // 5. 推拉结合的提款机制
    mapping(address => uint256) private pendingWithdrawals;
    
    // 推送方式 - 但限制每次处理数量
    function distributeRewards(address[] calldata recipients, uint256[] calldata amounts) 
        external 
        whenNotPaused
        rateLimited
    {
        require(recipients.length <= 20, "Too many recipients");
        require(recipients.length == amounts.length, "Array mismatch");
        
        for (uint256 i = 0; i < recipients.length; ) {
            pendingWithdrawals[recipients[i]] += amounts[i];
            unchecked { ++i; }
        }
    }
    
    // 拉取方式 - 用户自行提款
    function withdraw() external {
        uint256 amount = pendingWithdrawals[msg.sender];
        require(amount > 0, "No pending withdrawal");
        
        // 检查-效果-交互模式
        pendingWithdrawals[msg.sender] = 0;
        
        // 低级调用，允许失败后恢复（可选安全模式）
        (bool success, ) = msg.sender.call{value: amount}("");
        if (!success) {
            // 恢复余额，允许用户重试
            pendingWithdrawals[msg.sender] = amount;
        }
    }
    
    // 6. Gas优化的访问控制
    address private immutable OWNER;
    
    constructor() {
        OWNER = msg.sender; // 一次性设置，不可变存储更省Gas
    }
    
    modifier onlyOwner() {
        require(msg.sender == OWNER, "Not authorized");
        _;
    }
    
    // 7. 可升级设置
    mapping(uint256 => uint256) private configValues;
    
    function setConfig(uint256 key, uint256 value) external onlyOwner {
        configValues[key] = value;
    }
    
    // 8. 应急暂停
    function pause() external onlyOwner {
        paused = true;
    }
    
    function unpause() external onlyOwner {
        paused = false;
    }
}

### 6.2 实际项目中的优化策略
在2025年的实际项目中，智能合约开发者采用了多层次的优化策略：

1. **分层优化策略**：
   - 合约层：优化存储、计算和交互
   - 架构层：采用微服务架构和模块化设计
   - 网络层：利用Layer2和跨链技术
   - 应用层：前端优化和用户体验改进

2. **持续优化流程**：
   - 基准测试：建立性能基准线
   - 分析：识别瓶颈和优化机会
   - 实施：应用优化技术
   - 验证：测量优化效果
   - 迭代：持续改进

```mermaid
flowchart TD
    A[分层优化策略] --> B[合约层优化]
    A --> C[架构层优化]
    A --> D[网络层优化]
    A --> E[应用层优化]
    
    B --> F[存储优化]
    B --> G[计算优化]
    B --> H[交互优化]
    
    C --> I[模块化设计]
    C --> J[微服务架构]
    C --> K[事件驱动模式]
    
    D --> L[Layer2解决方案]
    D --> M[跨链技术]
    D --> N[状态通道]
    
    E --> O[前端优化]
    E --> P[用户体验改进]
    E --> Q[缓存策略]

// Uniswap V4风格的集中流动性优化
contract ConcentratedLiquidityPool {
    // 1. 集中流动性存储优化
    struct Position {
        uint128 liquidity;
        uint24 tickLower;
        uint24 tickUpper;
        // 紧凑存储，仅使用必要字段
    }
    
    mapping(bytes32 => Position) private positions;
    
    // 2. 批量操作优化
    function mintMultiplePositions(
        address owner,
        uint24[] calldata tickLower,
        uint24[] calldata tickUpper,
        uint128[] calldata liquidity
    ) external {
        require(tickLower.length == tickUpper.length && tickLower.length == liquidity.length, "Array length mismatch");
        require(tickLower.length <= 10, "Too many positions");
        
        for (uint256 i = 0; i < tickLower.length; ) {
            bytes32 key = getPositionKey(owner, tickLower[i], tickUpper[i]);
            positions[key] = Position({
                liquidity: liquidity[i],
                tickLower: tickLower[i],
                tickUpper: tickUpper[i]
            });
            unchecked { ++i; }
        }
    }
    
    // 3. 高效价格计算
    function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160) {
        // 优化的平方根计算，避免复杂数学运算
        // ...
        return 0; // 示例返回
    }
    
    // 4. DoS防御措施
    uint256 public constant MAX_TICK_SPACING = 10;
    
    modifier validateTicks(uint24 tickLower, uint24 tickUpper) {
        require(tickLower < tickUpper, "Invalid tick range");
        require((tickLower % MAX_TICK_SPACING) == 0 && (tickUpper % MAX_TICK_SPACING) == 0, "Invalid tick spacing");
        _;
    }
    
    function getPositionKey(address owner, uint24 tickLower, uint24 tickUpper) 
        internal pure returns (bytes32) 
    {
        return keccak256(abi.encodePacked(owner, tickLower, tickUpper));
    }
}

timeline
    title 智能合约Gas优化与DoS防御技术发展路线
    section 2025
        AI辅助优化工具广泛应用 : 当前阶段
        编译器级深度优化实现
        自适应DoS防御系统部署
    section 2026
        zkEVM优化成为主流
        形式化验证自动化
        跨链安全标准建立
    section 2027
        自优化智能合约出现
        量子安全防御机制
        去中心化安全网络成熟
    section 2028+
        完全自动化安全与优化
        超大规模应用优化方案
        跨生态系统安全框架