Solidity Gas 优化：存储布局、数据位置与代理模式

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract StorageCost {
    // 三个 uint256 占用 3 个槽位（slots 0,1,2）
    uint256 public a;
    uint256 public b;
    uint256 public c;

    // 冷访问：3 次 SLOAD = 3 × 2100 = 6300 gas
    function readAll() external view returns (uint256, uint256, uint256) {
        return (a, b, c);
    }

    // 热访问：a 在上一行已读，本次读 b、c 各 100 gas
    function readTwice() external view returns (uint256) {
        uint256 x = a;              // 冷 SLOAD 2100
        return x + b;               // 热 SLOAD 100
    }
}

// ❌ 差：把 calldata 拷贝进 memory，再写入 storage
function bad(string memory name) external {
    names.push(name);
}

// ✅ 好：calldata 只读，直接写入 storage
function good(string calldata name) external {
    names.push(name);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// ❌ 差：3 个变量各占一个完整槽位 = 3 个槽位
contract Bad {
    uint256 a;   // slot 0（完整 32B）
    uint8   b;   // slot 1（只用 1B，其余 31B 浪费）
    uint256 c;   // slot 2
}

// ✅ 好：打包到 1 个槽位 = 1 个槽位
contract Good {
    uint128 a;   // slot 0 前 16B
    uint64  b;   // slot 0 中 8B
    uint64  c;   // slot 0 后 8B
}

// ❌ 差：address(20B)+uint96(12B) 可打包却被隔开
struct BadUser {
    uint256 id;       // slot 0
    address addr;     // slot 1（20B，浪费 12B）
    uint96 balance;   // slot 2
}

// ✅ 好：同类小类型紧邻，塞进一个槽
struct GoodUser {
    address addr;     // slot 0 前 20B
    uint96  balance;  // slot 0 后 12B
    uint256 id;       // slot 1
}

EIP-1167 运行时字节码（45 字节）：
363d3d373d3d3d363d73 <20字节目标地址> 5af43d82803e903d91602b57fd5bf3

语义：复制 calldata → delegatecall 到目标地址 → 返回结果

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TokenFactory {
    address public immutable implementation;
    address[] public allTokens;

    event TokenDeployed(address token, address owner);

    constructor() {
        // 先部署一次完整实现（逻辑）
        implementation = address(new ERC20Impl());
    }

    function createToken(string calldata name, string calldata symbol)
        external returns (address)
    {
        address clone = Clones.clone(implementation);   // 45 字节代理
        ERC20Impl(clone).initialize(name, symbol, msg.sender);
        allTokens.push(clone);
        emit TokenDeployed(clone, msg.sender);
        return clone;
    }
}

// 用 initialize 代替 constructor（代理无法运行构造函数）
contract ERC20Impl is ERC20 {
    function initialize(string memory name, string memory symbol, address owner) external {
        // 一次性初始化逻辑...
    }
}

// Uniswap V2 Pair 的经典打包
struct Reserves {
    uint112 reserve0;      // 8+4=12 字节
    uint112 reserve1;      // 12 字节
    uint32 blockTimestampLast;  // 4 字节
}                            // 合计 32 字节 = 1 槽位

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// 自定义错误：比 require("message") 省 ~50 gas + 部署更省
error InsufficientOutput(uint256 have, uint256 want);
error Expired(uint256 deadline, uint256 blockTimestamp);

contract SwapRouter {
    address public immutable weth;   // immutable 内联，免 SLOAD
    uint256 internal constant BPS = 10000;  // constant 编译期内联

    function swapExactETHForTokens(
        uint256 minOut,
        uint256 deadline,
        address[] calldata path
    ) external payable returns (uint256 amountOut) {
        if (block.timestamp > deadline) revert Expired(deadline, block.timestamp);
        // 核心 swap 逻辑...
        if (amountOut < minOut) revert InsufficientOutput(amountOut, minOut);
        return amountOut;
    }
}

# Foundry 生成 gas 快照，跟踪优化效果
forge snapshot --diff .gas-snapshot