Hethers
  • Documentation
  • Getting Started
  • Application Programming Interface
    • Providers
      • Provider
        • Accounts Methods
        • Logs Methods
        • Network Status Methods
        • Transactions Methods
        • Event Emitter Methods
        • Base Provider
        • HederaProvider
      • Types
    • Contract Interaction
      • Contract
      • ContractFactory
      • Example: ERC-20 Contract
    • Utilities
      • Accounts
      • Addresses
      • Application Binary Interface
        • AbiCoder
        • ABI Formats
        • Fragments
        • Interface
      • BigNumber
      • Byte Manipulation
      • Constants
      • Display Logic and Input
      • Encoding Utilities
      • FixedNumber
      • Hashing Algorithms
      • HD Wallet
      • Logging
      • Property Utilities
      • Signing Key
      • Strings
      • Transactions
      • Web Utilities
      • Wordlists
    • Signers
  • Contributing
  • Other Resources
Powered by GitBook
On this page
  • Formats
  • JSON String ABI (Solidity Output JSON)
  • Human-Readable ABI
  • Output Formats
  • Fragment
  • ConstructorFragment (inherits Fragment)
  • ErrorFragment (inherits Fragment)
  • EventFragment (inherits Fragment)
  • FunctionFragment (inherits ConstructorFragment)
  • ParamType
  1. Application Programming Interface
  2. Utilities
  3. Application Binary Interface

Fragments

PreviousABI FormatsNextInterface

Last updated 3 years ago

Formats

JSON String ABI (Solidity Output JSON)

The JSON ABI Format is the format that is .

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

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

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.

Fragment

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

Properties

fragment.name ⇒ string

fragment.type ⇒ string

  • constructor

  • event

  • function

Methods

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

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

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

Returns true if object is a Fragment.

Properties

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

Methods

Creates a new ConstructorFragment from any compatible objectOrString.

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

Returns true if object is a ConstructorFragment.

Methods

Creates a new ErrorFragment from any compatible objectOrString.

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

Returns true if object is an ErrorFragment.

Properties

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.

Methods

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.

Properties

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.

Methods

Creates a new FunctionFragment from any compatible objectOrString.

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

Returns true if object is a FunctionFragment.

ParamType

The following examples will represent the Solidity parameter:

string foobar

Properties

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

paramType.indexed ⇒ boolean

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.

Methods

paramType.format( [ outputType = sighash ] )

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.

Each and may be output using its format method.

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 .

An

An

A

A

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

This is a string which indicates the type of the . This will be one of:

fragment.inputs ⇒ Array<>

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

Creates a string representation of the Fragment using the available .

hethers.utils.Fragment.from( objectOrString ) ⇒

ConstructorFragment (inherits )

fragment.gas ⇒

hethers.utls.ConstructorFragment.from( objectOrString ) ⇒

ErrorFragment (inherits )

hethers.utils.ErroFragment.from( objectOrString ) ⇒

EventFragment (inherits )

FunctionFragment (inherits )

hethers.utils.FunctionFragment.from( objectOrString ) ⇒

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

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

Creates a string representation of the Fragment using the available .

output from the Solidity compiler
BigNumber
Fragment
ParamType
Fragment from
Error
Event
Function
Constructor
ConstructorFragment
Fragment
ParamType
ParamType
output formats
Fragment
Fragment
ConstructorFragment
Fragment
ErrorFragment
Fragment
ConstructorFragment
FunctionFragment
type
EventFragment
output formats