[Ethereum] How to you call a payable function in another contract with arguments and send funds

contract-designcontract-developmentcontract-invocationsolidity

I have a contract named Call:

contract Call {
  ...
  function () payable {
    // TODO: Call the call function in the main contract
    // and forward all funds (msg.value) sent to this contract
    // and passing in the following data: msg.sender
  }
}

Here is the Main contract:

contract Main {
  ...
  function call(address senderAddress) public {
    // Make the code in here run when someone sends ethers to the Call contract
  }
}

So, I want to have it so that whenever someone sends ethers the Call contract, it forwards all the ethers to the Main contract while running the call function in the Main contract with the necessary arguments.

Can this be done?

Best Answer

Update per @Girish comment, in Solidity 0.6+ the syntax has changed to: address.function{value:msg.value}(arg1, arg2, arg3)

Original

The general syntax for calling a function in another contract with arguments and sending funds is: address.func.value(amount)(arg1, arg2, arg3)

func needs to have the payable modifier (for Solidity 0.4+).

Completing @Edmund's answer with these important details, here's an example that compiles:

pragma solidity ^0.4.0;

contract PayMain {
  Main main;
  function PayMain(address _m) {
     main = Main(_m);
  }
  function () payable {
    // Call the handlePayment function in the main contract
    // and forward all funds (msg.value) sent to this contract
    // and passing in the following data: msg.sender
    main.handlePayment.value(msg.value)(msg.sender);
  }
}

contract Main {
  function handlePayment(address senderAddress) payable public {
      // senderAddress in this example could be removed since msg.sender can be used directly
  }
}

Also emphasizing what he wrote:

Be aware that this will only work if the people sending the funds send enough gas to cover the call to Main and whatever you do in it.

Related Solutions

[Ethereum] Passing ether with call to Solidity function

You pass in an object with a property named value and the amount of wei.

Using your example, like:

contracts['CrowdFunder'].contract.contribute({value: web3.toWei(12, 'ether')});

Note, in your example res will be a transaction hash.

[Ethereum] Calling function of external contract and passing bytecode

You should consider the following also.

pragma solidity ^0.4.17;

contract DeployedContract {
    uint public result = 0;

    function add(uint input) {
        result = result + input;
    }
}

contract Proxy {    
    address deployed_contract = 0x123;

    function directCall() public {
        DeployedContract(deployed_contract).add(123);
    }
}

Just assume the contract from the address.

Also, uint is an alias of uint256

Bytes32 is an array of bytes of length 32. Bytes first 32 bytes is a uint256 which contains the length of the bytes

call4 can be fixed with:

function call4() {
    deployed_contract.call("0x1003e2d20000000000000000000000000000000000000000000000000000000000000005");
    // does not compile: TypeError: Invalid rational number
}

As it takes bytes and bytes need to be enclosed in quotes, assuming that the data being passed is correct.

call5 needs to be passed an array with remix or simply just do the following:

function call5(bytes data) {
    // using call data from above (see call3), when using bytes32 as type, data is truncated to 0x1003e2d200000000000000000000000000000000000000000000000000000000
    deployed_contract.call(data); 
    // fails, since bytes32 truncates data  
}

And again, call it with

"0x1003e2d20000000000000000000000000000000000000000000000000000000000000005"

Best Answer

Original

Related Solutions

[Ethereum] Passing ether with call to Solidity function

[Ethereum] Calling function of external contract and passing bytecode

Related Topic