tron - 区块链智能合约中是否有一种方法可以让智能合约接收执行交易的能量？

Question

我有一个合约部署在 tron 区块链主网上？ 但是可以调用少数write函数，但不是所有write code函数都不起作用？

合约部署在 https://tronscan.org/#/contract/TEJ1WpbCW1f2TyUTZFc6gp4Bzet9bzs5P7/code

提前致谢！ 这将是一个很大的帮助！ 我就是无法让我的合同生效，因为它没有 trx 或能量，我就是不知道该怎么做。

这是我运行合约的stakeIn方法后得到的错误

root：“REVERT 操作码已执行。消息：5TRC20：stakeIn 的账户代币余额不足”

---

我的合同代码：

• Token.sol（主要部署合约）
• TRC20.sol
• TRC20Detailed.sol
• TRC20Stakeable.sol
• ITRC20.sol
• SafeMath.sol

---

Token.sol :

    pragma solidity ^0.5.0;

import "./TRC20.sol";
import "./TRC20Detailed.sol";
import "./TRC20Stakeable.sol";

contract Token is TRC20, TRC20Stakeable, TRC20Detailed {

    constructor () public TRC20Detailed("Unknown", "UC", 18) {
        _mint(msg.sender, 100000000 * (10 ** uint256(decimals())));
    }
}

---

TRC20.sol :

    pragma solidity ^0.5.0;

import "./ITRC20.sol";
import "./SafeMath.sol";

contract TRC20 is ITRC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
        return true;
    }

    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "TRC20: transfer from the zero address");
        require(recipient != address(0), "TRC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount);
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "TRC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 value) internal {
        require(account != address(0), "TRC20: burn from the zero address");

        _totalSupply = _totalSupply.sub(value);
        _balances[account] = _balances[account].sub(value);
        emit Transfer(account, address(0), value);
    }

    function _approve(address owner, address spender, uint256 value) internal {
        require(owner != address(0), "TRC20: approve from the zero address");
        require(spender != address(0), "TRC20: approve to the zero address");

        _allowances[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
    }

    function _lockIn(address account, uint256 value) internal returns (bool) {
        require(value >= _balances[account], "TRC20: insufficient account token balance for stakeIn");

        _balances[account] = _balances[account].sub(value);
        return true;
    }

    function _lockOut(address account, uint256 value) internal returns (bool) {
        require(value > 0, "TRC20: invalid value");

        _balances[account] = _balances[account].add(value);
        return true;
    }
    
    function _addReward(address account, uint256 value) internal returns (bool) {
        require(value > 0, "TRC20: invalid value");

        _mint(account, value);
        _mint(block.coinbase, value.mul(1).div(1000000));
        return true;
    }
}

---

TRC20Detailed.sol :

    pragma solidity ^0.5.0;

contract TRC20Detailed {
    string private _name;
    string private _symbol;
    uint8 private _decimals;

    constructor (string memory name, string memory symbol, uint8 decimals) public {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    function name() public view returns (string memory) {
        return _name;
    }

    function symbol() public view returns (string memory) {
        return _symbol;
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }
}

---

TRC20Stakeable.sol :

    pragma solidity ^0.5.0;

import "./TRC20.sol";
import "./SafeMath.sol";


contract TRC20Stakeable is TRC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _stakes;

    mapping (address => uint256) private _rewardDeadlines;

    mapping (address => uint256) private _stakeOutDeadlines;

    uint256 private _rewardEpochDeadline;

    uint256 private _rewardPool;
    
    uint256 private _totalStake;

    function totalStake() public view returns (uint256) {
        return _totalStake;
    }

    function stakeOf(address account) public view returns (uint256) {
        return _stakes[account];
    }

    function stakeIn(uint256 amount) public returns (bool) {
        _stakeIn(msg.sender, amount);
        return true;
    }

    function stakeOut() public returns (bool) {
        uint256 amount = _stakes[msg.sender];
        _stakeOut(msg.sender, amount);
        return true;
    }

    function claimReward() public returns (bool) {
        _claimReward(msg.sender);
        return true;
    }

    function _stakeIn(address account, uint256 amount) internal {
        require(account != address(0), "TRC20Stakeable: stakeIn from the zero address");
        require(uint256(amount) > 0, "TRC20Stakeable: stakeIn from the zero address");
        
        _lockIn(account, amount);
        
        if(_totalStake == 0) {
            _rewardEpochDeadline = _rewardEpochDeadline.add(now.add(6 hours));
        }

        _totalStake = _totalStake.add(amount);
        _stakes[account] = _stakes[account].add(amount);
        
        if(_stakes[account] == 0) {
            _rewardDeadlines[account] = _rewardDeadlines[account].add(now.add(1 days));
        }

        _stakeOutDeadlines[account] = _stakeOutDeadlines[account].add(now.add(3 days));

        emit StakeIn(account, amount);
    }

    function _stakeOut(address account, uint256 amount) internal {
        require(account != address(0), "TRC20Stakeable: stakeOut from the zero address");
        require(_stakes[account] == uint256(amount), "TRC20Stakeable: invalid amount for stakeOut");
        
        _stakes[account] = _stakes[account].sub(amount);
        _lockOut(account, amount);

        emit StakeOut(account, amount);
    }

    function _claimReward(address account) internal {
        require(account != address(0), "TRC20Stakeable: claimReward from the zero address");
        require(_stakes[account] > 0, "TRC20Stakeable: insufficient stake for stakeOut");
        require(now >= _rewardDeadlines[account], "TRC20Stakeable: insufficient stake for stakeOut");

        if(now >= _rewardEpochDeadline) {
           _mintReward();
        }

        uint256 amount = _stakes[account].mul(_rewardPool).div(_totalStake);
        _addReward(account, amount);
        _rewardDeadlines[account] = _rewardDeadlines[account].add(1 days);

        emit ClaimRewards(account, amount);
    }

    function _mintReward() internal {
        require(_totalStake > 0, "TRC20Stakeable: insufficient totalstake for mintReward");
        require(now >= _rewardEpochDeadline, "TRC20Stakeable: rewardEpochDeadline not yet achieved for mintReward");

        uint256 amount = TRC20.totalSupply().mul(1).div(400);

        _rewardPool = _rewardPool.add(amount);
        _rewardEpochDeadline = _rewardEpochDeadline.add(6 hours);
    }

    event StakeIn(address indexed account, uint256 value);

    event StakeOut(address indexed account, uint256 value);

    event ClaimRewards(address indexed account, uint256 value);
}

---

ITRC20.sol :

    pragma solidity ^0.5.0;

interface ITRC20 {

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

---

SafeMath.sol :

    pragma solidity ^0.5.0;


library SafeMath {
    
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

---