[Ethereum] Are underscores `_` in modifiers code or are they just meant to look cool

modifierssolidity

I often see _ in modifiers

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

Does it execute any code or is it meant to make the code easier to read ?

Best Answer

Update Oct 12 2016

From Solidity version 0.4.0+, you now need to add a semicolon after _. See Solidity - Version 0.4.0:

Change _ to _; in modifiers.

The tests below only work in Solidity < v 0.4.0.

Summary

The code for the function being modified is inserted where the _ is placed in the modifier.
You can add more than one _s in the modifier code. And the code of the function being modified is inserted in each place where _ is located in the modifier. See modifier checkThree. This may be prevented by later versions of the solc compiler.
The modifiers gets called in the sequence they were defined (checkOne checkTwo checkThree) and at the end of the function, they are called in reverse. The modifiers seem to be applied like a stack. In this example anyway.

Details

From Solidity Features - Function Modifiers :

PT Modifiers can be used to easily change the behaviour of functions, for example to automatically check a condition prior to executing the function. They are inheritable properties of contracts and may be overridden by derived contracts.
contract owned {
  function owned() { owner = msg.sender; }
  address owner;

  // This contract only defines a modifier but does not use it - it will
  // be used in derived contracts.
  // The function body is inserted where the special symbol "_" in the
  // definition of a modifier appears.
  modifier onlyowner { if (msg.sender == owner) _ }
}

Here's an example from EtherScan.io - The DAO - Source Code.

The modifier onlyTokenholders restricts "modified" functions from be executed by non-tokenholders.

modifier onlyTokenholders {
    if (balanceOf(msg.sender) == 0) throw;
        _
}

Here is the vote(...) function with the onlyTokenHolders modifier:

