智能合约销毁转移给它的erc20代币

Question

我想制定一个智能合约来销毁转移到其中的代币。

我的代币合约

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GameToken is ERC20, ERC20Burnable, Ownable {
    uint256 public totalBurned;

    constructor() ERC20("Invader Pixel Token", "IPX") Ownable(msg.sender) {
        _mint(msg.sender, 0 * 10 ** 18);
    }

    function mintBySwapContract(address to, uint256 amount) external {
        require(msg.sender == swapContract, "Not authorized to mint");
        _mint(to, amount);
    }

    function mintByOwner(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }

    function burn(uint256 amount) public override {
        super.burn(amount);
        totalBurned += amount;
    }

    function burnFrom(address account, uint256 amount) public override {
        super.burnFrom(account, amount);
        totalBurned += amount;
    }

    address public swapContract;

    function setSwapContract(address _swapContract) external onlyOwner {
        swapContract = _swapContract;
    }
}

我的合同会烧掉他们

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

import "./GameToken.sol";

contract BurnContract {
    GameToken public gameToken;

    struct BurnRecord {
        address sender;
        uint256 tokenAmount;
    }

    BurnRecord[] public burnRecords;

    constructor(GameToken _gameToken) {
        gameToken = _gameToken;
    }

    fallback() external {
        uint256 tokensToBurn = gameToken.balanceOf(address(this));
        require(tokensToBurn > 0, "No tokens to burn");
        gameToken.burn(tokensToBurn);

        burnRecords.push(
            BurnRecord({
                sender: msg.sender,
                tokenAmount: tokensToBurn
            })
        );
    }

    function getBurnRecordsByAddress(
        address _address
    ) external view returns (uint256 totalTokensBurnt) {
        uint256 tokensBurntByAddress = 0;
        for (uint256 i = 0; i < burnRecords.length; i++) {
            if (burnRecords[i].sender == _address) {
                tokensBurntByAddress += burnRecords[i].tokenAmount;
            }
        }
        return tokensBurntByAddress;
    }
}

代币被发送到合约，但没有被烧毁。我不知道是什么导致了这个问题。我可以在资源管理器中查看此合约中的代币。发件人的代币会减少，但不会发生销毁。是回退功能出错了吗？

我的nextjs使用了转账功能

const tokenContract = new ethers.Contract(gameTokenAddress, gameTokenABI, signer);
    
            const tokenAmount = ethers.utils.parseEther(burnAmount.toString());
            const gasLimit = ethers.utils.parseUnits('10', 'gwei');
    
            const transferTx = await tokenContract.transfer(burnContractAddress, tokenAmount, {
                gasLimit: gasLimit,
            });

            const receipt = await transferTx.wait();
            setHash(await receipt.transactionHash)

Answer 1

当代币转移到您的合约中时，您无法进行后备。仅当有人将 ETH 转移到合约时才会调用您那里的后备函数。简而言之，没有办法自动使用 ERC20。

如果您自己部署 ERC20 并且希望自动部署，那么您必须将该回调添加到 ERC20 中以调用您的

BurnContract

，但这是您必须添加的自定义。

这是因为你的合约要做某事，就必须有人向它发送交易，而代币转账是代币合约上的交易，而不是接收者地址/合约上的交易，而 ETH 转账是发送到接收者地址的交易，这就是为什么您可以在那里进行回调。简而言之，您

BurnContract

不知道有人向它发送代币，除非有人调用它，在这种情况下它可以检查自己的余额。