VM錯誤：如果您發送值，則應支付建構子

我使用了來自https://www.ethereum.org/token#the-code的代幣合約。我已將買入/賣出價格設置為 1000000000000000000 wei，但是當我嘗試通過發送 1 個乙太幣從另一個帳戶購買代幣時，它返回錯誤！

我用過 Remix Solidity Ide 編譯器版本：0.4.22+commit.4cb486ee.Emscripten.clang 環境：Java Script VM

pragma solidity ^0.4.16;

contract owned {
address public owner;
constructor() public {
   owner = msg.sender;
}

modifier onlyOwner {
   require(msg.sender == owner);
   _;
}

function transferOwnership(address newOwner) onlyOwner public {
   owner = newOwner;
}
}

interface tokenRecipient { function receiveApproval(address _from, uint256 
_value, address _token, bytes _extraData) external; }

contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
uint256 public totalSupply;

// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);

// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 
_value);

// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);

/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the 
contract
*/
constructor(
   uint256 initialSupply,
   string tokenName,
   string tokenSymbol
) public payable {
   totalSupply = initialSupply * 10 ** uint256(decimals);  // Update total 
supply with the decimal amount
   balanceOf[msg.sender] = totalSupply;                // Give the creator 
      all initial tokens
   name = tokenName;                                   // Set the name for 
    display purposes
   symbol = tokenSymbol;                               // Set the symbol 
       for display purposes
}

/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal{
   // Prevent transfer to 0x0 address. Use burn() instead
   require(_to != 0x0);
   // Check if the sender has enough
   require(balanceOf[_from] >= _value);
   // Check for overflows
   require(balanceOf[_to] + _value > balanceOf[_to]);
   // Save this for an assertion in the future
   uint previousBalances = balanceOf[_from] + balanceOf[_to];
   // Subtract from the sender
   balanceOf[_from] -= _value;
   // Add the same to the recipient
   balanceOf[_to] += _value;
   emit Transfer(_from, _to, _value);
   // Asserts are used to use static analysis to find bugs in your code. 
They should never fail
   assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}

/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) 
{
   _transfer(msg.sender, _to, _value);
   return true;
}

/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
 function transferFrom(address _from, address _to, uint256 _value) public 
returns (bool success) {
   require(_value <= allowance[_from][msg.sender]);     // Check allowance
   allowance[_from][msg.sender] -= _value;
   _transfer(_from, _to, _value);
   return true;
}

/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
   returns (bool success) {
   allowance[msg.sender][_spender] = _value;
   emit Approval(msg.sender, _spender, _value);
   return true;
}

/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, 
 and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
   public
   returns (bool success) {
   tokenRecipient spender = tokenRecipient(_spender);
   if (approve(_spender, _value)) {
       spender.receiveApproval(msg.sender, _value, this, _extraData);
       return true;
   }
}

/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
   require(balanceOf[msg.sender] >= _value);   // Check if the sender has 
enough
   balanceOf[msg.sender] -= _value;            // Subtract from the sender
   totalSupply -= _value;                      // Updates totalSupply
   emit Burn(msg.sender, _value);
   return true;
}

/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool 
success) {
   require(balanceOf[_from] >= _value);                // Check if the 
targeted balance is enough
   require(_value <= allowance[_from][msg.sender]);    // Check allowance
   balanceOf[_from] -= _value;                         // Subtract from the 
targeted balance
   allowance[_from][msg.sender] -= _value;         // Subtract from the sender's allowance
   totalSupply -= _value;                              // Update 
totalSupply
   emit Burn(_from, _value);
   return true;
}
}

contract MyAdvancedToken is owned, TokenERC20 {

uint256 public sellPrice;
uint256 public buyPrice;

mapping (address => bool) public frozenAccount;

/* This generates a public event on the blockchain that will notify clients 
 */
           event FrozenFunds(address target, bool frozen);

/* Initializes contract with initial supply tokens to the creator of the 
contract */
constructor(
   uint256 initialSupply,
   string tokenName,
   string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public payable {}

/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
   require (_to != 0x0);                               // Prevent transfer 
to 0x0 address. Use burn() instead
   require (balanceOf[_from] >= _value);               // Check if the 
sender has enough
   require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for 
overflows
   require(!frozenAccount[_from]);                     // Check if sender is frozen
   require(!frozenAccount[_to]);                       // Check if recipient is frozen
   balanceOf[_from] -= _value;                         // Subtract from the sender
   balanceOf[_to] += _value;                           // Add the same to the recipient
   emit Transfer(_from, _to, _value);
}

/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
   balanceOf[target] += mintedAmount;
   totalSupply += mintedAmount;
   emit Transfer(0, this, mintedAmount);
   emit Transfer(address(this), target, mintedAmount);
}

/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
   frozenAccount[target] = freeze;
   emit FrozenFunds(target, freeze);
}

/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
   sellPrice = newSellPrice;
   buyPrice = newBuyPrice;
}

/// @notice Buy tokens from contract by sending ether
function buy() payable public {
   uint amount = msg.value / buyPrice;               // calculates the amount
   _transfer(this, msg.sender, amount);              // makes the transfers
}

/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
   address myAddress = this;
   require(myAddress.balance >= amount * sellPrice);      // checks if the contract has enough ether to buy
   _transfer(msg.sender, this, amount);              // makes the transfers
   msg.sender.transfer(amount * sellPrice);          // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}

見過幾個這樣的問題..但還沒有解決方案

一旦我通過刪除額外的換行符來編譯你的程式碼，你的程式碼就可以正常工作了。（您文章中的程式碼有換行符，導致某些評論不再是評論。）

這是我在 Remix 中所做的：

1. 使用參數進行部署1, "test token", "TEST"。這使部署地址擁有 1 個令牌。（用 驗證balanceOf。）
2. transfer使用參數呼叫<address of contract>, 1以將令牌轉移到合約。（用 驗證balanceOf。）
3. setPrices使用參數呼叫以將0, "1000000000000000000"其設置buyPrice為1*10^18。（用 驗證buyPrice。）
4. 呼叫buy並附加 1 個乙太幣。
5. 以我的地址作為參數呼叫balanceOf以驗證我現在有 1 個令牌。

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