在私有鏈中生成新令牌時出錯

pragma solidity ^0.4.25;


// ERC20 Token Smart Contract
contract MyToken {
   string public constant name = "MyToken";
   string public constant symbol = "MYT";
   uint8 public constant decimals = 0;
   uint public _totalSupply = 1000000;
   uint256 public RATE = 1;
   bool public isMinting = false;
   string public constant generatedBy  = "Togen.io by Proof Suite";

   using SafeMath for uint256;
   address public owner;

   // Functions with this modifier can only be executed by the owner
   modifier onlyOwner() {
       if(msg.sender != owner) {
           throw;
       }
       _;
   }

   // Balances for each account
   mapping(address => uint256) balances;
   // Owner of account approves the transfer of an amount to another account
   mapping(address => mapping(address=>uint256)) allowed;

   // Its a payable function works as a token factory.
   function () payable {
       createTokens();
   }

   // Constructor
   constructor() public {
       owner = msg.sender; 
       balances[owner] = _totalSupply;
   }

   //allows owner to burn tokens that are not sold in a crowdsale
   function burnTokens(uint256 _value) onlyOwner {
       require(balances[msg.sender] >= _value && _value > 0);
       _totalSupply = _totalSupply.sub(_value);
       balances[msg.sender] = balances[msg.sender].sub(_value);
   }

   // This function creates Tokens  
   function createTokens() payable {
       if(isMinting == true) {
           require(msg.value > 0);
           uint256  tokens = msg.value.div(100000000000000).mul(RATE);
           balances[msg.sender] = balances[msg.sender].add(tokens);
           _totalSupply = _totalSupply.add(tokens);
           owner.transfer(msg.value);
       }
       else {
           throw;
       }
   }

   function endCrowdsale() onlyOwner {
       isMinting = false;
   }

   function changeCrowdsaleRate(uint256 _value) onlyOwner {
       RATE = _value;
   }

   function totalSupply() constant returns(uint256) {
       return _totalSupply;
   }

   // What is the balance of a particular account?
   function balanceOf(address _owner) constant returns(uint256) {
       return balances[_owner];
   }

   // Transfer the balance from owner's account to another account   
   function transfer(address _to, uint256 _value) returns(bool) {
       require(balances[msg.sender] >= _value && _value > 0);
       balances[msg.sender] = balances[msg.sender].sub(_value);
       balances[_to] = balances[_to].add(_value);
       Transfer(msg.sender, _to, _value);
       return true;
   }

   // Send _value amount of tokens from address _from to address _to
   // The transferFrom method is used for a withdraw workflow, allowing contracts to send
   // tokens on your behalf, for example to "deposit" to a contract address and/or to charge
   // fees in sub-currencies; the command should fail unless the _from account has
   // deliberately authorized the sender of the message via some mechanism; we propose
   // these standardized APIs for approval:
   function transferFrom(address _from, address _to, uint256 _value) returns(bool) {
       require(allowed[_from][msg.sender] >= _value && balances[_from] >= _value && _value > 0);
       balances[_from] = balances[_from].sub(_value);
       balances[_to] = balances[_to].add(_value);
       allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
       Transfer(_from, _to, _value);
       return true;
   }

   // Allow _spender to withdraw from your account, multiple times, up to the _value amount.
   // If this function is called again it overwrites the current allowance with _value.
   function approve(address _spender, uint256 _value) returns(bool) {
       allowed[msg.sender][_spender] = _value; 
       Approval(msg.sender, _spender, _value);
       return true;
   }

   // Returns the amount which _spender is still allowed to withdraw from _owner
   function allowance(address _owner, address _spender) constant returns(uint256) {
       return allowed[_owner][_spender];
   }

   event Transfer(address indexed _from, address indexed _to, uint256 _value);
   event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

我使用Togen實用程序生成了一個代幣合約。而且它似乎工作正常。批准、轉移和吸氣劑工作正常。但是當我試圖生成新的令牌時，從 remix 呼叫該函式告訴我應該支付建構子。但我不能呼叫那個函式

編輯： //它的應付函式用作令牌工廠。函式 () 應付 { createTokens(msg.value); }

   // This function creates Tokens  
   function createTokens(uint256 value) private /*payable*/ {
       if(isMinting == true) {
           require(value > 0);
           uint256 tokens = value.div(100000000000000).mul(RATE);
           balances[msg.sender] = balances[msg.sender].add(tokens);
           _totalSupply = _totalSupply.add(tokens);
           owner.transfer(value);
       }
       else {
           throw;
       }
   }

編輯2：

我在變數中硬編碼 de 值。但問題依然存在。注意：如果您發送值，則應支付建構子。

   // This function creates Tokens  
   function createTokens() payable {
       if(isMinting == true) {
           uint testValue = 6666;
           require(/*msg.value*/testValue > 0);
           uint256 tokens = /*msg.value*/testValue.div(100000000000000).mul(RATE);
           balances[msg.sender] = balances[msg.sender].add(tokens);
           _totalSupply = _totalSupply.add(tokens);
           owner.transfer(/*msg.value*/testValue);
       }
       else {
           throw;
       }
   }

顯然，您向引用的函式 createTokens() 發送了一個零值交易（參見圖片中的 wei= 0），並且您有一個特定的要求：

require(msg.value > 0);

那場火。

所以它恢復了。

您的建構子不需要支付。

評論後編輯

如果您想通過硬編碼值（即“6666”）模擬機制，我可以建議註釋掉最後一行（owner.transfer…）。如果您成功地從令牌編號計算中不為零，它將很容易工作。

再次編輯

// This function creates Tokens  
function createTokens() payable {
   if(isMinting == true){
       uint testValue = 666600000000000000;
       require(/*msg.value*/ testValue > 0);
       uint256  tokens = /*msg.value*/testValue.div(100000000000000).mul(RATE);
       balances[msg.sender] = balances[msg.sender].add(tokens);
       _totalSupply = _totalSupply.add(tokens);
      // owner.transfer(/*msg.value*/testValue);
   }
   else{
       throw;
   }
}

這可以工作。

// Its a payable function works as a token factory.
function () payable{
   createTokens();
}

// This function creates Tokens  
function createTokens() payable {
   if(isMinting == true){
       require(msg.value > 0);
       uint256  tokens = msg.value.div(100000000000000).mul(RATE);
       balances[msg.sender] = balances[msg.sender].add(tokens);
       _totalSupply = _totalSupply.add(tokens);
       owner.transfer(msg.value);
   }
   else{
       throw;
   }
}

如果你嘗試createTokens通過回調函式呼叫函式（即通過向合約發送乙太幣），那麼在createTokens函式內部，msg.value已經是 0。

您可以按如下方式解決此問題：

• createTokens將函式聲明為作為輸入的private函式uint256 value
• msg.value將此函式中的每次出現替換為value
• 去掉payable這個函式聲明中的修飾符
• 當你從回退函式呼叫它時，通過msg.value

引用自：https://ethereum.stackexchange.com/questions/65601