[Ethereum] way to return data from a fallback function

contract-developmentdesign-patternssolidity

I'm trying to write a contract that contains a fallback function which would pass-through the call to another destination contract. This would allow for future upgrades/bug-fixes to the destination contract by updating the destination contract address in the contract which contains the pass-through fallback function.

Caller calling Do() -> Pass-Through function () -> Destination implements Do()

The problem is the fallback function can't return anything. Worse, if the caller to a contract with a fallback function is expecting a return value, they will receive what I believe is msg.data instead of the expected value.

Is there a way to return data from a fallback function (assembly okay) ?
Is the current behavior dangerous (e.g. corrupting the caller's stack)?

Here's the example code:

pragma solidity ^0.4.10;

contract Real
{
    function Do() public constant returns (uint256) { return 12345; }
}

contract Blank
{
    function () public { }
}

// Client contract address: 0x7C2F875a9D5Ba712A6cdF35E537651ea89779802
contract Client
{
    function Run() public constant returns (uint256 result1, uint256 result2)
    {
        Real real = Real(0xd64dE830995C7407b09CF96EC59f76701D4DBcF9); // This is the address of Real
        result1 = real.Do();

        Real blank = Real(0x068c8D804Fab87B3d2cF3f02914eF2bE6b199436); // This is the address of Blank
        result2 = blank.Do();
    }
}

// result1 = 12345
// result2 = 0xDDFAE52900000000000000000000000000000000000000000000000000000000
// bytes4(sha3("Do()")) = 0xDDFAE529. This is why I think result2 is msg.data

Best Answer

As outlined here by chriseth (who created Solidity):

Fallback functions cannot have return values.

It does look like your result2 value is the msg.data value. That said, you have not outlined how you are calling the client function - it is possible that returning msg.data is a fallback of the library/tooling that you are using.

Update

Since 0.4.17 you can use pragma experimental ABIEncoderV2 to return structs. Of course, until the experimental keyword is removed, it's not safe to use it in production apps.

solidity nameReg – Understanding nameReg.call(“register”, “MyName”) Between Contracts

From the link in the question, the important part about nameReg.call("register", "MyName") is (bold mine):

to interface with contracts that do not adhere to the ABI, the function call is provided which takes an arbitrary number of arguments of any type. These arguments are padded to 32 bytes and concatenated.

See the note here:

Note: the ABI is an abstraction that is not part of the core Ethereum protocol. Anyone can define their own ABI for their contracts, and any callers of such contracts would have to comply with that ABI to get meaningful results. However, it is simpler for all developers to use Solidity, Serpent, and web3.js which all comply with the ABI above.

nameReg.call("register", "MyName") will not invoke register on a nameReg contract compiled by Solidity. The reason is that Solidity does not use "register" to lookup "functions" (it uses the first 4 bytes as the method id. For example EVM pseudocode that Solidity produces, see this). Here's code for a quick test:

contract NameReg {
    bytes32 public nn;
    bytes public calldata;

    function register(bytes32 name) {
      nn = name;    
    }

    function() {
        calldata = msg.data;
    }

    function doesNotCallRegister() {
        this.call("register", "MyName");
    }
 }

With anameReg contract compiled by Solidity, nameReg.call("register", "MyName") will invoke the fallback function where msg.data will be "register", "MyName" padded to 32 bytes and concatenated: 0x72656769737465720000000000000000000000000000000000000000000000004d794e616d650000000000000000000000000000000000000000000000000000.

Best Answer

Related Solutions

Solidity – How to Return Struct When Function is Called

Update

solidity nameReg – Understanding nameReg.call(“register”, “MyName”) Between Contracts

Related Topic