ABI

The web3.eth.abi functions let you encode and decode parameters to ABI (Application Binary Interface) for function calls to the EVM (Ethereum Virtual Machine).

For using Web3 ABI functions, first install Web3 package using npm i web3 or yarn add web3. After that, Web3 ABI functions will be available.

import { Web3 } from 'web3';

const web3 = new Web3();
const encoded = web3.eth.abi.encodeFunctionSignature({
    name: 'myMethod',
    type: 'function',
    inputs: [{
        type: 'uint256',
        name: 'myNumber'
    },{
        type: 'string',
        name: 'myString'
    }]
});

For using individual package install web3-eth-abi package using npm i web3-eth-abi or yarn add web3-eth-abi and only import required functions. This is more efficient approach for building lightweight applications.

import { encodeFunctionSignature } from 'web3-eth-abi';

const encoded = encodeFunctionSignature({
    name: 'myMethod',
    type: 'function',
    inputs: [{
        type: 'uint256',
        name: 'myNumber'
    },{
        type: 'string',
        name: 'myString'
    }]
});

Functions

decodeFunctionCall

▸ decodeFunctionCall(functionsAbi, data, methodSignatureProvided?): DecodedParams & { __method__: string }

Decodes a function call data using its JSON interface object. The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json

Parameters

Name	Type	Default value	Description
`functionsAbi`	`AbiConstructorFragment` \| `AbiFunctionFragment`	`undefined`	The `JSON interface` object of the function.
`data`	`string`	`undefined`	The data to decode
`methodSignatureProvided`	`boolean`	`true`	(Optional) if `false` do not remove the first 4 bytes that would rather contain the function signature.

Returns

DecodedParams & { __method__: string }

The data decoded according to the passed ABI.

Example

const data =
	'0xa413686200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000548656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010416e6f74686572204772656574696e6700000000000000000000000000000000';
const params = decodeFunctionCall(
	{
		inputs: [
			{ internalType: 'string', name: '_greeting', type: 'string' },
			{ internalType: 'string', name: '_second_greeting', type: 'string' },
		],
		name: 'setGreeting',
		outputs: [
			{ internalType: 'bool', name: '', type: 'bool' },
			{ internalType: 'string', name: '', type: 'string' },
		],
		stateMutability: 'nonpayable',
		type: 'function',
	},
	data,
);

console.log(params);
> {
> 	'0': 'Hello',
> 	'1': 'Another Greeting',
> 	__length__: 2,
> 	__method__: 'setGreeting(string,string)',
> 	_greeting: 'Hello',
> 	_second_greeting: 'Another Greeting',
> }

decodeFunctionReturn

▸ decodeFunctionReturn(functionsAbi, returnValues?): unknown

Decodes a function call data using its JSON interface object. The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json

Parameters

Name	Type	Description
`functionsAbi`	`AbiFunctionFragment`	The `JSON interface` object of the function.
`returnValues?`	`string`	The data (the function-returned-values) to decoded

Returns

unknown

The ABI encoded function call, which, means the function signature and the parameters passed.
The function-returned-values decoded according to the passed ABI. If there are multiple values, it returns them as an object as the example below. But if it is a single value, it returns it only for simplicity.

Example

// decode a multi-value data of a method
const data =
	'0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000548656c6c6f000000000000000000000000000000000000000000000000000000';
const decodedResult = decodeFunctionReturn(
	{
		inputs: [
			{ internalType: 'string', name: '_greeting', type: 'string' }
		],
		name: 'setGreeting',
		outputs: [
			{ internalType: 'string', name: '', type: 'string' },
			{ internalType: 'bool', name: '', type: 'bool' },
		],
		stateMutability: 'nonpayable',
		type: 'function',
	},
	data,
);

console.log(decodedResult);
> { '0': 'Hello', '1': true, __length__: 2 }

// decode a single-value data of a method
const data =
	'0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000548656c6c6f000000000000000000000000000000000000000000000000000000';
const decodedResult = decodeFunctionReturn(
	{
		inputs: [
			{ internalType: 'string', name: '_greeting', type: 'string' }
		],
		name: 'setGreeting',
		outputs: [{ internalType: 'string', name: '', type: 'string' }],
		stateMutability: 'nonpayable',
		type: 'function',
	},
	data,
);

console.log(decodedResult);
> 'Hello'

decodeLog

▸ decodeLog<ReturnType>(inputs, data, topics): ReturnType

Decodes ABI-encoded log data and indexed topic data.

Type parameters

Name	Type
`ReturnType`	extends `DecodedParams`

Parameters

