Solidity大循环异常求助：百万级代币查询返回空结果

你遇到的这个问题确实是Solidity开发中很常见的区块Gas限制坑，下面我来详细拆解原因和解决办法：

核心原因：区块Gas上限限制 #

Solidity中的view函数虽然不会修改链上状态、不需要支付Gas费用，但仍然会计算Gas消耗——当总Gas消耗超过当前区块允许的最大Gas上限时，整个调用会直接失败，返回空结果或者默认值（比如你的测试函数返回0）。

你的测试循环到384万次时触发失败，是因为这个循环消耗的总Gas刚好触达了区块的Gas上限（以太坊主网区块Gas上限约3000万，每次简单循环迭代大概消耗8-10Gas，384万次刚好接近这个数值）。而tokensOfOwner函数中，每次循环还要读取IndexToOwner这个storage变量，消耗的Gas比纯循环更多，所以当总供应量超过50万时就会触发Gas超限。

你的代码问题分析 #

先看你提供的tokensOfOwner函数：

function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) { 
    uint256 tokenCount = balanceOf(_owner); 
    if (tokenCount == 0) { 
        return new uint256[](0); 
    } else { 
        uint256[] memory result = new uint256[](tokenCount); 
        uint256 total = totalSupply(); 
        uint256 resultIndex = 0; 
        uint256 id; 
        for (id = 1; id <= total; id++) { 
            if (IndexToOwner[id] == _owner) { 
                result[resultIndex] = id; 
                resultIndex++; 
            } 
        } 
        return result; 
    } 
}

这个函数的核心问题在于：遍历所有已发行的代币ID来匹配用户地址，当总供应量达到百万级别时，循环次数过多，Gas消耗直接超过区块上限，导致调用失败返回空数组。

测试函数的情况类似：

function testLoop(uint256 num) external view returns(uint256 res) { 
    uint256 i=0; 
    uint256 cnt=0; 
    for(i;i<num;i++) { 
        cnt++; 
    } 
    return cnt; 
}

纯循环操作虽然Gas消耗低，但当循环次数足够大时，总Gas还是会触达上限，导致调用失败返回默认值0。

可行的解决方案 #

方案1：维护用户代币列表（最常用） #

在合约中新增一个mapping(address => uint256[]) public ownerToTokens，在代币铸造（mint）、转移（transfer）时同步更新这个列表，这样查询用户代币时直接返回该数组，无需遍历所有代币：

mapping(address => uint256[]) public ownerToTokens;
mapping(uint256 => uint256) public tokenToOwnerIndex; // 记录代币在owner列表中的索引，用于删除

// mint时添加
function mint(address _to, uint256 _tokenId) external {
    IndexToOwner[_tokenId] = _to;
    tokenToOwnerIndex[_tokenId] = ownerToTokens[_to].length;
    ownerToTokens[_to].push(_tokenId);
    // ...其他mint逻辑
}

// transfer时更新
function transferFrom(address _from, address _to, uint256 _tokenId) external {
    // 先从_from的列表中删除（用swap+pop节省Gas）
    uint256 index = tokenToOwnerIndex[_tokenId];
    uint256 lastTokenId = ownerToTokens[_from][ownerToTokens[_from].length - 1];
    ownerToTokens[_from][index] = lastTokenId;
    tokenToOwnerIndex[lastTokenId] = index;
    ownerToTokens[_from].pop();

    // 添加到_to的列表
    tokenToOwnerIndex[_tokenId] = ownerToTokens[_to].length;
    ownerToTokens[_to].push(_tokenId);
    IndexToOwner[_tokenId] = _to;
    // ...其他transfer逻辑
}

// 优化后的查询函数
function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
    return ownerToTokens[_owner];
}

这种方式查询Gas消耗极低，不管用户持有多少代币，都能瞬间返回结果。

方案2：使用枚举集合（OpenZeppelin工具） #

借助OpenZeppelin的EnumerableSet或EnumerableMap合约，来高效管理用户的代币集合，避免手动维护列表的繁琐：

import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

contract MyToken {
    using EnumerableSet for EnumerableSet.UintSet;
    mapping(address => EnumerableSet.UintSet) private _ownerTokens;

    // mint时添加
    function mint(address _to, uint256 _tokenId) external {
        _ownerTokens[_to].add(_tokenId);
        IndexToOwner[_tokenId] = _to;
        // ...其他逻辑
    }

    // transfer时更新
    function transferFrom(address _from, address _to, uint256 _tokenId) external {
        _ownerTokens[_from].remove(_tokenId);
        _ownerTokens[_to].add(_tokenId);
        IndexToOwner[_tokenId] = _to;
        // ...其他逻辑
    }

    // 查询函数
    function tokensOfOwner(address _owner) external view returns(uint256[] memory) {
        uint256 count = _ownerTokens[_owner].length();
        uint256[] memory tokens = new uint256[](count);
        for (uint256 i = 0; i < count; i++) {
            tokens[i] = _ownerTokens[_owner].at(i);
        }
        return tokens;
    }
}

OpenZeppelin的工具已经帮你优化了集合的增删查操作，安全性和Gas效率都有保障。

方案3：分页查询（兼容旧合约） #

如果无法修改合约逻辑（比如已经部署的合约），可以采用分页查询的方式，每次只查询一部分范围的tokenId，控制单次调用的Gas消耗：

function tokensOfOwnerPaginated(address _owner, uint256 startId, uint256 pageSize) external view returns(uint256[] memory, uint256 nextStartId) {
    uint256[] memory result = new uint256[](pageSize);
    uint256 resultIndex = 0;
    uint256 total = totalSupply();
    uint256 id = startId;

    while (id <= total && resultIndex < pageSize) {
        if (IndexToOwner[id] == _owner) {
            result[resultIndex] = id;
            resultIndex++;
        }
        id++;
    }

    // 裁剪数组到实际长度
    uint256[] memory trimmedResult = new uint256[](resultIndex);
    for (uint256 i = 0; i < resultIndex; i++) {
        trimmedResult[i] = result[i];
    }

    return (trimmedResult, id);
}

调用时每次传入startId和pageSize（比如pageSize设为1000），直到返回的nextStartId超过总供应量，就可以收集到所有用户代币。

内容的提问来源于stack exchange，提问作者HansPeterLoft