第三章：ERC-20及扩展标准

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

interface IERC20 {
    // 查询代币总供应量
    function totalSupply() external view returns (uint256);
    
    // 查询账户余额
    function balanceOf(address account) external view returns (uint256);
    
    // 转账函数
    function transfer(address to, uint256 amount) external returns (bool);
    
    // 查询授权额度
    function allowance(address owner, address spender) external view returns (uint256);
    
    // 授权函数
    function approve(address spender, uint256 amount) external returns (bool);
    
    // 授权转账
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    
    // 事件定义
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

abstract contract StablecoinBase is ERC20, Pausable, AccessControl {
    // 角色定义
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
    
    // 黑名单映射
    mapping(address => bool) private _blacklisted;
    
    // 铸币限额管理
    mapping(address => uint256) private _minterAllowances;
    
    // 事件
    event Blacklisted(address indexed account);
    event UnBlacklisted(address indexed account);
    event MinterConfigured(address indexed minter, uint256 allowance);
    event MinterRemoved(address indexed minter);
    
    // 修饰器：检查黑名单
    modifier notBlacklisted(address account) {
        require(!_blacklisted[account], "Account is blacklisted");
        _;
    }
    
    // 铸币功能（带限额控制）
    function mint(address to, uint256 amount) 
        external 
        onlyRole(MINTER_ROLE) 
        whenNotPaused 
        notBlacklisted(to) 
    {
        require(amount <= _minterAllowances[msg.sender], "Exceeds minter allowance");
        _minterAllowances[msg.sender] -= amount;
        _mint(to, amount);
    }
    
    // 销毁功能
    function burn(uint256 amount) external whenNotPaused {
        _burn(msg.sender, amount);
    }
    
    // 黑名单管理
    function blacklist(address account) external onlyRole(BLACKLISTER_ROLE) {
        _blacklisted[account] = true;
        emit Blacklisted(account);
    }
    
    // 重写transfer以检查黑名单
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);
        require(!_blacklisted[from] && !_blacklisted[to], "Blacklisted address");
    }
}

abstract contract ERC20Permit is ERC20, IERC20Permit {
    using ECDSA for bytes32;
    
    bytes32 public constant PERMIT_TYPEHASH = keccak256(
        "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
    );
    
    mapping(address => uint256) public nonces;
    
    // EIP-712 Domain
    bytes32 private immutable DOMAIN_SEPARATOR;
    
    constructor() {
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(name())),
                keccak256(bytes("1")),
                block.chainid,
                address(this)
            )
        );
    }
    
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
        
        bytes32 structHash = keccak256(
            abi.encode(
                PERMIT_TYPEHASH,
                owner,
                spender,
                value,
                nonces[owner]++,
                deadline
            )
        );
        
        bytes32 hash = keccak256(
            abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash)
        );
        
        address signer = hash.recover(v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");
        
        _approve(owner, spender, value);
    }
}

contract GasOptimizedStablecoin is StablecoinBase {
    // 使用packed结构体减少存储槽
    struct UserInfo {
        uint128 balance;      // 足够存储大部分余额
        uint64 lastTransfer;  // 时间戳
        bool isBlacklisted;   // 黑名单状态
        bool isWhitelisted;   // 白名单状态（免Gas费）
    }
    
    mapping(address => UserInfo) private _userInfo;
    
    // 批量转账（节省基础Gas开销）
    function batchTransfer(
        address[] calldata recipients,
        uint256[] calldata amounts
    ) external whenNotPaused {
        require(recipients.length == amounts.length, "Length mismatch");
        require(recipients.length <= 100, "Too many recipients");
        
        uint256 totalAmount;
        for (uint256 i = 0; i < amounts.length; ) {
            totalAmount += amounts[i];
            unchecked { ++i; }
        }
        
        require(_userInfo[msg.sender].balance >= totalAmount, "Insufficient balance");
        
        // 使用unchecked节省溢出检查Gas
        unchecked {
            _userInfo[msg.sender].balance -= uint128(totalAmount);
        }
        
        for (uint256 i = 0; i < recipients.length; ) {
            _userInfo[recipients[i]].balance += uint128(amounts[i]);
            emit Transfer(msg.sender, recipients[i], amounts[i]);
            unchecked { ++i; }
        }
    }
    
    // 使用assembly优化的余额查询
    function balanceOf(address account) public view returns (uint256 balance) {
        assembly {
            // 直接读取存储槽
            let slot := _userInfo.slot
            let key := account
            mstore(0x00, key)
            mstore(0x20, slot)
            let location := keccak256(0x00, 0x40)
            balance := shr(128, sload(location))
        }
    }
}

