Solidity CALL – Difference Between Direct Call and Creating Contract Object

contract-developmentsolidity

What's the difference between these two forms of calling methods on external contracts?

contract A {
    function foo() {
    }
}

contract B {

  function createFoo (address _contractAddress){
    Contract A = A(_contractAddress);
    A.foo();
  }

  function callFoo (address _contractAddress) {
    address newAddress = _contractAddress;
    newAddress.call(bytes4(sha3("foo()")));
  }
}

createFoo and callFoo seem to do the same thing. How are they different?

Best Answer

There's a huge difference between them

function createFoo (address _contractAddress){
    Contract A = A(_contractAddress);
    A.foo();
}

If foo() fails the call to createFoo() will also fail and it will propagate reversing any change you have made.

Another difference is you can retrieve the value returned by foo(). If the function returned an address you can assign to a variable.

address who = A.foo();

In the second case if foo() fails, call will return false. But it will not reverse changes you have made, you have to explicitely call revert().

function callFoo (address _contractAddress) {
    address newAddress = _contractAddress;
    newAddress.call(bytes4(sha3("foo()")));
}

And you do not have access to the value returned by foo(), call only return true if it executed successfully or false if it has failed.

Related Solutions

[Ethereum] the difference between an internal/external and public/private function in solidity

The paragraph specifically mentions that only function types are by default internal, and contract functions are by default public, even though I agree the wording is a little bit confusing. It says nowhere that they are at the same time both public and internal.

I think that there is some confusion to what a function type is. The same way you specify the type for a 256 int variable with the keyword uint256, you can also specify the type of a variable that will hold a function. The only difference is that this type declaration is a little more complex since functions are more complex and it looks like this:

function (param types) {internal|external} [pure|constant|view|payable] [returns (return types)] varName;

You can then assign to the variable varName a function that has the same type that you defined. This is only possible inside another function.

As a very simple example:

contract Example{
    function(uint256) returns (uint256) varName;

    function simpleFunction(uint256 parameter) returns (uint256){
        return parameter;
    }

    function test(){
        varName = simpleFunction;
    }
}

Where varName is the variable of function type, while simpleFunction and test are normal contract functions

Just so you have a simple definition for all those access classifiers:

public - all can access
external - Cannot be accessed internally, only externally
internal - only this contract and contracts deriving from it can access
private - can be accessed only from this contract

As you can notice private is a subset of internal and external is a subset of public.

Solidity – Understanding the Difference Between Gas Price and Gas Limit

Smart Contracts are written in solidity (a programming language). In smart contracts there is a price of executing each line of code. suppose you wrote 1000 lines of code that code ran and you used 1500 lines (because of loops and conditions) then the gas price will be 1500 whereas gas limit is a limit after which contract will stop executing.

We use gas limit so that if anyhow our contract goes in infinite then it will stop after gas limit reached so that it wont cost us too many ethers.

Best Answer

Related Solutions

[Ethereum] the difference between an internal/external and public/private function in solidity

Solidity – Understanding the Difference Between Gas Price and Gas Limit

Related Topic