Name	Type	Description
`inputs`	readonly `AbiParameter`[] \| `AbiParameter`[]	A AbiParameter input array. See the Solidity documentation for a list of types.
`data`	`string`	The ABI byte code in the `data` field of a log.
`topics`	`string` \| `string`[]	An array with the index parameter topics of the log, without the topic[0] if its a non-anonymous event, otherwise with topic[0]

Returns

ReturnType

The result object containing the decoded parameters.

Example

let res = web3.eth.abi.decodeLog(
   [
     {
       type: "string",
       name: "myString",
     },
     {
       type: "uint256",
       name: "myNumber",
       indexed: true,
     },
     {
       type: "uint8",
       name: "mySmallNumber",
       indexed: true,
     },
   ],
   "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000748656c6c6f252100000000000000000000000000000000000000000000000000",
   [
     "0x000000000000000000000000000000000000000000000000000000000000f310",
     "0x0000000000000000000000000000000000000000000000000000000000000010",
   ]
 );
> {
 '0': 'Hello%!',
 '1': 62224n,
 '2': 16n,
 __length__: 3,
 myString: 'Hello%!',
 myNumber: 62224n,
 mySmallNumber: 16n
}

decodeParameter

▸ decodeParameter(abi, bytes): unknown

Decodes an ABI encoded parameter to its JavaScript type.

Parameters

Name	Type	Description
`abi`	`AbiInput`	The type of the parameter. See the Solidity documentation for a list of types.
`bytes`	`string`	The ABI byte code to decode

Returns

unknown

The decoded parameter

Example

  const res = web3.eth.abi.decodeParameter(
   "uint256",
   "0x0000000000000000000000000000000000000000000000000000000000000010"
 );
 console.log(res);
> 16n

 const res = web3.eth.abi.decodeParameter(
   "string",
   "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
 );

 console.log(res);
 > Hello!%!

 const res = web3.eth.abi.decodeParameter(
   {
     ParentStruct: {
       propertyOne: "uint256",
       propertyTwo: "uint256",
       childStruct: {
         propertyOne: "uint256",
         propertyTwo: "uint256",
       },
     },
   },
   "0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e"
 );

 console.log(res);
  {
 '0': 42n,
 '1': 56n,
 '2': {
   '0': 45n,
   '1': 78n,
   __length__: 2,
   propertyOne: 45n,
   propertyTwo: 78n
 },
 __length__: 3,
 propertyOne: 42n,
 propertyTwo: 56n,
 childStruct: {
   '0': 45n,
   '1': 78n,
   __length__: 2,
   propertyOne: 45n,
   propertyTwo: 78n
 }
}

decodeParameters

▸ decodeParameters(abi, bytes): Object

Decodes ABI encoded parameters to its JavaScript types.

Parameters

Name	Type	Description
`abi`	`AbiInput`[] \| readonly `AbiInput`[]	An array of AbiInput. See the Solidity documentation for a list of types.
`bytes`	`string`	The ABI byte code to decode

Returns

Object

The result object containing the decoded parameters.

Name	Type
`__length__`	`number`

Example

let res = web3.eth.abi.decodeParameters(
   ["string", "uint256"],
   "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
 );
 console.log(res);
 > { '0': 'Hello!%!', '1': 234n, __length__: 2 }

let res = web3.eth.abi.decodeParameters(
   [
     {
       type: "string",
       name: "myString",
     },
     {
       type: "uint256",
       name: "myNumber",
     },
   ],
   "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
 );
console.log(res);
 > {
 '0': 'Hello!%!',
 '1': 234n,
 __length__: 2,
 myString: 'Hello!%!',
 myNumber: 234n
}

const res = web3.eth.abi.decodeParameters(
   [
     "uint8[]",
     {
       ParentStruct: {
         propertyOne: "uint256",
         propertyTwo: "uint256",
         childStruct: {
           propertyOne: "uint256",
           propertyTwo: "uint256",
         },
       },
     },
   ],
   "0x00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000018"
 );
 console.log(res);
 >
 '0': [ 42n, 24n ],
 '1': {
   '0': 42n,
   '1': 56n,
   '2': {
     '0': 45n,
     '1': 78n,
     __length__: 2,
     propertyOne: 45n,
     propertyTwo: 78n
   },
   __length__: 3,
   propertyOne: 42n,
   propertyTwo: 56n,
   childStruct: {
     '0': 45n,
     '1': 78n,
     __length__: 2,
     propertyOne: 45n,
     propertyTwo: 78n
   }
 },
 __length__: 2,
 ParentStruct: {
   '0': 42n,
   '1': 56n,
   '2': {
     '0': 45n,
     '1': 78n,
     __length__: 2,
     propertyOne: 45n,
     propertyTwo: 78n
   },
   __length__: 3,
   propertyOne: 42n,
   propertyTwo: 56n,
   childStruct: {
     '0': 45n,
     '1': 78n,
     __length__: 2,
     propertyOne: 45n,
     propertyTwo: 78n
   }
 }
}