// 使用OpenZeppelin的UUPS实现
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

contract StablecoinV1 is 
    Initializable,
    ERC20Upgradeable,
    PausableUpgradeable,
    OwnableUpgradeable,
    UUPSUpgradeable 
{
    // 存储布局版本控制
    uint256 private constant STORAGE_VERSION = 1;
    
    // 状态变量（注意顺序很重要）
    mapping(address => bool) public blacklisted;
    mapping(address => uint256) public minterAllowance;
    address[] public minters;
    
    // 初始化函数（代替构造函数）
    function initialize(
        string memory name,
        string memory symbol
    ) public initializer {
        __ERC20_init(name, symbol);
        __Pausable_init();
        __Ownable_init();
        __UUPSUpgradeable_init();
    }
    
    // 升级授权（只有owner可以升级）
    function _authorizeUpgrade(address newImplementation)
        internal
        onlyOwner
        override
    {}
    
    // 获取实现版本
    function version() external pure returns (string memory) {
        return "1.0.0";
    }
}

// V2版本示例（添加新功能）
contract StablecoinV2 is StablecoinV1 {
    // 新增状态变量（只能在最后添加）
    mapping(address => uint256) public dailyTransferLimit;
    mapping(address => uint256) public dailyTransferAmount;
    mapping(address => uint256) public lastTransferDay;
    
    // 新增功能：每日转账限额
    function setDailyLimit(address user, uint256 limit) external onlyOwner {
        dailyTransferLimit[user] = limit;
    }
    
    // 重写transfer以实现限额检查
    function transfer(address to, uint256 amount) 
        public 
        override 
        returns (bool) 
    {
        _checkDailyLimit(msg.sender, amount);
        return super.transfer(to, amount);
    }
    
    function _checkDailyLimit(address user, uint256 amount) private {
        uint256 today = block.timestamp / 1 days;
        
        if (lastTransferDay[user] < today) {
            dailyTransferAmount[user] = 0;
            lastTransferDay[user] = today;
        }
        
        require(
            dailyTransferAmount[user] + amount <= dailyTransferLimit[user],
            "Daily limit exceeded"
        );
        
        dailyTransferAmount[user] += amount;
    }
    
    function version() external pure override returns (string memory) {
        return "2.0.0";
    }
}

abstract contract StablecoinStorageV1 {
    // 状态变量
    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    uint256 internal _totalSupply;
    
    // 存储间隙：预留升级空间
    uint256[47] private __gap;  // 50 - 3 = 47
}

abstract contract StablecoinStorageV2 is StablecoinStorageV1 {
    // 新增状态变量
    mapping(address => bool) internal _frozen;
    uint256 internal _maxSupply;
    
    // 更新存储间隙
    uint256[45] private __gap;  // 47 - 2 = 45
}

// 使用非结构化存储（Unstructured Storage）
contract DiamondStorage {
    struct DiamondStorageStruct {
        mapping(address => uint256) balances;
        mapping(address => bool) blacklisted;
        uint256 totalSupply;
        address admin;
    }
    
    function diamondStorage() 
        internal 
        pure 
        returns (DiamondStorageStruct storage ds) 
    {
        bytes32 position = keccak256("diamond.standard.diamond.storage");
        assembly {
            ds.slot := position
        }
    }
}

