Sensible contract safety | Ethereum Basis Weblog

Solidity was launched in October 2014 when neither the Ethereum community nor the digital machine had any real-world testing, fuel prices at the moment had been even drastically totally different than they’re now. Moreover, a number of the early design choices had been taken from the Serpent. Over the previous few months, examples and patterns that had been initially thought of greatest practices have been uncovered to actuality, and a few of them have really turned out to be anti-patterns. That is why we just lately up to date a number of the Documentation of energyhowever since most individuals most likely do not comply with the movement of github commits to that repository, I would like to focus on a number of the findings right here.

I can’t speak about minor issues right here, examine them in documentation.

Sending ether

Sending Ether ought to be one of many best issues to do in Solidity, but it surely turns on the market are some subtleties that most individuals do not understand.

It will be important that in the perfect case, the recipient of ether initiates the cost. Adopted by a BAD instance of an public sale contract:

// THIS IS A NEGATIVE EXAMPLE! DO NOT USE!
contract public sale {
  handle highestBidder;
  uint highestBid;
  perform bid() {
    if (msg.worth < highestBid) throw;
    if (highestBidder != 0)
      highestBidder.ship(highestBid); // refund earlier bidder
    highestBidder = msg.sender;
    highestBid = msg.worth;
  }
}

Due to the utmost stack depth of 1024, a brand new bidder can all the time improve the stack measurement to 1023 after which name supply() which can trigger ship (highest supply) a silent failure name (ie the earlier bidder won’t get a refund) however the brand new bidder will nonetheless be the very best bidder. One strategy to examine if ship was profitable in checking its return worth:

/// THIS IS STILL A NEGATIVE EXAMPLE! DO NOT USE!
if (highestBidder != 0)
  if (!highestBidder.ship(highestBid))
    throw;
The 
throw
    command causes the present callback to be returned.  This can be a dangerous thought, as a result of the receiver, eg by implementing a substitute perform as 
perform() { throw; }
    she will be able to all the time power the switch of Ether to fail and this could lead to nobody with the ability to overrun her.

The one strategy to stop each conditions is to transform the ship sample to a withdraw sample, giving the recipient management over the switch:

/// THIS IS STILL A NEGATIVE EXAMPLE! DO NOT USE!
contract public sale {
  handle highestBidder;
  uint highestBid;
  mapping(handle => uint) refunds;
  perform bid() {
    if (msg.worth < highestBid) throw;
    if (highestBidder != 0)
      refunds[highestBidder] += highestBid;
    highestBidder = msg.sender;
    highestBid = msg.worth;
  }
  perform withdrawRefund() {
    if (msg.sender.ship(refunds[msg.sender]))
      refunds[msg.sender] = 0;
  }
}
 

Why does “damaging instance” nonetheless seem above the contract? Due to the fuel mechanics, the contract is definitely effective, however nonetheless not instance. The reason being that it’s inconceivable to stop code execution on the recipient as a part of the ship. Which means whereas the ship perform continues to be in progress, the recipient can name again the draw. At that time the refund quantity continues to be the identical and due to this fact they might get the quantity once more and so forth. On this explicit instance it does not work, as a result of the receiver solely will get a fuel stipend (2100 fuel) and it is inconceivable to make one other ship with this quantity of fuel. Nonetheless, the next code is susceptible to this assault: msg.sender.name.worth(return[msg.sender])().

With all this in thoughts, the next code ought to be effective (in fact, it is nonetheless not an entire instance of an public sale contract):

contract public sale {
  handle highestBidder;
  uint highestBid;
  mapping(handle => uint) refunds;
  perform bid() {
    if (msg.worth < highestBid) throw;
    if (highestBidder != 0)
      refunds[highestBidder] += highestBid;
    highestBidder = msg.sender;
    highestBid = msg.worth;
  }
  perform withdrawRefund() {
    uint refund = refunds[msg.sender];
    refunds[msg.sender] = 0;
    if (!msg.sender.ship(refund))
     refunds[msg.sender] = refund;
  }
}