decodeParametersWith

▸ decodeParametersWith(abis, bytes, loose): Object

Should be used to decode list of params

Parameters

Name	Type
`abis`	`AbiInput`[] \| readonly `AbiInput`[]
`bytes`	`string`
`loose`	`boolean`

Returns

Object

Name	Type
`__length__`	`number`

encodeErrorSignature

▸ encodeErrorSignature(functionName): string

Encodes the error name to its ABI signature, which are the sha3 hash of the error name including input types.

Parameters

Name	Type
`functionName`	`string` \| `AbiErrorFragment`

Returns

string

encodeEventSignature

▸ encodeEventSignature(functionName): string

Encodes the event name to its ABI signature, which are the sha3 hash of the event name including input types.

Parameters

Name	Type	Description
`functionName`	`string` \| `AbiEventFragment`	The event name to encode, or the AbiEventFragment object of the event. If string, it has to be in the form of `eventName(param1Type,param2Type,...)`. eg: myEvent(uint256,bytes32).

Returns

string

The ABI signature of the event.

Example

const event = web3.eth.abi.encodeEventSignature({
  name: "myEvent",
  type: "event",
  inputs: [
    {
      type: "uint256",
      name: "myNumber",
    },
    {
      type: "bytes32",
      name: "myBytes",
    },
  ],
});
console.log(event);
> 0xf2eeb729e636a8cb783be044acf6b7b1e2c5863735b60d6daae84c366ee87d97

 const event = web3.eth.abi.encodeEventSignature({
  inputs: [
    {
      indexed: true,
      name: "from",
      type: "address",
    },
    {
      indexed: true,
      name: "to",
      type: "address",
    },
    {
      indexed: false,
      name: "value",
      type: "uint256",
    },
  ],
  name: "Transfer",
  type: "event",
});
console.log(event);
> 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef

encodeFunctionCall

▸ encodeFunctionCall(jsonInterface, params): string

Encodes a function call using its JSON interface object and given parameters. The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json

Parameters

Name	Type	Description
`jsonInterface`	`AbiFunctionFragment`	The `JSON interface` object of the function.
`params`	`unknown`[]	The parameters to encode

Returns

string

The ABI encoded function call, which, means the function signature and the parameters passed.

Example

const sig = web3.eth.abi.encodeFunctionCall(
  {
    name: "myMethod",
    type: "function",
    inputs: [
      {
        type: "uint256",
        name: "myNumber",
      },
      {
        type: "string",
        name: "myString",
      },
    ],
  },
  ["2345675643", "Hello!%"]
);
console.log(sig);
> 0x24ee0097000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000

const sig = web3.eth.abi.encodeFunctionCall(
  {
    inputs: [
      {
        name: "account",
        type: "address",
      },
    ],
    name: "balanceOf",
    outputs: [
      {
        name: "",
        type: "uint256",
      },
    ],
    stateMutability: "view",
    type: "function",
  },
  ["0x1234567890123456789012345678901234567890"]
);

console.log(sig);
> 0x70a082310000000000000000000000001234567890123456789012345678901234567890

encodeFunctionSignature

▸ encodeFunctionSignature(functionName): string

Encodes the function name to its ABI representation, which are the first 4 bytes of the sha3 of the function name including types. The JSON interface spec documentation https://docs.soliditylang.org/en/latest/abi-spec.html#json

Parameters

Name	Type	Description
`functionName`	`string` \| `AbiFunctionFragment`	The function name to encode or the `JSON interface` object of the function. If the passed parameter is a string, it has to be in the form of `functionName(param1Type,param2Type,...)`. eg: myFunction(uint256,uint32[],bytes10,bytes)

Returns

string

The ABI signature of the function.

Example

const signature = web3.eth.abi.encodeFunctionSignature({
  name: "myMethod",
  type: "function",
  inputs: [
    {
      type: "uint256",
      name: "myNumber",
    },
    {
      type: "string",
      name: "myString",
    },
  ],
});
console.log(signature);
> 0x24ee0097

const signature = web3.eth.abi.encodeFunctionSignature('myMethod(uint256,string)')
console.log(signature);
> 0x24ee0097

const signature = web3.eth.abi.encodeFunctionSignature('safeTransferFrom(address,address,uint256,bytes)');
console.log(signature);
> 0xb88d4fde

encodeParameter

▸ encodeParameter(abi, param): string

Encodes a parameter based on its type to its ABI representation.