import "@layerzerolabs/solidity-examples/contracts/token/oft/v2/OFTV2.sol";

contract OmniChainStablecoin is OFTV2, Pausable {
    // 链ID到地址的映射（用于限额管理）
    mapping(uint16 => address) public trustedRemotes;
    
    // 每条链的铸币限额
    mapping(uint16 => uint256) public chainMintLimit;
    mapping(uint16 => uint256) public chainMintAmount;
    
    // 跨链转账费用（基点）
    uint256 public bridgeFee = 10; // 0.1%
    address public feeCollector;
    
    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        address _lzEndpoint
    ) OFTV2(_name, _symbol, _decimals, _lzEndpoint) {
        feeCollector = msg.sender;
    }
    
    // 设置可信远程合约
    function setTrustedRemote(
        uint16 _chainId,
        bytes calldata _path
    ) external onlyOwner {
        trustedRemotes[_chainId] = address(bytes20(_path));
        trustedRemote[_chainId] = _path;
    }
    
    // 重写发送函数以实现费用收取
    function _send(
        address _from,
        uint16 _dstChainId,
        bytes32 _toAddress,
        uint256 _amount,
        address payable _refundAddress,
        address _zroPaymentAddress,
        bytes memory _adapterParams
    ) internal override returns (uint256 amount) {
        // 计算并收取跨链费用
        uint256 fee = (_amount * bridgeFee) / 10000;
        uint256 amountAfterFee = _amount - fee;
        
        if (fee > 0) {
            _transfer(_from, feeCollector, fee);
        }
        
        // 检查目标链限额
        require(
            chainMintAmount[_dstChainId] + amountAfterFee <= chainMintLimit[_dstChainId],
            "Chain mint limit exceeded"
        );
        
        chainMintAmount[_dstChainId] += amountAfterFee;
        
        return super._send(
            _from,
            _dstChainId,
            _toAddress,
            amountAfterFee,
            _refundAddress,
            _zroPaymentAddress,
            _adapterParams
        );
    }
    
    // 估算跨链费用
    function estimateSendFee(
        uint16 _dstChainId,
        bytes32 _toAddress,
        uint256 _amount,
        bool _useZro,
        bytes calldata _adapterParams
    ) public view override returns (uint256 nativeFee, uint256 zroFee) {
        uint256 amountAfterFee = _amount - (_amount * bridgeFee) / 10000;
        return super.estimateSendFee(
            _dstChainId,
            _toAddress,
            amountAfterFee,
            _useZro,
            _adapterParams
        );
    }
}

