1

getting errors on creating a token with the sample scripts I found, saying throw has been depreciated and to use revert, assert or require. I tried different combinations but it does not work, I'm not a script programmer, so I have limited knowledge.

Here is the code:

pragma solidity ^0.4.2;
contract owned {
address public owner;

function owned() {
    owner = msg.sender;
}

modifier onlyOwner {
    if (msg.sender != owner) throw;
    _;
}

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

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

contract token {
/* 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);

/* Initializes contract with initial supply tokens to the creator of the contract */
function token(
    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 (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 (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;
}

/* This unnamed function is called whenever someone tries to send ether to it */
function () {
    throw;     // Prevents accidental sending of ether
}
}

contract MyAdvancedToken is owned, token {

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 */
function MyAdvancedToken(
    uint256 initialSupply,
    string tokenName,
    uint8 decimalUnits,
    string tokenSymbol
) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}

/* Send coins */
function transfer(address _to, uint256 _value) {
    if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
    if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
    if (frozenAccount[msg.sender]) throw;                // Check if frozen
    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
}


/* A contract attempts to get the coins */
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
    if (frozenAccount[_from]) throw;                        // Check if frozen            
    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 mintToken(address target, uint256 mintedAmount) onlyOwner {
    balanceOf[target] += mintedAmount;
    totalSupply += mintedAmount;
    Transfer(0, this, mintedAmount);
    Transfer(this, target, mintedAmount);
}

function freezeAccount(address target, bool freeze) onlyOwner {
    frozenAccount[target] = freeze;
    FrozenFunds(target, freeze);
}

function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
    sellPrice = newSellPrice;
    buyPrice = newBuyPrice;
}

function buy() payable {
    uint amount = msg.value / buyPrice;                // calculates the amount
    if (balanceOf[this] < amount) throw;               // checks if it has enough to sell
    balanceOf[msg.sender] += amount;                   // adds the amount to buyer's balance
    balanceOf[this] -= amount;                         // subtracts amount from seller's balance
    Transfer(this, msg.sender, amount);                // execute an event reflecting the change
}

function sell(uint256 amount) {
    if (balanceOf[msg.sender] < amount ) throw;        // checks if the sender has enough to sell
    balanceOf[this] += amount;                         // adds the amount to owner's balance
    balanceOf[msg.sender] -= amount;                   // subtracts the amount from seller's balance
    if (!msg.sender.send(amount * sellPrice)) {        // sends ether to the seller. It's important
        throw;                                         // to do this last to avoid recursion attacks
    } else {
        Transfer(msg.sender, this, amount);            // executes an event reflecting on the change
    }               
}
}
5
  • 1
    Paste your source code here? Aug 3 '17 at 18:47
  • Try replacing throw with revert()
    – niksmac
    Aug 4 '17 at 0:41
  • I started answering but it was getting convoluted. It compiles using a compiler that was available around the time it was authored, say ... 0.4.2 that it's asking for in the first line. A word of caution about using it for anything serious. How are you compiling the program? Aug 4 '17 at 1:37
  • Are you sure you got error, It should generally be a warning and I was able to compile your code in remix without errors and for the warnings try replacing throw with revert.
    – Rangesh
    Aug 4 '17 at 1:38
  • This is just warning as throw has been deprecated. you can use revert() in stead of throw or change the code to with require() or assert() in stead of "if" condition.
    – Abhishek
    Aug 4 '17 at 6:46
1

Revert, require and assert were added in solidity version 0.4.10 and syntax checker in 0.4.13. So if you compile using 0.4.2, it will not work as in that compiler version, the functions were not present

As a general practice please include revert, require and assert instead of throw as throw has been deprecated since 4.13.

Read the usage of require assert and revert from here

0

There is no error, just got some warnings, and warning doesn't block execute. And now, i replaced some warnings, the warning of send function could be ignored, because you have a judgement when send failed.

pragma solidity ^0.4.2;
contract owned {

    address public owner;

    function owned() {
      owner = msg.sender;
    }

    modifier onlyOwner {
      if (msg.sender != owner) revert();
        _;
    }

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

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

contract token {

  /* 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);

  /* Initializes contract with initial supply tokens to the creator of the contract */
  function token(
      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 (balanceOf[msg.sender] < _value) revert();           // Check if the sender has enough
      if (balanceOf[_to] + _value < balanceOf[_to]) revert(); // 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 (balanceOf[_from] < _value) revert();                 // Check if the sender has enough
      if (balanceOf[_to] + _value < balanceOf[_to]) revert();  // Check for overflows
      if (_value > allowance[_from][msg.sender]) revert();   // 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;
  }

  /* This unnamed function is called whenever someone tries to send ether to it */
  function () {
      revert();     // Prevents accidental sending of ether
  }

}

contract MyAdvancedToken is owned, token {

  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 */
  function MyAdvancedToken(
      uint256 initialSupply,
      string tokenName,
      uint8 decimalUnits,
      string tokenSymbol
      ) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}

  /* Send coins */
  function transfer(address _to, uint256 _value) {

      if (balanceOf[msg.sender] < _value) revert();           // Check if the sender has enough
      if (balanceOf[_to] + _value < balanceOf[_to]) revert(); // Check for overflows
      if (frozenAccount[msg.sender]) revert();                // Check if frozen

      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
  }


  /* A contract attempts to get the coins */
  function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
      if (frozenAccount[_from]) revert();                        // Check if frozen            
      if (balanceOf[_from] < _value) revert();                 // Check if the sender has enough
      if (balanceOf[_to] + _value < balanceOf[_to]) revert();  // Check for overflows
      if (_value > allowance[_from][msg.sender]) revert();   // 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 mintToken(address target, uint256 mintedAmount) onlyOwner {
      balanceOf[target] += mintedAmount;
      totalSupply += mintedAmount;
      Transfer(0, this, mintedAmount);
      Transfer(this, target, mintedAmount);
  }

  function freezeAccount(address target, bool freeze) onlyOwner {
      frozenAccount[target] = freeze;
      FrozenFunds(target, freeze);
  }

  function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
      sellPrice = newSellPrice;
      buyPrice = newBuyPrice;
  }

  function buy() payable {
      uint amount = msg.value / buyPrice;                // calculates the amount
      if (balanceOf[this] < amount) revert();               // checks if it has enough to sell
      balanceOf[msg.sender] += amount;                   // adds the amount to buyer's balance
      balanceOf[this] -= amount;                         // subtracts amount from seller's balance
      Transfer(this, msg.sender, amount);                // execute an event reflecting the change
  }

  function sell(uint256 amount) {
      if (balanceOf[msg.sender] < amount ) revert();        // checks if the sender has enough to sell
      balanceOf[this] += amount;                         // adds the amount to owner's balance
      balanceOf[msg.sender] -= amount;                   // subtracts the amount from seller's balance

      if (!msg.sender.send(amount * sellPrice)) {        // sends ether to the seller. It's important
          revert();                                         // to do this last to avoid recursion attacks
      } else {
          Transfer(msg.sender, this, amount);            // executes an event reflecting on the change
    }               
  }

}
1
  • BinGoBinBIn, thank you for your help, very much appreciated! Aug 4 '17 at 4:44
0

/* This unnamed function is called whenever someone tries to send ether to it */ function () { throw; // Prevents accidental sending of ether }

Add payable keyword in case you forgot

function () public payable { throw; // Prevents accidental sending of ether }

You find the advantages of using revert, assert and require over throw.(in terms of better security, refunding the gas price and revoking the state changes)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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