Parameters

Name	Type	Description
`abi`	`AbiInput`	The type of the parameter. See the Solidity documentation for a list of types.
`param`	`unknown`	The actual parameter to encode.

Returns

string

The ABI encoded parameter

Example

 const res = web3.eth.abi.encodeParameter("uint256", "2345675643");
 console.log(res);
 0x000000000000000000000000000000000000000000000000000000008bd02b7b

 const res = web3.eth.abi.encodeParameter("uint", "2345675643");

 console.log(res);
 >0x000000000000000000000000000000000000000000000000000000008bd02b7b

   const res = web3.eth.abi.encodeParameter("bytes32", "0xdf3234");

 console.log(res);
 >0xdf32340000000000000000000000000000000000000000000000000000000000

  const res = web3.eth.abi.encodeParameter("bytes", "0xdf3234");

 console.log(res);
 > 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003df32340000000000000000000000000000000000000000000000000000000000

  const res = web3.eth.abi.encodeParameter("bytes32[]", ["0xdf3234", "0xfdfd"]);

 console.log(res);
 > 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002df32340000000000000000000000000000000000000000000000000000000000fdfd000000000000000000000000000000000000000000000000000000000000

 const res = web3.eth.abi.encodeParameter(
   {
     ParentStruct: {
       propertyOne: "uint256",
       propertyTwo: "uint256",
       childStruct: {
         propertyOne: "uint256",
         propertyTwo: "uint256",
       },
     },
   },
   {
     propertyOne: 42,
     propertyTwo: 56,
     childStruct: {
       propertyOne: 45,
       propertyTwo: 78,
     },
   }
 );

 console.log(res);
 > 0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e

encodeParameters

▸ encodeParameters(abi, params): string

Encodes a parameter based on its type to its ABI representation.

Parameters

Name	Type	Description
`abi`	readonly `AbiInput`[]	An array of AbiInput. See Solidity's documentation for more details.
`params`	`unknown`[]	The actual parameters to encode.

Returns

string

The ABI encoded parameters

Example

const res = web3.eth.abi.encodeParameters(
   ["uint256", "string"],
   ["2345675643", "Hello!%"]
 );

 console.log(res);
 > 0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000

getMessage

▸ getMessage(typedData, hash?): string

Get the EIP-191 encoded message to sign, from the typedData object. If hash is enabled, the message will be hashed with Keccak256.

Parameters

Name	Type
`typedData`	`Eip712TypedData`
`hash?`	`boolean`

Returns

string

inferTypesAndEncodeParameters

▸ inferTypesAndEncodeParameters(params): string

Infer a smart contract method parameter type and then encode this parameter.

Parameters

Name	Type	Description
`params`	`unknown`[]	The parameters to encode.

Returns

string

The ABI encoded parameters

Remarks

This method is useful when you don't know the type of the parameters you want to encode. It will infer the type of the parameters and then encode them. However, it is not recommended to use this method when you know the type of the parameters you want to encode. In this case, use the encodeParameters method instead. The type inference is not perfect and can lead to unexpected results. Especially when you want to encode an array, uint that is not uint256 or bytes....

Example

const res = web3.eth.abi.encodeParameters(
   ["2345675643", "Hello!%"]
 );

 console.log(res);
 > 0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000

Functions​

decodeFunctionCall​

Parameters​

Returns​

decodeFunctionReturn​

Parameters​

Returns​

decodeLog​

Type parameters​

Parameters​

Returns​

decodeParameter​

Parameters​

Returns​

decodeParameters​

Parameters​

Returns​

decodeParametersWith​

Parameters​

Returns​

encodeErrorSignature​

Parameters​

Returns​

encodeEventSignature​

Parameters​

Returns​

encodeFunctionCall​

Parameters​

Returns​

encodeFunctionSignature​

Parameters​

Returns​

encodeParameter​

Parameters​

Returns​

encodeParameters​

Parameters​

Returns​

getMessage​

Parameters​

Returns​

inferTypesAndEncodeParameters​

Parameters​

Returns​

Functions

decodeFunctionCall

Parameters

Returns

decodeFunctionReturn

Parameters

Returns

decodeLog

Type parameters

Parameters

Returns

decodeParameter

Parameters

Returns

decodeParameters

Parameters

Returns

decodeParametersWith

Parameters

Returns

encodeErrorSignature

Parameters

Returns

encodeEventSignature

Parameters

Returns

encodeFunctionCall

Parameters

Returns

encodeFunctionSignature

Parameters

Returns

encodeParameter

Parameters

Returns

encodeParameters

Parameters

Returns

getMessage

Parameters

Returns

inferTypesAndEncodeParameters

Parameters

Returns