use cosmwasm_std::{
    entry_point, to_binary, Binary, Deps, DepsMut, 
    Env, MessageInfo, Response, StdResult, Uint128,
    IbcMsg, IbcTimeout, CosmosMsg,
};
use cw20::{Cw20Contract, Cw20ExecuteMsg};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct IbcTransferMsg {
    pub channel_id: String,
    pub to_address: String,
    pub amount: Uint128,
    pub timeout: IbcTimeout,
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result {
    match msg {
        ExecuteMsg::IbcTransfer(transfer_msg) => {
            execute_ibc_transfer(deps, env, info, transfer_msg)
        }
        _ => handle_cw20_execute(deps, env, info, msg),
    }
}

fn execute_ibc_transfer(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: IbcTransferMsg,
) -> Result {
    // 检查余额
    let balance = BALANCES.load(deps.storage, &info.sender)?;
    if balance < msg.amount {
        return Err(ContractError::InsufficientFunds {});
    }
    
    // 扣除余额
    BALANCES.update(
        deps.storage,
        &info.sender,
        |balance| -> StdResult<_> {
            Ok(balance.unwrap_or_default() - msg.amount)
        },
    )?;
    
    // 构建IBC消息
    let ibc_msg = IbcMsg::Transfer {
        channel_id: msg.channel_id,
        to_address: msg.to_address,
        amount: coin(msg.amount.u128(), "ustable"),
        timeout: msg.timeout,
    };
    
    Ok(Response::new()
        .add_message(ibc_msg)
        .add_attribute("action", "ibc_transfer")
        .add_attribute("from", info.sender)
        .add_attribute("amount", msg.amount))
}

// IBC包接收处理
#[entry_point]
pub fn ibc_packet_receive(
    deps: DepsMut,
    _env: Env,
    msg: IbcPacketReceiveMsg,
) -> Result {
    // 解析接收的数据
    let packet: TransferPacket = from_slice(&msg.packet.data)?;
    
    // 铸造代币给接收者
    BALANCES.update(
        deps.storage,
        &packet.receiver,
        |balance| -> StdResult<_> {
            Ok(balance.unwrap_or_default() + packet.amount)
        },
    )?;
    
    Ok(IbcReceiveResponse::new()
        .set_ack(to_binary(&TransferAck::Success)?)
        .add_attribute("action", "receive")
        .add_attribute("receiver", packet.receiver)
        .add_attribute("amount", packet.amount))
}

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

import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract EnterpriseStablecoin is 
    Initializable,
    ERC20Upgradeable,
    PausableUpgradeable,
    AccessControlUpgradeable,
    UUPSUpgradeable 
{
    using ECDSA for bytes32;
    
    // 角色定义
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant BLACKLISTER_ROLE = keccak256("BLACKLISTER_ROLE");
    bytes32 public constant KYC_ROLE = keccak256("KYC_ROLE");
    bytes32 public constant UPGRADER_ROLE = keccak256("UPGRADER_ROLE");
    
    // 状态变量
    mapping(address => bool) public blacklisted;
    mapping(address => bool) public kycApproved;
    mapping(address => uint256) public minterAllowance;
    mapping(address => uint256) public lastActivity;
    
    // 交易限制
    uint256 public maxTransactionAmount;
    uint256 public dailyTransferLimit;
    mapping(address => uint256) public dailyTransferred;
    mapping(address => uint256) public lastTransferDay;
    
    // 合规功能
    bool public kycRequired;
    uint256 public inactivityThreshold;
    
    // 签名nonce（防重放）
    mapping(address => uint256) public nonces;
    
    // 事件
    event Blacklisted(address indexed account);
    event UnBlacklisted(address indexed account);
    event KYCApproved(address indexed account);
    event KYCRevoked(address indexed account);
    event ComplianceConfigUpdated(bool kycRequired, uint256 inactivityThreshold);
    
    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }
    
    function initialize(
        string memory name,
        string memory symbol,
        bool _kycRequired
    ) public initializer {
        __ERC20_init(name, symbol);
        __Pausable_init();
        __AccessControl_init();
        __UUPSUpgradeable_init();
        
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(PAUSER_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(UPGRADER_ROLE, msg.sender);
        
        kycRequired = _kycRequired;
        maxTransactionAmount = 1000000 * 10**decimals(); // 1M默认限额
        dailyTransferLimit = 5000000 * 10**decimals();   // 5M每日限额
        inactivityThreshold = 365 days;                  // 1年不活跃阈值
    }
    
    // 铸币功能
    function mint(address to, uint256 amount) 
        external 
        onlyRole(MINTER_ROLE)
        whenNotPaused 
    {
        require(!blacklisted[to], "Recipient is blacklisted");
        require(!kycRequired || kycApproved[to], "KYC not approved");
        require(amount <= minterAllowance[msg.sender], "Exceeds allowance");
        
        minterAllowance[msg.sender] -= amount;
        _mint(to, amount);
        lastActivity[to] = block.timestamp;
    }
    
    // 带签名的铸币（链下授权）
    function mintWithSignature(
        address to,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external whenNotPaused {
        require(block.timestamp <= deadline, "Signature expired");
        
        bytes32 structHash = keccak256(
            abi.encode(
                keccak256("Mint(address to,uint256 amount,uint256 nonce,uint256 deadline)"),
                to,
                amount,
                nonces[to]++,
                deadline
            )
        );
        
        bytes32 hash = _hashTypedDataV4(structHash);
        address signer = hash.recover(v, r, s);
        
        require(hasRole(MINTER_ROLE, signer), "Invalid signer");
        require(!blacklisted[to], "Recipient is blacklisted");
        require(!kycRequired || kycApproved[to], "KYC not approved");
        
        _mint(to, amount);
        lastActivity[to] = block.timestamp;
    }
    
    // 重写transfer函数
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(!blacklisted[from] && !blacklisted[to], "Blacklisted address");
        require(!kycRequired || (kycApproved[from] && kycApproved[to]), "KYC required");
        require(amount <= maxTransactionAmount, "Exceeds max transaction");
        
        // 检查每日限额
        _checkDailyLimit(from, amount);
        
        super._transfer(from, to, amount);
        
        // 更新活动时间
        lastActivity[from] = block.timestamp;
        lastActivity[to] = block.timestamp;
    }
    
    // 每日限额检查
    function _checkDailyLimit(address user, uint256 amount) private {
        uint256 today = block.timestamp / 1 days;
        
        if (lastTransferDay[user] < today) {
            dailyTransferred[user] = 0;
            lastTransferDay[user] = today;
        }
        
        require(
            dailyTransferred[user] + amount <= dailyTransferLimit,
            "Daily limit exceeded"
        );
        
        dailyTransferred[user] += amount;
    }
    
    // 冻结不活跃账户的资金
    function freezeInactiveAccount(address account) 
        external 
        onlyRole(BLACKLISTER_ROLE) 
    {
        require(
            block.timestamp - lastActivity[account] > inactivityThreshold,
            "Account still active"
        );
        blacklisted[account] = true;
        emit Blacklisted(account);
    }
    
    // 批量KYC审批
    function batchApproveKYC(address[] calldata accounts) 
        external 
        onlyRole(KYC_ROLE) 
    {
        for (uint256 i = 0; i < accounts.length; i++) {
            kycApproved[accounts[i]] = true;
            emit KYCApproved(accounts[i]);
        }
    }
    
    // 紧急提取（仅限被黑名单地址）
    function emergencyWithdraw(address blacklistedAccount, address to) 
        external 
        onlyRole(DEFAULT_ADMIN_ROLE) 
    {
        require(blacklisted[blacklistedAccount], "Account not blacklisted");
        uint256 amount = balanceOf(blacklistedAccount);
        _burn(blacklistedAccount, amount);
        _mint(to, amount);
    }
    
    // 升级授权
    function _authorizeUpgrade(address newImplementation)
        internal
        onlyRole(UPGRADER_ROLE)
        override
    {}
    
    // 暂停功能
    function pause() external onlyRole(PAUSER_ROLE) {
        _pause();
    }
    
    function unpause() external onlyRole(PAUSER_ROLE) {
        _unpause();
    }
    
    // 获取版本
    function version() external pure returns (string memory) {
        return "1.0.0";
    }
}

// deploy/01_deploy_stablecoin.js
const { ethers, upgrades } = require("hardhat");

module.exports = async ({ getNamedAccounts, deployments }) => {
    const { deploy } = deployments;
    const { deployer } = await getNamedAccounts();
    
    // 部署实现合约
    const EnterpriseStablecoin = await ethers.getContractFactory(
        "EnterpriseStablecoin"
    );
    
    const proxy = await upgrades.deployProxy(
        EnterpriseStablecoin,
        ["USD Stablecoin", "USDS", true], // 启用KYC
        { 
            initializer: "initialize",
            kind: "uups" 
        }
    );
    
    await proxy.deployed();
    console.log("Proxy deployed to:", proxy.address);
    
    // 获取实现地址
    const implementationAddress = await upgrades.erc1967.getImplementationAddress(
        proxy.address
    );
    console.log("Implementation deployed to:", implementationAddress);
    
    // 配置角色
    const MINTER_ROLE = ethers.utils.keccak256(
        ethers.utils.toUtf8Bytes("MINTER_ROLE")
    );
    const KYC_ROLE = ethers.utils.keccak256(
        ethers.utils.toUtf8Bytes("KYC_ROLE")
    );
    
    // 设置铸币者
    await proxy.grantRole(MINTER_ROLE, deployer);
    await proxy.setMinterAllowance(deployer, ethers.utils.parseUnits("1000000", 6));
    
    // 保存部署信息
    deployments.save("EnterpriseStablecoin", {
        address: proxy.address,
        implementation: implementationAddress,
        abi: EnterpriseStablecoin.interface.format("json"),
    });
};

// test/EnterpriseStablecoin.test.js
const { expect } = require("chai");
const { ethers, upgrades } = require("hardhat");

describe("EnterpriseStablecoin", function () {
    let stablecoin;
    let owner, minter, user1, user2, blacklister;
    let MINTER_ROLE, BLACKLISTER_ROLE, KYC_ROLE;
    
    beforeEach(async function () {
        [owner, minter, user1, user2, blacklister] = await ethers.getSigners();
        
        const EnterpriseStablecoin = await ethers.getContractFactory(
            "EnterpriseStablecoin"
        );
        stablecoin = await upgrades.deployProxy(
            EnterpriseStablecoin,
            ["Test USD", "TUSD", true],
            { kind: "uups" }
        );
        
        // 获取角色常量
        MINTER_ROLE = await stablecoin.MINTER_ROLE();
        BLACKLISTER_ROLE = await stablecoin.BLACKLISTER_ROLE();
        KYC_ROLE = await stablecoin.KYC_ROLE();
        
        // 配置角色
        await stablecoin.grantRole(MINTER_ROLE, minter.address);
        await stablecoin.grantRole(BLACKLISTER_ROLE, blacklister.address);
        await stablecoin.grantRole(KYC_ROLE, owner.address);
    });
    
    describe("KYC功能", function () {
        it("未通过KYC不能接收代币", async function () {
            await stablecoin.setMinterAllowance(
                minter.address, 
                ethers.utils.parseUnits("1000", 6)
            );
            
            await expect(
                stablecoin.connect(minter).mint(
                    user1.address, 
                    ethers.utils.parseUnits("100", 6)
                )
            ).to.be.revertedWith("KYC not approved");
        });
        
        it("通过KYC后可以正常交易", async function () {
            // 批准KYC
            await stablecoin.batchApproveKYC([user1.address, user2.address]);
            
            // 设置铸币额度
            await stablecoin.setMinterAllowance(
                minter.address, 
                ethers.utils.parseUnits("1000", 6)
            );
            
            // 铸币
            await stablecoin.connect(minter).mint(
                user1.address, 
                ethers.utils.parseUnits("100", 6)
            );
            
            // 转账
            await stablecoin.connect(user1).transfer(
                user2.address, 
                ethers.utils.parseUnits("50", 6)
            );
            
            expect(await stablecoin.balanceOf(user2.address))
                .to.equal(ethers.utils.parseUnits("50", 6));
        });
    });
    
    describe("升级功能", function () {
        it("可以升级到新版本", async function () {
            const EnterpriseStablecoinV2 = await ethers.getContractFactory(
                "EnterpriseStablecoinV2"
            );
            
            const upgraded = await upgrades.upgradeProxy(
                stablecoin.address,
                EnterpriseStablecoinV2
            );
            
            expect(await upgraded.version()).to.equal("2.0.0");
        });
    });
});

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

contract GasOptimizedStablecoin {
    // 传统存储变量
    mapping(address => uint256) public balances;
    
    // 瞬时存储键
    uint256 constant REENTRANCY_GUARD_SLOT = uint256(keccak256("reentrancy.guard"));
    uint256 constant TEMP_ALLOWANCE_SLOT = uint256(keccak256("temp.allowance"));
    
    // 使用瞬时存储的重入锁
    modifier nonReentrant() {
        assembly {
            if tload(REENTRANCY_GUARD_SLOT) {
                revert(0, 0)
            }
            tstore(REENTRANCY_GUARD_SLOT, 1)
        }
        _;
        assembly {
            tstore(REENTRANCY_GUARD_SLOT, 0)
        }
    }
    
    // 复杂的批量转账操作
    function batchTransferWithKYC(
        address[] calldata recipients,
        uint256[] calldata amounts,
        bytes[] calldata kycProofs
    ) external nonReentrant {
        require(recipients.length == amounts.length, "Length mismatch");
        
        uint256 totalAmount;
        
        // 第一次遍历：验证KYC并计算总额
        for (uint256 i = 0; i < recipients.length; i++) {
            // 使用瞬时存储缓存KYC验证结果
            bytes32 kycKey = keccak256(abi.encode(recipients[i], "kyc"));
            
            assembly {
                // 检查是否已验证
                if iszero(tload(kycKey)) {
                    // 验证KYC（简化版）
                    let kycValid := 1 // 假设验证通过
                    tstore(kycKey, kycValid)
                }
            }
            
            totalAmount += amounts[i];
        }
        
        // 检查总余额
        require(balances[msg.sender] >= totalAmount, "Insufficient balance");
        
        // 第二次遍历：执行转账
        for (uint256 i = 0; i < recipients.length; i++) {
            _transferOptimized(msg.sender, recipients[i], amounts[i]);
        }
    }
    
    // 优化的转账函数
    function _transferOptimized(
        address from,
        address to,
        uint256 amount
    ) internal {
        assembly {
            // 加载余额
            let fromBalance := sload(add(balances.slot, from))
            let toBalance := sload(add(balances.slot, to))
            
            // 检查余额
            if lt(fromBalance, amount) {
                revert(0, 0)
            }
            
            // 使用unchecked数学
            let newFromBalance := sub(fromBalance, amount)
            let newToBalance := add(toBalance, amount)
            
            // 存储新余额
            sstore(add(balances.slot, from), newFromBalance)
            sstore(add(balances.slot, to), newToBalance)
        }
    }
    
    // 使用瞬时存储的闪电贷
    function flashLoan(
        address receiver,
        uint256 amount,
        bytes calldata data
    ) external nonReentrant {
        uint256 balanceBefore = balances[address(this)];
        
        // 使用瞬时存储记录贷款信息
        assembly {
            tstore(TEMP_ALLOWANCE_SLOT, amount)
        }
        
        // 发送代币
        balances[address(this)] -= amount;
        balances[receiver] += amount;
        
        // 调用接收者
        IFlashLoanReceiver(receiver).onFlashLoan(amount, data);
        
        // 检查还款
        uint256 fee = amount * 3 / 1000; // 0.3% 费用
        require(
            balances[address(this)] >= balanceBefore + fee,
            "Flash loan not repaid"
        );
        
        // 清除瞬时存储
        assembly {
            tstore(TEMP_ALLOWANCE_SLOT, 0)
        }
    }
}

// 存储槽打包优化示例
contract StoragePackingExample {
    // 未优化：3个存储槽
    struct BadPacking {
        uint256 amount;     // 槽0
        bool active;        // 槽1
        uint128 limit;      // 槽2
    }
    
    // 优化后：2个存储槽
    struct GoodPacking {
        uint256 amount;     // 槽0
        uint128 limit;      // 槽1的前128位
        bool active;        // 槽1的第129位
        uint120 reserved;   // 槽1的剩余位
    }
    
    // 最优化：一个槽存储多个小数据
    struct UltraPacking {
        uint128 balance;
        uint64 lastUpdate;
        uint32 nonce;
        uint16 flags;
        uint8 decimals;
        uint8 version;
    } // 正好256位，一个槽
}

contract AssemblyOptimized {
    // 优化的批量余额查询
    function balanceOfBatch(
        address[] calldata accounts
    ) external view returns (uint256[] memory balances_) {
        assembly {
            let length := calldataload(add(accounts.offset, sub(0x20, 0x04)))
            
            // 分配内存
            balances_ := mload(0x40)
            let dataPtr := add(balances_, 0x20)
            mstore(0x40, add(dataPtr, mul(length, 0x20)))
            mstore(balances_, length)
            
            // 遍历账户
            for { let i := 0 } lt(i, length) { i := add(i, 1) } {
                let account := calldataload(add(accounts.offset, mul(i, 0x20)))
                
                // 计算存储位置
                mstore(0x00, account)
                mstore(0x20, balances.slot)
                let slot := keccak256(0x00, 0x40)
                
                // 读取并存储余额
                mstore(add(dataPtr, mul(i, 0x20)), sload(slot))
            }
        }
    }
    
    // 优化的余额更新（避免零到非零的SSTORE）
    function updateBalance(
        address account,
        uint256 newBalance
    ) external {
        assembly {
            // 计算存储位置
            mstore(0x00, account)
            mstore(0x20, balances.slot)
            let slot := keccak256(0x00, 0x40)
            
            let oldBalance := sload(slot)
            
            // 如果从零到非零，使用更贵的操作码
            // 如果从非零到零，可以获得gas退款
            switch newBalance
            case 0 {
                // 清零操作
                if oldBalance {
                    sstore(slot, 0)
                    // 获得退款
                }
            }
            default {
                // 更新操作
                if iszero(eq(oldBalance, newBalance)) {
                    sstore(slot, newBalance)
                }
            }
        }
    }
}

// EVM操作码成本对比
contract OpcodesCost {
    // 存储操作成本
    // SLOAD: 2100 gas (温读取) / 2600 gas (冷读取)
    // SSTORE: 2900 gas (温写入) / 22100 gas (冷写入从零到非零)
    // TLOAD: 100 gas
    // TSTORE: 100 gas
    
    // 内存操作成本
    // MLOAD: 3 gas
    // MSTORE: 3 gas
    // MSTORE8: 3 gas
    
    // 计算操作成本
    // ADD/SUB: 3 gas
    // MUL: 5 gas
    // DIV: 5 gas
    // EXP: 10 gas + 50 gas per byte
}

contract SecureStablecoin {
    using SafeMath for uint256;
    
    // 滑点保护
    function swapToUSDC(
        uint256 amount,
        uint256 minAmountOut,
        uint256 deadline
    ) external returns (uint256 amountOut) {
        require(block.timestamp <= deadline, "Expired");
        
        // 执行交换
        amountOut = IUniswapV2Router(router).swapExactTokensForTokens(
            amount,
            minAmountOut,  // 滑点保护
            path,
            msg.sender,
            deadline
        )[1];
        
        require(amountOut >= minAmountOut, "Slippage too high");
    }
    
    // CEI模式 (Checks-Effects-Interactions)
    function withdraw(uint256 amount) external nonReentrant {
        // Checks
        require(balances[msg.sender] >= amount, "Insufficient balance");
        require(amount > 0, "Zero amount");
        
        // Effects
        balances[msg.sender] = balances[msg.sender].sub(amount);
        totalSupply = totalSupply.sub(amount);
        
        // Interactions
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        
        emit Withdrawal(msg.sender, amount);
    }
    
    // 防止前端跑跑
    mapping(address => uint256) private lastActionBlock;
    
    modifier antiMEV() {
        require(
            lastActionBlock[msg.sender] < block.number,
            "Same block action"
        );
        lastActionBlock[msg.sender] = block.number;
        _;
    }
    
    // 严格的访问控制
    mapping(address => mapping(bytes4 => bool)) private permissions;
    
    modifier onlyPermitted(bytes4 selector) {
        require(
            permissions[msg.sender][selector],
            "No permission"
        );
        _;
    }
    
    // 参数验证
    modifier validAddress(address addr) {
        require(addr != address(0), "Zero address");
        require(addr != address(this), "Invalid target");
        _;
    }
}