Ethereum: help understanding how contract ABI maps to transaction method/functions

Understanding Contract ABI Maps: A Guide to Transaction Methods and Functions

The Ethereum Virtual Machine (EVM) uses a standardized Binary Interoperability Interface (ABI) to define the interface of smart contracts. The ABI mapping is used to translate the binary representation of a contract’s bytecode and the actual functions that can be called within that contract.

In this article, we will examine how the “abi” object maps transaction methods and functions in Ethereum.

What is an ABI Map?

An ABI (Application Binary Interface) mapping is a data structure that represents the bytecode interface of a smart contract. It provides information about the functions that can be called within the contract, including their name, signature, and parameters.

The “abi” object in Ethereum is used to store the mappings. It is typically stored in the “abi.json” or “abi.txt” file, depending on the structure of the project. The ABI map contains the following information:

• Function names: The contract name followed by “_function”.

• Signature: A string specifying the function signature, including the return type and parameter types.

• Parameters: An array of strings specifying the parameter names.

How ​​does the “abi” object relate to operation methods?

When you call a function in a smart contract, the EVM translates that call into bytecode instructions. These instructions are stored in the “tx” (transaction) field of the “body” field of the “Operation” structure.

The ABI map provides the mapping between operation methods and functions. Here’s an example of how this works:

Let’s say we have a contract called “MyContract” that contains two functions: “func1” and “func2”. The contract object “abi” might look like this:

{
"constant": true,
"inputs": [],
"name": "func1",
"outputs": [],
"payable": false,
"stateMutability": "view",
"type": "function"
}

The function “func1” is called without input, does not return a value, and can be executed in the review state.

When we call the function “myContract.func1()” during an Ethereum transaction, the EVM translates this call into bytecode instructions corresponding to the object “abi”. For example:

{
"input": [],
"name": "func1",
"outputs": [],
"payable": false,
"stateMutability": "image",
"type": "function"
}

This instruction is stored in the “body” field of the transaction.

How ​​does ABI work with transaction methods?

To convert a function signature from an ABI binding to bytecode instructions, we need to do the following:

• Create an abstract syntax tree (AST) of the function signature.

• Compile the AST into bytecode instructions according to the contract’s bytecode format.

Here is an example of a Solidity implementation:

pragma strength ^0.8.0;
contract MyContract {
function func1() public pure virtual {
//...
}
function func2() public pure override {
//...
}
}

In this example, the functions “func1” and “func2” are defined as pure virtual. The “abi” object associates these functions with their names in the contract name, followed by “_function”.

When we call the function “myContract.func1()” or “myContract.func2()” during an Ethereum transaction, the EVM translates this call into bytecode instructions that match the ABI mapping.

Conclusion

In summary, the ABI map plays a crucial role in translating the bytecode of a smart contract into instructions that can be used by the Ethereum Virtual Machine (EVM). By understanding the structure and usage of the ABI map, we can better understand the complexities of creating and deploying smart contracts on the Ethereum blockchain.