Notice that we did not use throw on a failed ship as a result of we are able to roll again any state adjustments manually, and never utilizing throw has a lot much less unwanted side effects.

Utilizing Throw

A throw assertion is usually very handy for returning any adjustments made to state as a part of a name (or the whole transaction, relying on how the perform is known as). Nonetheless, you have to be conscious that this additionally consumes all of the fuel and is due to this fact costly and can doubtlessly cease calls to the present perform. Because of this I’d advocate utilizing it solely within the following conditions:

1. Return Ether switch to present perform

If the perform just isn’t meant to obtain Ether or just isn’t within the present state or with present arguments, it’s best to use throw to reject the Ether. Utilizing throw is the one strategy to reliably ship Ether as a result of fuel and stack depth points: the receiver might have a bug within the fallback perform that takes an excessive amount of fuel and due to this fact can’t obtain Ether, or the perform might have been maliciously known as by a context with an excessive amount of stack depth (even perhaps previous to the calling perform).

Notice that by accident sending Ether to a contract just isn’t all the time a UX fault: you’ll be able to by no means predict in what order or at what time transactions are added to the block. If the contract is written to simply accept solely the primary transaction, the Ether included within the different transactions have to be rejected.

2. Returning the results of known as features

In the event you name features on different contracts, you’ll be able to by no means know the way they’re applied. Which means the results of those calls are additionally unknown and due to this fact the one strategy to undo these results is through the use of throw. After all, it’s best to all the time write your contract to not name these features within the first place if you understand you will must return the results, however there are some use circumstances the place you solely know this after the actual fact.

Loops and Block Gasoline Restrict

There’s a restrict to how a lot fuel could be consumed in a single block. This restrict is versatile, however it’s fairly troublesome to extend it. Which means each single perform in your contract ought to keep under a certain quantity of gas in all (affordable) conditions. The next is a BAD instance of a voting contract:

/// THIS IS STILL A NEGATIVE EXAMPLE! DO NOT USE!
contract Voting {
  mapping(handle => uint) voteWeight;
  handle[] yesVotes;
  uint requiredWeight;
  handle beneficiary;
  uint quantity;
  perform voteYes() { yesVotes.push(msg.sender); }
  perform tallyVotes() {
    uint yesVotes;
    for (uint i = 0; i < yesVotes.size; ++i)
      yesVotes += voteWeight[yesVotes[i]];
    if (yesVotes > requiredWeight)
      beneficiary.ship(quantity);
  }
}

The contract really has a number of issues, however the one I would like to focus on right here is the loop drawback: suppose vote weights are transferable and divisible like tokens (consider DAO tokens for instance). This implies you’ll be able to create any variety of clones of your self. Creating such clones will improve the loop size within the tallyVotes perform till extra fuel is required than is out there inside a single block.

This is applicable to something that makes use of loops, additionally the place loops aren’t explicitly seen within the contract, for instance when copying arrays or arrays inside storage. Once more, it is effective to have loops of arbitrary size if the size of the loop is managed by the caller, for instance for those who’re iterating over a string handed as a perform argument. However by no means create a scenario the place the size of the loop is managed by a celebration that may not be the one one to endure from its failure.

As a facet observe, this was one of many the reason why we now have the idea of blocked accounts inside the DAO contract: the burden of the vote is counted on the level the place the vote is forged, to stop the truth that the loop will get caught and if the vote the burden just isn’t mounted till the top voting interval, you could possibly forged a second vote by simply transferring your tokens after which voting once more.

Receiving ether / backup perform

If you would like your contract to obtain Ether by way of a daily ship() name, it’s worthwhile to make its fallback perform low-cost. It may solely use 2300, a fuel that doesn’t enable storage writes or perform calls despatched with Ether. Principally the one factor it’s best to do contained in the fallback perform is to log the occasion in order that exterior processes can react to that truth. After all, any contract perform can obtain ether and isn’t sure by that fuel restrict. Features really should reject the Ether despatched to them if they do not wish to obtain it, however we’re serious about doubtlessly reversing this conduct in a future launch.