Call, DelegateCall & Callcode

This is advanced topic. See http://solidity.readthedocs.io/en/v0.4.21/types.html#address

call, delegatecall & callcode

• are members of Address
• all breaks type safety of solidity and should only be used as last resort
• unknown malicious contract being called are given control and may call back into your contract and be prepared for changes to your state variables
• arguments
  • arbitrary number of arguments of any type
  • 1st argument
    • function signature
    • 4 bytes, bytes4(keccak256("functionName(uint256)"))
      • tried "uint256" (see below code) and works
      • tried "string" but does not work (although return call success state not changed)
        • return "success" may means the function signature is correct - so the function is located
        • but state did not change - maybe the storage layout is not consistent
      • see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI for function signature
  • following arguments
    • padded to 32 bytes & concatenated
  • returns:
    • boolean, terminated or exception
    • not possible to get actual return data (not knowing encoding and size)

call

• call the target address
• in target code, "this" is the target address
• context storage is the target address
• can use call.gas(10000).value(1 ether)(...) to adjust gas and value
  • * not possible on overloaded functions

delegatecall

• delegate execution to code in target address
  • only code is used, others (storage, balance etc.) are from current address
• in execution, "this" is the calling address
• context storage is the calling address
• purpose: to use library code
• user has to ensure storage layout in both contracts is suitable for delegatecall
• can use delegatecall.gas(1000)

callcode (deprecated)

• the only provided one before Homestead
• not provide access to original msg.sender & msg.value

pragma solidity ^0.4.17;

contract Markable {

    uint256 mark;

function getMark() view public returns (uint256) {

return mark;

}

function setMark(uint256 _mark) public {

mark = _mark;

}

}

contract Markable2 {

    string mark2;

function getMark2() view public returns (string) {

return mark2;

}

function setMark2(string _mark) public {

mark2 = _mark;

}

}

contract SomeContract is Markable, Markable2 {

event callMeMaybeEvent(address _from);

function callMeMaybe(uint256 _mark) payable public {

mark = _mark;

emit callMeMaybeEvent(this);

}

}

contract ThatCallsSomeContract is Markable, Markable2 {

    event callResult(string desc, bool succ);

function callTheOtherContract(address _contractAddress, uint256 mark1, uint256 mark2, string mark3) public {

bool s1 = _contractAddress.call(bytes4(keccak256("callMeMaybe(uint256)")), mark1);

emit callResult("first",s1);

bool s2 = _contractAddress.delegatecall(bytes4(keccak256("callMeMaybe(uint256)")), mark2);

emit callResult("second", s2);

SomeLib.calledSomeLibFun(mark3);

}

}

library SomeLib {

event calledSomeLib(address _from);

function calledSomeLibFun(string _mark) public {

Markable2(this).setMark2(_mark);

emit calledSomeLib(this);

}

}