function vote(
    uint _proposalID,
    bool _supportsProposal
) onlyTokenholders noEther returns (uint _voteID) {

    Proposal p = proposals[_proposalID];
    if (p.votedYes[msg.sender]
        || p.votedNo[msg.sender]
        || now >= p.votingDeadline) {

        throw;
    }

The code within the vote(...) function is only executed if the modifier check does not throw an error from the statement if (balanceOf(msg.sender) == 0) throw;. The _ represents the body of the vote(...) function.

From Learn X in Y minutes - Where X=Solidity, here is an example where the _ is not at the end of the modifier function:

// underscore can be included before end of body,
// but explicitly returning will skip, so use carefully
modifier checkValue(uint amount) {
    _
    if (msg.value > amount) {
        msg.sender.send(amount - msg.value);
    }
}

Let's take '_' for a test run

Here is some code to test _:

contract TestModifier {

    string[] public messages;
    uint256 testVariable;

    function numberOfMessages() constant returns (uint256) {
        return messages.length;
    }

    modifier checkOne {
        messages.push("checkOne - 1");
        if (testVariable == 123) 
            throw;
        _
        messages.push("checkOne - 2");
        if (testVariable == 123) 
            throw;
    }

    modifier checkTwo {
        messages.push("checkTwo - 1");
        if (testVariable == 123) 
            throw;
        _
        messages.push("checkTwo - 2");
        if (testVariable == 123) 
            throw;
    }

    modifier checkThree {
        messages.push("checkThree - 1");
        if (testVariable == 123) 
            throw;
        _
        messages.push("checkThree - 2");
        if (testVariable == 123) 
            throw;
        _
        messages.push("checkThree - 3");
        if (testVariable == 123) 
            throw;
    }

    function test() checkOne checkTwo checkThree returns (uint256) {
        messages.push("test - 1");
        testVariable = 345;
        messages.push("test - 2");
        return testVariable;
    }
}

Flattened the code

> var testModifierSource='contract TestModifier { string[] public messages; uint256 testVariable; function numberOfMessages() constant returns (uint256) { return messages.length; } modifier checkOne { messages.push("checkOne - 1"); if (testVariable == 123)  throw; _ messages.push("checkOne - 2"); if (testVariable == 123)  throw; } modifier checkTwo { messages.push("checkTwo - 1"); if (testVariable == 123)  throw; _ messages.push("checkTwo - 2"); if (testVariable == 123)  throw; } modifier checkThree { messages.push("checkThree - 1"); if (testVariable == 123)  throw; _ messages.push("checkThree - 2"); if (testVariable == 123)  throw; _ messages.push("checkThree - 3"); if (testVariable == 123)  throw; } function test() checkOne checkTwo checkThree returns (uint256) { messages.push("test - 1"); testVariable = 345; messages.push("test - 2"); return testVariable; }}'
undefined

Inserted contract into the blockchain:

> var testModifierCompiled = web3.eth.compile.solidity(testModifierSource);
undefined
> var testModifierContract = web3.eth.contract(testModifierCompiled.TestModifier.info.abiDefinition);
var testModifier = testModifierContract.new({
    from:web3.eth.accounts[0], 
    data: testModifierCompiled.TestModifier.code, gas: 1000000}, 
    function(e, contract) {
      if (!e) {
        if (!contract.address) {
          console.log("Contract transaction send: TransactionHash: " + contract.transactionHash + " waiting to be mined...");
        } else {
          console.log("Contract mined! Address: " + contract.address);
          console.log(contract);
        }
    }
})
...
Contract mined! Address: 0xd2ca2d34da6e50d28407f78ded3a07962b56181c
[object Object]

Sent a transaction to call the test() function:

> testModifier.test(eth.accounts[0], {
  from:web3.eth.accounts[0], 
  data: testModifierCompiled.TestModifier.code,
  gas: 1000000
});

Checked the results:

> var i;
> for (i = 0; i < testModifier.numberOfMessages(); i++) {
    console.log(testModifier.messages(i));
}
checkOne - 1
checkTwo - 1
checkThree - 1
test - 1
test - 2

Taking Out The Return Statement In `test()`:

I removed the return statement so the source code for test is:

function test() checkOne checkTwo checkThree returns (uint256) {
    messages.push("test - 1");
    testVariable = 345;
    messages.push("test - 2");
    // return testVariable;
}

And re-ran the test to produce the following results:

var i;
undefined
> for (i = 0; i < testModifier.numberOfMessages(); i++) {
..     console.log(testModifier.messages(i));
.. }
checkOne - 1
checkTwo - 1
checkThree - 1
test - 1
test - 2
checkThree - 2
test - 1
test - 2
checkThree - 3
checkTwo - 2
checkOne - 2
undefined

Related Solutions

[Ethereum] How to Unit test modifiers in Solidity

Yes, there is, perhaps a better way to phrase this is how to test for throw conditions - or now, rather assert(), require(), and revert(). For example, in the case above, you want to make sure that when someone other than the owner calls a function, then the function throws and any state changes are rolled back to their original state. The best way to do this is with Solidity unit tests using Truffle. Unfortunately, when using JavaScript unit tests, when a throw condition is encountered, then the test "breaks" - with Solidity unit tests, you can test many throw conditions at the same time without stopping.

What you will want to use is a proxy contract to “to wrap the contract call to a raw call and return whether it succeeded or not.”. A proxy contract should look like the below:

contract ThrowProxy {
  address public target;
  bytes data;

  function ThrowProxy(address _target) {
    target = _target;
  }

  //prime the data using the fallback function.
  function() {
    data = msg.data;
  }

 function execute() returns (bool) {
    return target.call(data);
  }
}

In the creation of your throwProxy contract, your _target would be the address of the contract that you would like to test.

In your Solidity unit test, you would include a test like the below:

function testTheThrow() {
    MyContract mycontract = new MyContract(); 
    ThrowProxy throwproxy = new ThrowProxy(address(mycontract)); 
    MyContract(address(throwproxy)).functionThatShouldThrow();
    bool r = throwproxy.execute.gas(200000)(); 
    Assert.isFalse(r, "Should be false because is should throw!");
}

In the example above, we are using the fallback function from the throwProxy contract to compile the call data to execute the functionThatShouldThrow() by using the execute() function from the throwProxy to use the .call() method on your original target, MyContract. Recall that .call() return a Boolean as to whether execution is successful or not - it does not include any returns from the function. From here, saving the r as to the Boolean value as to whether the functionThatShouldThrow() is successful or not. From here, you can use the Assert.sol library to assert that r is in fact false because the function should have thrown.

[Ethereum] Solidity modifiers: good or bad

I often find I want a software client to be able to check but I also want a modifier for readability, so it often ends up like this:

modifier onlyIfAllowed() {
  require(isAllowed(args));
  _;
}

function isAllowed() public view returns(bool allowed) {
  allowed = ...
}

function safer() public onlyIfAllowed ...

Of course, it would also be fine to do that in-line.

function inline() public {
  require(isAllowed());
  // carry on

Ultimately, it is a matter of personal preference. I find it more readable to go like this:

function tricky() public onlyOwner onlyIfAllowed onlySomethingElse { ...

... so the actual purpose of the function doesn't get mixed up with repetitive steps. It's more DRY, in my opinion. Not everyone agrees. The Vyper team, for example, consider modifiers an anti-feature that obscures important logic that they feel should be in-line.

Hope it helps.