solidity – How One Contract Sends Ether to Another Contract with More Than 2300 Gas

contract-developmentcontract-invocationgassolidity

I want one contract to collect a certain amount of finney before sending it to another contract, but I can't simply send in with C2.send(thisMuch).

function() {
    Dividend m = Dividend(dividendAddr);
    if (this.balance >= 70 finney) {
        uint sendProfit = this.balance;
    }
    m.Enter.send(sendProfit);
}

This is what I have so far, but I'm completely lost when it comes to sending finney from one contract to the next. How can I do that?

I have made two contracts on how I think it should work.
Contract one sends it to contract two.

contract one {

    address public deployer;
    address public targetAddress;


    modifier execute {
        if (msg.sender == deployer) {
            _
        }
    }


    function one(address _targetAddress) {
        deployer = msg.sender;
        targetAddress = _targetAddress;
    }


    function forward() {
        two m = two(targetAddress);
        m.pay();
        targetAddress.send(this.balance);
    }


    function() {
        forward();
    }


    function sendBack() execute {
        deployer.send(this.balance);
    }


}

Contract two sends it back to me.

contract two {

    address public deployer;

    function two() {
        deployer = msg.sender;
    }

    function pay() {
        deployer.send(this.balance);
    }

    function() {
        pay();
    }

}

Is this how it should work?

Best Answer

In order to send Ether to another contract while specifying the amount of gas, use the call function.

targetAddress.call.gas(200000).value(this.balance)(); will call the fallback function.

targetAddress.call.gas(200000).value(this.balance)(bytes4(sha3("pay()"))); will call the pay function.

Related Solutions

[Ethereum] fallback function is accepting more than 2300 gas

The fallback function is just like any other function: it gets as much gas as you pass to it.

What's different about the fallback function is that it's the one invoked when someone does a simple ether transfer, e.g. msg.sender.transfer(amount) in a smart contract, or a transfer from an exchange, etc. In those cases, very little gas is sent along, so if you want those cases to succeed, you should be careful about what you put in the fallback function.

I think there are other reasons to avoid the fallback function, notably around helping to prevent mistakes. See https://programtheblockchain.com/posts/2017/12/16/be-careful-when-using-the-solidity-fallback-function/.

Solidity: How to Send Ether to Another Contract’s Payable Function

The following won't succeed because the target contract doesn't define a payable fallback function:

TokenContractAddress.call.value(this.balance)();

Your other attempt is correct, assuming TokenContractAddress is a variable of type RobustDividendToken that points to the deployed RobustDividendToken contract:

TokenContractAddress.deposit.value(this.balance)();

If this is failing, please provide the full code that you're using and describe how you're deploying each contract and how TokenContractAddress gets its value.

Here's a test contract I made that is able to successfully call RobustDividendToken's deposit function:

contract Test {
    RobustDividendToken token;

    function Test(RobustDividendToken _token) public {
        token = _token;
    }

    function deposit() public payable {
        token.deposit.value(msg.value)();
    }
}

I deployed RobustDividendToken via Remix, then copied its address and deployed Test passing that address as a constructor parameter. (Be sure to pass the address as a quoted string.) Then I set the value field in Remix to a non-zero value and called deposit on Test. The transaction succeeded.

Best Answer

Related Solutions

[Ethereum] fallback function is accepting more than 2300 gas

Solidity: How to Send Ether to Another Contract’s Payable Function

Related Topic