First of all, I'd like to provide a disclaimer. I'm not a developer, I never studied codes, and never wrote scripts since I was 14 years old. I'm doing this project for the company I work in at the moment, and as I was trying to create a token through ethereum, I constantly receive this error:

"throw" is deprecated in favour of "revert()", "require()" and "assert()".
        if (_to == 0x0) throw;                               
// Prevent transfer to 0x0 address. Use burn() instead
                        ^---^, 

This error pops up every time I type in the code provided by ethereum, their template. I do not know why this is happening, nor do I know how to fix it. I looked everywhere online, but I cannot seem to find anyone else facing the same issue. How do I fix this? am I doing this wrong? it is the first time I try to deploy a contract on the server and not on the test net. Thank you in advance!

Here's the code:

pragma solidity ^0.4.8;
contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); }

contract MyToken {
/* Public variables of the token */
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
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 notifies clients about the amount burnt */
event Burn(address indexed from, uint256 value);

/* Initializes contract with initial supply tokens to the creator of the contract */
function MyToken(
    uint256 initialSupply,
    string tokenName,
    uint8 decimalUnits,
    string tokenSymbol
    ) {
    balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
    totalSupply = initialSupply;                        // Update total supply
    name = tokenName;                                   // Set the name for display purposes
    symbol = tokenSymbol;                               // Set the symbol for display purposes
    decimals = decimalUnits;                            // Amount of decimals for display purposes
}

/* Send coins */
function transfer(address _to, uint256 _value) {
    if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
    if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
    if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
    balanceOf[msg.sender] -= _value;                     // Subtract from the sender
    balanceOf[_to] += _value;                            // Add the same to the recipient
    Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
}

/* Allow another contract to spend some tokens in your behalf */
function approve(address _spender, uint256 _value)
    returns (bool success) {
    allowance[msg.sender][_spender] = _value;
    return true;
}

/* Approve and then communicate the approved contract in a single tx */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
    returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
}        

/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
    if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
    if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
    if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
    if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
    balanceOf[_from] -= _value;                           // Subtract from the sender
    balanceOf[_to] += _value;                             // Add the same to the recipient
    allowance[_from][msg.sender] -= _value;
    Transfer(_from, _to, _value);
    return true;
}

function burn(uint256 _value) returns (bool success) {
    if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
    balanceOf[msg.sender] -= _value;                      // Subtract from the sender
    totalSupply -= _value;                                // Updates totalSupply
    Burn(msg.sender, _value);
    return true;
}

function burnFrom(address _from, uint256 _value) returns (bool success) {
    if (balanceOf[_from] < _value) throw;                // Check if the sender has enough
    if (_value > allowance[_from][msg.sender]) throw;    // Check allowance
    balanceOf[_from] -= _value;                          // Subtract from the sender
    totalSupply -= _value;                               // Updates totalSupply
    Burn(_from, _value);
    return true;
}

}

The code is from the ethereum.org token example

  • Please, put your code or where you are using this "throw". – Gawey Jul 25 '17 at 13:48
  • what about if (now < closingTime && msg.value > 0 && (privateCreation == 0 || privateCreation == msg.sender)) { etc } throw; ? – Hus Jul 26 '17 at 13:45
  • @Hus require(now < closingTime && msg.value > 0 && (privateCreation == 0 || privateCreation == msg.sender)); { etc } – Joe Jul 26 '17 at 15:04

throw was deprecated in solidity version 0.4.13. You need to replace each line that says if(condition) throw; with require(opposite of condition);. For example:

if (_to == 0x0) throw;

becomes

require(_to != 0x0);

throw is used a number of times throughout your code, you need to change every one

so it will be this one:

    /* Send coins */
function transfer(address _to, uint256 _value) {
    require (_to != 0x0) ;                               // Prevent transfer to 0x0 address. Use burn() instead
    if (balanceOf[msg.sender] < _value);           // Check if the sender has enough
    if (balanceOf[_to] + _value < balanceOf[_to]); // Check for overflows
    balanceOf[msg.sender] -= _value;                     // Subtract from the sender
    balanceOf[_to] += _value;                            // Add the same to the recipient
    Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
}

OR:

    /* Send coins */
function transfer(address _to, uint256 _value) {
    require (_to != 0x0) ;                               // Prevent transfer to 0x0 address. Use burn() instead
    if (balanceOf[msg.sender] < _value) require;           // Check if the sender has enough
    if (balanceOf[_to] + _value < balanceOf[_to]) require; // Check for overflows
    balanceOf[msg.sender] -= _value;                     // Subtract from the sender
    balanceOf[_to] += _value;                            // Add the same to the recipient
    Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
}

.. if () require; or without?

This is just a warning and your code should still get compiled successfully.

You can check out below link regarding the open issue on Github about completely deprecating throw.

Depricating throw

throw will consume all you gas where as revert will return the unused gas.

you can also go through solidity docs.

Your Answer

 

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.