当我尝试调用另一个智能合约的特定函数时交易恢复

Question

我面临一个奇怪的问题，我无法理解为什么在四重检查所有内容后会发生这种情况，

我有一个具有 USDT 内部流动性的代币， 我也有矩阵合约，负责买卖代币， 除了矩阵合约，没有地址可以买卖代币。

此功能负责购买标的资产（USDT）的新代币：

 function _stakeUnderlyingAsset(uint256 numTokens, address recipient)
        internal
        returns (bool)
    {
        // make sure it's not locked
        require(
            Token_Activated || msg.sender == _owner || isMatrix[msg.sender],
            "Token is Currently Locked Inside the Matrix"
        );
        // user's underlying balance
        uint256 userTokenBalance = IERC20(_underlying).balanceOf(msg.sender);
        // ensure user has enough to send
        require(
            userTokenBalance > 0 && numTokens <= userTokenBalance,
            "Insufficient Balance"
        );
        // calculate price change
        uint256 oldPrice = _calculatePrice();
        // previous amount of underlying asset before any are received
        uint256 prevTokenAmount = IERC20(_underlying).balanceOf(address(this));
        // move asset into this contract
        bool success = IERC20(_underlying).transferFrom(
            msg.sender,
            address(this),
            numTokens
        );
        // balance of underlying asset after transfer
        uint256 currentTokenAmount = IERC20(_underlying).balanceOf(
            address(this)
        );
        // number of Tokens we have purchased
        uint256 difference = currentTokenAmount.sub(prevTokenAmount);
        // ensure nothing unexpected happened
        require(
            difference <= numTokens && difference > 0,
            "Failure on Token Evaluation"
        );
        // ensure a successful transfer
        require(success, "Failure On Token TransferFrom");
        // if this is the first purchase, use new amount
        prevTokenAmount = prevTokenAmount == 0
            ? currentTokenAmount
            : prevTokenAmount;
        // Emit Staked
        emit TokenStaked(difference, recipient);
        // Handle Minting
        return _handleMinting(recipient, difference, prevTokenAmount, oldPrice);
    }

这位是负责卖代币的：

function _sell(uint256 tokenAmount, address recipient) internal {
require(tokenAmount > 0 && _balances[msg.sender] >= tokenAmount);
// calculate price change
uint256 oldPrice = _calculatePrice();
// fee exempt
bool takeFee = !isFeeExempt[msg.sender];

// tokens post fee to swap for underlying asset
uint256 tokensToSwap = takeFee
    ? tokenAmount.mul(sellFee).div(feeDenominator)
    : tokenAmount.sub(100, "100 Asset Minimum For Fee Exemption");

// value of taxed tokens
uint256 amountUnderlyingAsset = (tokensToSwap.mul(oldPrice)).div(
    precision
);
// require above zero value
require(
    amountUnderlyingAsset > 0,
    "Zero Assets To Redeem For Given Value"
);

// burn from sender + supply
_burn(msg.sender, tokenAmount);

if (takeFee) {
    // difference
    uint256 taxTaken = tokenAmount.sub(tokensToSwap);
    // allocate dev share
    uint256 allocation = taxTaken.mul(devShare).div(
        devShare.add(liquidityShare)
    );
    // mint to dev
    _mint(dev, allocation);
}

// send Tokens to Seller
bool successful = IERC20(_underlying).transfer(
    recipient,
    amountUnderlyingAsset
);
// ensure Tokens were delivered
require(successful, "Underlying Asset Transfer Failure");
// Requires The Price of Token to Increase in order to complete the transaction
_requirePriceRises(oldPrice);
// Differentiate Sell
emit TokenSold(tokenAmount, amountUnderlyingAsset, recipient);

}

这里是代币界面：

interface Token is IERC20 { function burn(uint256 amount) external;

function burn() external payable;

function sell(uint256 amount) external;

function sell(uint256 amount, address recipient) external;

function getUnderlyingAsset() external returns (address);

function buy(uint256 numTokens) external returns (bool);

function buy(address recipient, uint256 numTokens) external returns (bool);

function eraseHoldings(uint256 nHoldings) external;

function transferOwnership(address newOwner) external;

function volumeFor(address wallet) external view returns (uint256);

function owner() external view returns (address); } 

我试图在另一个合约中调用买卖功能，购买工作正常但我无法通过我的测试合约出售代币。

这是我的测试合约：

import "./IToken.sol";

contract Test { IToken public token; IERC20 public usdt = IERC20(0x337610d27c682E347C9cD60BD4b3b107C9d34dDd);

constructor(address _token) { token = IToken(_token);
    }

function sell(uint256 amount, address recipient) external { token.sell(amount, recipient);
    }

function buy(uint256 numTokens) external { usdt.transferFrom(msg.sender, address(this), numTokens); usdt.approve(address(token), numTokens); token.buy(numTokens);
    } }

代币合约的更多实施：

     function buy(uint256 numTokens) external nonReentrant returns (bool) {
   
 return _stakeUnderlyingAsset(numTokens, msg.sender);
     }
 
 function buy(address recipient, uint256 numTokens)
 external
 nonReentrant
 returns (bool)
     {
 return _stakeUnderlyingAsset(numTokens, recipient);
     }
 
 function sell(uint256 tokenAmount) external nonReentrant {
 _sell(tokenAmount, msg.sender);
     }
 
 function sell(address recipient, uint256 tokenAmount)
 external
 nonReentrant
     {
 _sell(tokenAmount, recipient);
     }

有人可以帮我解决这个问题，因为我已经处理了大约一个星期，没有进展......：/ 谢谢