Solidity 智能合约工程师

Here's a gas-optimized staking contract:

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

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract Staking is ReentrancyGuard {
    using SafeERC20 for IERC20;
    
    IERC20 public immutable stakingToken;
    IERC20 public immutable rewardToken;
    
    uint256 public rewardRate;        // rewards per second
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    uint256 public totalStaked;
    
    mapping(address => uint256) public stakedBalance;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;
    
    function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");
        totalStaked += amount;
        stakedBalance[msg.sender] += amount;
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
    }
    
    function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0 && stakedBalance[msg.sender] >= amount);
        totalStaked -= amount;
        stakedBalance[msg.sender] -= amount;
        // State updated BEFORE transfer (checks-effects-interactions)
        stakingToken.safeTransfer(msg.sender, amount);
    }
}

Gas optimizations:

• immutable for token addresses (saves ~2100 gas per read vs storage)
• SafeERC20 handles non-standard ERC20s that don't return bool
• State updates before transfers (CEI pattern + ReentrancyGuard)
• Reward calculation uses rewardPerToken pattern — O(1) per user, not O(n) loop

Security: ReentrancyGuard on all external functions, CEI pattern, no selfdestruct, OpenZeppelin base.

Two options, each with tradeoffs:

Option 1: UUPS Proxy (recommended for new contracts)

• Upgrade logic lives in the implementation contract, not the proxy
• Gas-efficient: no admin slot in every proxy call
• More secure: can't upgrade from proxy level, must go through implementation

import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract StakingV1 is UUPSUpgradeable, ReentrancyGuardUpgradeable {
    function initialize(address _stakingToken) public initializer {
        __UUPSUpgradeable_init();
        __ReentrancyGuard_init();
        stakingToken = IERC20(_stakingToken);
    }
    
    function _authorizeUpgrade(address) internal override onlyOwner {}
}

Critical rules for upgradeable contracts:

1. NEVER use constructors — use initializer functions
2. NEVER change the order of existing state variables in V2
3. ONLY append new variables at the end of the storage layout
4. Use @openzeppelin/upgrades Hardhat plugin to validate storage compatibility
5. Add a timelock on _authorizeUpgrade for production — don't let owner upgrade instantly

Option 2: Transparent Proxy (simpler but more gas)

• Admin address can upgrade, everyone else calls implementation
• Higher gas per call (~2100 gas overhead for admin check)
• Better for simple upgrade patterns

I recommend UUPS + 48-hour timelock for production staking contracts.