JSON String ABI (Solidity Output JSON)

The JSON ABI Format is the format that is output from the Solidity compiler.
A JSON serialized object is always a string, which represents an Array of Objects, where each Object has various properties describing the Fragment of the ABI.
The deserialized JSON string (which is a normal JavaScript Object) may also be passed into any function which accepts a JSON String ABI.

Human-Readable ABI

The ABI is described by using an array of strings, where each string is the Solidity signature of the constructor, function, event or error.
When parsing a fragment, all inferred properties will be injected (e.g. a payable method will have its constant property set to false).
Tuples can be specified by using the tuple(...) syntax or with bare (additional) parenthesis, (...).
const ABI = [
// Constructor
"constructor(address ens)",
// Constant functions (pure or view)
"function balanceOf(address owner) view returns (uint)",
// State-mutating functions (payable or non-payable)
"function mint(uint amount) payable",
"function transfer(address to, uint amount) returns (bool)",
// Events
"event Transfer(address indexed from, address indexed to, uint amount)",
// Errors
"error InsufficientFunds(address from, uint balance)",

Output Formats

Each Fragment and ParamType may be output using its format method.

hethers.utils.FormatTypes.full ⇒ string

This is a full human-readable string, including all parameter names, any optional modifiers (e.g. indexed, public, etc) and white-space to aid in human readability.

hethers.utils.FormatTypes.minimal ⇒ string

This is similar to full, except with no unnecessary whitespace or parameter names. This is useful for storing a minimal string which can still fully reconstruct the original Fragment using Fragment from.

hethers.utils.FormatTypes.json ⇒ string

This returns a JavaScript Object which is safe to call JSON.stringify on to create a JSON string.

hethers.utils.FormatTypes.sighash ⇒ string

This is a minimal output format, which is used by Solidity when computing a signature hash or an event topic hash.
The sighash format is insufficient to re-create the original Fragment, since it discards modifiers such as indexed, anonymous, stateMutability, etc.
It is only useful for computing the selector for a Fragment, and cannot be used to format an Interface.


An ABI is a collection of Fragments, where each fragment specifies:


fragment.name ⇒ string

This is the name of the Event or Function. This will be null for a ConstructorFragment.

fragment.type ⇒ string

This is a string which indicates the type of the Fragment. This will be one of:
  • constructor
  • event
  • function

fragment.inputs ⇒ Array<ParamType>

This is an array of each ParamType for the input parameters to the Constructor, Event of Function.


fragment.format( [ format = sighash ] ) ⇒ string

Creates a string representation of the Fragment using the available output formats.

hethers.utils.Fragment.from( objectOrString ) ⇒ Fragment

Creates a new Fragment sub-class from any compatible objectOrString.

hethers.utils.Fragment.isFragment( object ) ⇒ boolean

Returns true if object is a Fragment.

ConstructorFragment (inherits Fragment)


fragment.gas ⇒ BigNumber

This is the gas limit that should be used during deployment. It may be null.

fragment.payable ⇒ boolean

This is whether the constructor may receive ether during deployment as an endowment (i.e. msg.value != 0).

fragment.stateMutability ⇒ string

This is the state mutability of the constructor. It can be any of:
  • nonpayable
  • payable


hethers.utls.ConstructorFragment.from( objectOrString ) ⇒ ConstructorFragment

Creates a new ConstructorFragment from any compatible objectOrString.

hethers.utils.ConstructorFragment.isConstructorFragment( object ) ⇒ boolean

Returns true if object is a ConstructorFragment.

ErrorFragment (inherits Fragment)


hethers.utils.ErroFragment.from( objectOrString ) ⇒ ErrorFragment

Creates a new ErrorFragment from any compatible objectOrString.

hethers.utils.ErrorFragment.isErrorFragment( object ) ⇒ boolean

Returns true if object is an ErrorFragment.

EventFragment (inherits Fragment)


fragment.anonymous ⇒ boolean

This is whether the event is anonymous. An anonymous Event does not inject its topic hash as topic0 when creating a log.


hethers.utils.EventFragment.from( objectOrString ) ⇒ EventFragment

Creates a new EventFragment from any compatible objectOrString.

hethers.utils.EventFragment.isEventFragment( object ) ⇒ boolean

Returns true if object is an EventFragment.

FunctionFragment (inherits ConstructorFragment)


fragment.constant ⇒ boolean

This is whether the function is constant (i.e. does not change state). This is true if the state mutability is pure or view.

fragment.stateMutability ⇒ string

This is the state mutability of the constructor. It can be any of:
  • nonpayable
  • payable
  • pure
  • view

fragment.outputs ⇒ Array<ParamType>

A list of the Function output parameters.


hethers.utils.FunctionFragment.from( objectOrString ) ⇒ FunctionFragment

Creates a new FunctionFragment from any compatible objectOrString.

hethers.utils.FunctionFragment.isFunctionFragment( object ) ⇒ boolean

Returns true if object is a FunctionFragment.


The following examples will represent the Solidity parameter:
string foobar


paramType.name ⇒ string

The local parameter name. This may be null for unnamed parameters. For example, the parameter definition string foobar would be foobar.

paramType.type ⇒ string

The full type of the parameter, including tuple and array symbols. This may be null for unnamed parameters. For the above example, this would be foobar.

paramType.baseType ⇒ string

The base type of the parameter. For primitive types (e.g. address, uint256, etc) this is equal to type. For arrays, it will be the string array and for a tuple, it will be the string tuple.

paramType.indexed ⇒ boolean

Whether the parameter has been marked as indexed. This only applies to parameters which are part of an EventFragment.

paramType.arrayChildren ⇒ ParamType

The type of children of the array. This is null for any parameter which is not an array.

paramType.arrayLength ⇒ number

The length of the array, or -1 for dynamic-length arrays. This is null for parameters which are not arrays.

paramType.components ⇒ Array<ParamType>

The components of a tuple. This is null for non-tuple parameters.


paramType.format( [ outputType = sighash ] )

Creates a string representation of the Fragment using the available output formats.

hethers.utils.ParamType.from( objectOrString ) ⇒ ParamType

Creates a new ParamType from any compatible objectOrString.

hethers.utils.ParamType.isParamType( object ) ⇒ boolean

Returns true if object is a ParamType.