107
The ABI, Application Binary Interface, is basically how you call functions in a contract and get data back.
An ABI
determines such details as how functions are called and in which
binary format information should be passed from one program component
to the next...
An Ethereum smart contract is bytecode deployed on the Ethereum blockchain. There could be ...
90
ABI stands for application binary interface.
In general, an ABI is the interface between two program modules, one of which is often at the level of machine code. The interface is the de facto method for encoding/decoding data into/out of the machine code.
In Ethereum, it's basically how you can encode Solidity contract calls for the EVM and, backwards, ...
67
Summary
Your original contract code would not work correctly until I added a constant to the function definition to indicate that this function does not modify the blockchain.
I had to use the method signature of double(int256) instead of double(int) to get the eth_call JSON-RPC to work.
The Details
Run Your geth Instance
You can use the Testnet ...
31
The JSON is called an ABI.
You do need the source code, as you have, and one way to get the ABI is to paste it in Remix IDE, compile it, and then click the 'ABI' button to copy the ABI into your clipboard.
29
Thank you K.Fichter for the help, I just want to fully clarify the answer for anyone else who may run into this issue.
Let's say you want to get the balance of a token at an Ethereum Address. Using Web3 you would do the following:
var tokenContract = web3.eth.contract(contractABI).at(contractAddress)
var decimal = tokenContract.decimals()
var balance = ...
22
Mainly due to optimizations carried out when the source code is compiled it's not feasible to get the source code from the bytecode/opcode itself. Refer this question.
Compilation back to the original source code is impossible because all
variable names, type names and even function names are removed. It
might be technically possible to arrive at some ...
20
Here is an example from What is an ABI and why is it needed to interact with contracts?
contract Foo {
function baz(uint32 x, bool y) returns (bool r) { r = x > 32 || y; }
}
If we wanted to call baz() with the parameters 69 and true, we would pass 68 bytes in total, which can be broken down into:
0xcdcd77c0: the Method ID. This is derived as the first ...
19
EDIT: Solidity's author, chriseth, recommends to avoid using Solidity's call
https://github.com/ethereum/solidity/issues/2884#issuecomment-329169020
The thing is: a.call() is an ancient beast that should not be used. I would recommend using inline assembly for such tasks, since it provides the same security guarantees but does not do any invisible magic.
...
19
It is quite complicated to get this correct, but here's some information on how to work it out.
I'm using a simple contract as an example:
pragma solidity ^0.4.2;
contract Test {
uint256 public v1;
string public v2;
function Test(uint256 _v1, string _v2) {
v1 = _v1;
v2 = _v2;
}
}
Here is my deployment to a --dev blockchain ...
19
It means that now you need to change your code to:
uint256 _unixTimestamp;
uint256 _timeExpired;
bytes32 output = keccak256(
abi.encodePacked(msg.sender, _unixTimestamp, _timeExpired)
);
17
Functions (aka Methods) are specified by the ABI, and have a Method ID, which is the first 4 bytes of the sha3 (Keccak-256) of the method's signature.
Here's an example of invoking someFunction on contract:
contract.call(bytes4(sha3("someFunction()")))
Here is a tested function with passing a methodId as a parameter:
contract C1 {
uint public _n; // ...
16
Contract Defintion: Formal definition in high-level code (e.g. solidity).
Compiled Contract: The contract converted to byte-code to run on the Ethereum Virtual Machine (EVM), adhering to the specification. Note the function names and input parameters are hashed during compilation. Therefore, for another account to call a function, it must first be given the ...
16
The page "Verify Contract" ask for "Constructor Arguments ABI-encoded".
In your case the constructor has no parameters, so you can leave such field empty.
In the general case when your constrctor has parameters you can proceed as follow:
You can use ethereumjs-abi to encode/decode the parameters for transaction calls.
Let's suppose your constructor is ...
15
Seems like the contract address should be enough.
You're right, it would be better if the ABI could be obtained by just looking at the contract.
So why do contract writers need to also provide the ABI, in addition to the contract address?
One reason is that the function Method IDs in a contract are computed using a hash function. So it is infeasible for ...
15
I know the question is old, but I had some problems with this so I will share what helped me.
To import the ABI from a JSON file, you can use the following code (assuming you already have your web3 Object):
var fs = require('fs');
var jsonFile = "pathToYourJSONFile/project.json";
var parsed= JSON.parse(fs.readFileSync(jsonFile));
var abi = parsed.abi;
var ...
13
You don't need the source code, just the ABI. The ABI is produced when the code is compiled, but can be, and usually is, distributed separately.
The ABI is essentially just a list of the function names in a contract and what types of arguments they take. You don't even need the whole ABI, just the parts that you want to interact with. For example, to ...
13
a) you know the source code of smart-contract
programmatically: see the link to gist from Ivan's answer
manually: with Remix
b) you don't know the source code but smart-contract was verified in one of the explorers
Then, use block explorer search to get ABI of smart-contract. For example, you can read the verified source code of smart-contracts in BlockScout,...
12
think of "ABI" as an "API" at a low level.
Think of it as the compiled version of an API (or as an API on the low level). As you know the contracts are stored as bytecodes in a binary format into the blockchain under a specific address. No one understands binary, so the ABI defines the structures and methods that you will use to interact with that binary ...
12
when you run
$ truffle compile
truffle creates and saves a json file per contract in /yourProjectPath/build/contracts. In this json file you'll find the abi, the bytecode, the topics (if you have any event in your smart contract), the function definitions etc (you get the point I guess, I encourage you to spend some time understanding that file - just to ...
11
It's the job of the compiler to produce the correct EVM bytecode so that as you say the MethodID "piece of data will end up jumping to the appropriate address for that function in the bytecode of the contract".
Since the MethodID is only 4 bytes, hash collisions (between 2 different functions) are possible. The Solidity compiler gives an error in that case ...
11
Here are instructions to find contract ABI using online remix solidity compiler.
In the "Compile" tab, click on the "Details" button.
On the modal, go down to the "Interface" section. Click the copy button.
11
You can use simple online tool to get abi-encoded constructor parameters https://abi.hashex.org. Just paste in abi and enter parameter values. Abi-encoded parameters would be automatically calculated.
Then just copy and paste result into etherscan.io constructor parameters input.
Here is an example of using this tool
10
If the question is about abi params, you can take a look at these two web3.js files:
https://github.com/ethereum/web3.js/blob/master/test/coder.encodeParam.js
https://github.com/ethereum/web3.js/blob/master/test/coder.decodeParam.js
Although these functions are not a part of public web3.js interface. Mostly because they need a proper refactor.
There is ...
10
Here is how you get the abi by using your local solc compiler:
solc filename.sol --abi
You also need the bin code to deploy the contract, which you can get as follows:
solc filename.sol --bin
If you want a solc combined output (e.g. for parity), where bin is part of the abi json string, use this:
solc filename.sol --combined-json abi,bin
9
I cannot find the contract details to get the json interface anymore.
If you select the compile tab, there you will find a button called details. When the details is clicked, a pop-up window will appear. You can find the ABI at
under the metadata section, and there output you will see the ABI
(json interface).
OR
under the interface section
Click green ...
9
you can also do
import { AbiItem } from 'web3-utils'
import Abi from './abi.json'
new web3.eth.Contract(Abi as AbiItem[], contractAddress)
8
The EVM is always 256 bits big-endian. From the Yellow Paper, Appendix H: "When interpreting 256-bit binary values as integers, the representation is big-endian."
RLP is different from the Contract ABI.
From above RLP wiki, encodings "must be represented in big endian binary form with no leading zeroes."
There are no (other) explicit rules about padding ...
8
It will be easier to understand if we make these two definitions (note: this might not be fully correct, but is enough for the following explanation):
the EVM is the machine executing the instructions, which has inputs and outputs
the state manager as the one putting data in/out of the blockchain.
Many of the interactions with the blockchain (and state ...
8
To add on to Nick Johnson's answer, function types in recent versions of solidity allow you to describe function pointers now:
http://solidity.readthedocs.io/en/latest/types.html#function-types
Function types are the types of functions. Variables of function type can be assigned from functions and function parameters of function type can be used to pass ...
8
the specific function should be executed in EVM with related input
data rather than the whole contract code
The EVM will execute the contract code. The EVM just executes the bytecode and does not know anything about functions. Solidity, Serpent and web3.js implement the same Application Binary Interface, which is how functions and data are encoded: What ...
Only top voted, non community-wiki answers of a minimum length are eligible