Configuration

How to configure ABIType in userland or as a library author.

Overview

ABIType's types are customizable using declaration merging. Just install abitype (make sure versions match) and extend the Register interface either directly in your code or in a d.ts file (e.g. abi.d.ts):

ts
declare module 'abitype' {
  export interface Register {
    BigIntType: bigint & { foo: 'bar' }
  }
}
 
import { ResolvedRegister } from 'abitype'
type Result = ResolvedRegister['BigIntType']
       type Result = bigint & {
    foo: 'bar';
}Try

ts
declare module 'abitype' {
  export interface Register {
    BigIntType: bigint & { foo: 'bar' }
  }
}
 
import { ResolvedRegister } from 'abitype'
type Result = ResolvedRegister['BigIntType']
       type Result = bigint & {
    foo: 'bar';
}Try

Extending Config from third-party packages

If you are using ABIType via another package (e.g. viem), you can customize the ABIType's types by targeting the package's abitype module:

declare module 'viem/node_modules/abitype' {
  export interface Register {
    BigIntType: MyCustomBigIntType
  }
}

declare module 'viem/node_modules/abitype' {
  export interface Register {
    BigIntType: MyCustomBigIntType
  }
}

Options

ABIType tries to strike a balance between type exhaustiveness and speed with sensible defaults. In some cases, you might want to tune your configuration (e.g. use a custom bigint type). To do this, the following configuration options are available:

WARNING

When configuring ArrayMaxDepth, FixedArrayMinLength, and FixedArrayMaxLength, there are trade-offs. For example, choosing a non-false value for ArrayMaxDepth and increasing the range between FixedArrayMinLength and FixedArrayMaxLength will make your types more exhaustive, but will also slow down the compiler for type checking, autocomplete, etc.

`AddressType`

TypeScript type to use for address values.

Type any
Default `0x${string}`

ts
declare module 'abitype' {
  export interface Register {
    AddressType: `0x${string}`
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    AddressType: `0x${string}`
  }
}Try

`ArrayMaxDepth`

Maximum depth for nested array types (e.g. string[][]). When false, there is no maximum array depth.

Type number | false
Default false

ts
declare module 'abitype' {
  export interface Register {
    ArrayMaxDepth: false
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    ArrayMaxDepth: false
  }
}Try

`BigIntType`

TypeScript type to use for int<M> and uint<M> values, where M > 48.

Type any
Default bigint

ts
declare module 'abitype' {
  export interface Register {
    BigIntType: bigint
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    BigIntType: bigint
  }
}Try

`BytesType`

TypeScript type to use for bytes<M> values.

Type { inputs: any; outputs: any }
Default { inputs: `0x${string}` | Uint8Array; outputs: `0x${string}` }

ts
declare module 'abitype' {
  export interface Register {
    BytesType: {
      inputs: `0x${string}` | Uint8Array
      outputs: `0x${string}`
    }
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    BytesType: {
      inputs: `0x${string}` | Uint8Array
      outputs: `0x${string}`
    }
  }
}Try

`FixedArrayMinLength`

Lower bound for fixed-length arrays.

Type number
Default 1

ts
declare module 'abitype' {
  export interface Register {
    FixedArrayMinLength: 1
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    FixedArrayMinLength: 1
  }
}Try

`FixedArrayMaxLength`

Upper bound for fixed-length arrays.

Type number
Default 99

ts
declare module 'abitype' {
  export interface Register {
    FixedArrayMinLength: 99
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    FixedArrayMinLength: 99
  }
}Try

`IntType`

TypeScript type to use for int<M> and uint<M> values, where M <= 48.

Type any
Default number

ts
declare module 'abitype' {
  export interface Register {
    IntType: number
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    IntType: number
  }
}Try

`StrictAbiType`

When set, validates AbiParameter's type against AbiType.

Type boolean
Default false

ts
declare module 'abitype' {
  export interface Register {
    StrictAbiType: false
  }
}Try

ts
declare module 'abitype' {
  export interface Register {
    StrictAbiType: false
  }
}Try

WARNING

You probably only want to set this to true if parsed types are returning as unknown and you want to figure out why. This will slow down type checking significantly.

Configuration ​

Overview ​

Options ​

AddressType ​

ArrayMaxDepth ​

BigIntType ​

BytesType ​

FixedArrayMinLength ​

FixedArrayMaxLength ​

IntType ​

StrictAbiType ​