Solidity – How to Use address.call{}() in Solidity Smart Contracts

abiaddressessolidity

I have seen here and several other places that the correct way to send ether from a contract to an address is to call the .call{}() method.

Then here, I have seen the method being used with arguments, like so:

addr.call{value: msg.value, gas: 5000}(
    abi.encodeWithSignature("foo(string,uint256)", "call foo", 123)
);

I understand the arguments in the curly braces. value: is the eth you want to send and gas: is the amount of gas you are willing to pay for the transaction to be mined (correct me if I am wrong).

What I do not understand are the arguments in brackets.

What is the abi object inside the contract and what does it do? Is it the same as the one you get when you compile the contract?
What does the abi.encodeWithSignature() method do?
How many arguments can the brackets take and what do they mean? And do you have to provide arguments to it or can you leave it empty?

Best Answer

After doing some research, I finally have the answers to the questions.

1. What is the abi object inside the contract and what does it do? Is it the same as the one you get when you compile the contract?

According to the Solidity docs:

The Contract Application Binary Interface (ABI) is the standard way to interact with contracts in the Ethereum ecosystem, both from outside the blockchain and for contract-to-contract interaction. Data is encoded according to its type, as described in this specification. The encoding is not self describing and thus requires a schema in order to decode.

So the abi object that contains the encodeWithSignature() method is the standard way to interact with contracts in the Ethereum ecosystem.

2. What does the abi.encodeWithSignature() method do?

This method takes either an empty sting or a function signature as its first argument. The function signature is usually a function in the called contract, although when it is not, there are ways Solidity deals with that. When it is a function in the called contract, that function is called when the abi.encodeWithSignature() method is called. So in the code example in the question, the called contract has a function: function foo(string var1, uint256 var2){} that is called every time the abi.encodeWithSignature("foo(string,uint256)", "call foo", 123) method is called in the caller contract. The other two arguments in the abi.encodeWithSignature() are arguments passed to the foo() function when it is being called.

3. How many arguments can the brackets take and what do they mean? And do you have to provide arguments to it or can you leave it empty?

The brackets in the call method, i.e.:

addr.call{value: msg.value, gas: 5000}(/** I am talking about this bracket*/);

requires a single bytes argument. So if you do not want to pass the abi.encodeWithSignature() method, you should pass an empty string or the compiler will throw an error.

Related Solutions

Solidity Contract Development – How to Call and Send Value

Here's an approach that's simpler and checked by the compiler:

contract contractA {
    function blah(int x, int y) payable {}
}

contract contractB {
    function invokeContractA() { 
        contractA a = contractA(0x1234567891234567891234567891234567891234);
        uint ValueToSend = 1234;
        a.blah{value: ValueToSend}(2, 3);
    }  
}

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 Contract Development – How to Call and Send Value

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

Related Topic