ABIType

https://github.com/wevm/abitype
Admin
ABIType provides strict TypeScript types and utilities for Ethereum ABIs and EIP-712 Typed Data,...
Tokens:21,932
Snippets:127
Trust Score:8
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Extract ABI function names with ABIType

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/getting-started.md

Example of using ABIType to extract function names from an ABI, specifying 'view' functions.

```typescript
import { ExtractAbiFunctionNames } from 'abitype'
import { erc20Abi } from 'abitype/abis'

type Result = ExtractAbiFunctionNames<typeof erc20Abi, 'view'>
//   ^?
```

--------------------------------

### Use `narrow` function with ABIs in JavaScript/TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/getting-started.md

Shows how to use the `narrow` function from ABIType to manage ABI types, especially useful in JavaScript.

```typescript
import { narrow } from 'abitype'
const erc20Abi = narrow([...])
```

--------------------------------

### Assert ABIs to constants in TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/getting-started.md

Demonstrates how to use `const` assertions with ABIs in TypeScript to ensure specific types.

```typescript
const erc20Abi = [...] as const
const erc20Abi = <const>[...]
```

--------------------------------

### Install Zod Peer Dependency for ABIType

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/zod.md

Installs the Zod peer dependency required for using ABIType's Zod schemas. This command should be run in your project's root directory.

```bash
pnpm add zod
```

```bash
bun add zod
```

```bash
npm i zod
```

```bash
yarn add zod
```

--------------------------------

### Installing ABIType via Package Managers

Source: https://github.com/wevm/abitype/blob/main/docs/pages/index.mdx

This section provides commands for installing the abitype package using various popular JavaScript package managers. It covers pnpm, bun, npm, and yarn, ensuring users can integrate the library into their projects regardless of their preferred tooling.

```bash
pnpm add abitype
```

```bash
bun add abitype
```

```bash
npm i abitype
```

```bash
yarn add abitype
```

--------------------------------

### Human-Readable Constructor Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet shows examples of human-readable constructor signatures in TypeScript. It demonstrates how to define constructors with optional parameters and mutability modifiers like 'payable'. This helps in defining contract initialization.

```typescript
'constructor()'
'constructor(address conduitController)'
'constructor(address conduitController) payable'
```

--------------------------------

### Human-Readable Event Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet illustrates the human-readable format for defining event signatures in TypeScript. It demonstrates how to specify the event name and its input parameters, including the 'indexed' modifier for parameters. These examples help in understanding event declaration.

```typescript
'event Mint()'
'event Transfer(bytes32 indexed node, address owner)'
```

--------------------------------

### Configure ABIType Bytes Type

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Demonstrates how to customize the TypeScript type for `bytes<M>` values in ABIType. The example sets `bytesType` to an object with `inputs` and `outputs` properties, both typed as `0x${string}`, reflecting a common use case for byte string representations.

```typescript
declare module 'abitype' {
  export interface Register {
    bytesType: {
      inputs: `0x${string}`
      outputs: `0x${string}`
    }
  }
}
```

--------------------------------

### Human-Readable Function Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet showcases various ways to define function signatures in a human-readable format using TypeScript. It covers the inclusion of function name, parameters, scope, mutability, and return types. These examples are useful for understanding the flexible syntax supported.

```typescript
'function mint()'
'function withdraw(uint wad)'
'function activate() public'
'function deposit() payable'
'function name() returns (string)'
'function tokenURI(uint256 tokenId) pure returns (string)'
```

--------------------------------

### Usage Example: Fetching and Parsing ABI with ABIType Zod

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/zod.md

Demonstrates how to fetch an ABI from Etherscan and parse it using the `Abi` schema from 'abitype/zod'. This involves making an HTTP request and then validating the response against the schema.

```typescript
import { Abi } from 'abitype/zod'

const result = await fetch(
  'https://api.etherscan.io/api?module=contract&action=getabi&address=0x…'
)
const abi = Abi.parse(result)
```

--------------------------------

### Configure ABIType Int Type

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Demonstrates how to configure the TypeScript type for `int<M>` and `uint<M>` values in ABIType where `M <= 48`. The example sets `intType` to `number`, which is the default, but can be modified to use other numeric types if necessary.

```typescript
declare module 'abitype' {
  export interface Register {
    intType: number
  }
}
```

--------------------------------

### Human-Readable Struct Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet displays examples of human-readable struct definitions in TypeScript. It covers both named and unnamed properties within a struct, demonstrating how to define complex data structures concisely. This is useful for custom data types.

```typescript
'struct AdditionalRecipient { uint256; address; }'
'struct AdditionalRecipient { uint256 amount; address recipient; }'
```

--------------------------------

### Configure ABIType BigInt Type

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Shows how to configure the TypeScript type used for `int<M>` and `uint<M>` values in ABIType where `M > 48`. The example sets `bigIntType` to the default `bigint`, but this can be changed to other types if needed.

```typescript
declare module 'abitype' {
  export interface Register {
    bigIntType: bigint
  }
}
```

--------------------------------

### Configure ABIType Fixed Array Min Length

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Illustrates how to set the lower bound for fixed-length arrays in ABIType. The example sets `FixedArrayMinLength` to `1`, indicating that fixed-length arrays must have at least one element. This can be adjusted based on specific project requirements.

```typescript
declare module 'abitype' {
  export interface Register {
    FixedArrayMinLength: 1
  }
}
```

--------------------------------

### Human-Readable Error Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet provides examples of human-readable error signatures in TypeScript. It shows how to declare custom error types with their names and optional input parameters. This format is concise for defining error conditions.

```typescript
'event CriteriaNotEnabledForItem()'
'event InvalidRestrictedOrder(bytes32 orderHash)'
```

--------------------------------

### Configure ABIType Address Type

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Illustrates how to set a custom TypeScript type for `address` values in ABIType. The example shows setting `addressType` to `` `0x${string}` ``, which is the default, but can be overridden to enforce specific address formats or types.

```typescript
declare module 'abitype' {
  export interface Register {
    addressType: `0x${string}`
  }
}
```

--------------------------------

### Configure ABIType Fixed Array Max Length

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Shows how to configure the upper bound for fixed-length arrays in ABIType. The example sets `FixedArrayMaxLength` to `99`, defining the maximum number of elements allowed in a fixed-length array. This parameter, along with `fixedArrayMinLength`, impacts type exhaustiveness and compiler performance.

```typescript
declare module 'abitype' {
  export interface Register {
    FixedArrayMaxLength: 99
  }
}
```

--------------------------------

### Human-Readable Fallback Signature Examples - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet illustrates human-readable fallback function signatures in TypeScript. It shows how to specify the scope (external) and mutability (payable) for fallback functions, which handle unaddressed calls.

```typescript
'fallback() external'
'fallback() external payable'
```

--------------------------------

### Type Extraction and Primitive Conversion in TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/index.mdx

This snippet demonstrates how to use ABIType to extract function input types from an ABI and convert them into primitive TypeScript types. It imports necessary utilities and an example ABI, then applies transformations to derive the primitive types for function inputs. This is useful for generating type-safe function signatures or validating input data.

```typescript
import { 
  AbiParametersToPrimitiveTypes, 
  ExtractAbiFunction 
} from 'abitype'
import { erc20Abi } from 'abitype/abis'

type TransferInputTypes = AbiParametersToPrimitiveTypes<
  ExtractAbiFunction<typeof erc20Abi, 'transfer'>['inputs']
>
```

--------------------------------

### Human-Readable Receive Signature Example - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet provides the human-readable signature for a receive function in TypeScript. It indicates that receive functions are external and payable, typically used for handling plain Ether transfers to a contract.

```typescript
'receive() external payable'
```

--------------------------------

### Extract Function Names and Types from ERC20 ABI (TypeScript)

Source: https://github.com/wevm/abitype/blob/main/README.md

This snippet demonstrates how to use ABIType to extract function names and input types from an ERC20 ABI. It utilizes `ExtractAbiFunctionNames` to get view function names and `AbiParametersToPrimitiveTypes` along with `ExtractAbiFunction` to infer the primitive TypeScript types for function input parameters. It requires importing necessary types from 'abitype' and the ERC20 ABI.

```typescript
import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction, ExtractAbiFunctionNames } from 'abitype'
import { erc20Abi } from 'abitype/abis'

type FunctionNames = ExtractAbiFunctionNames<typeof erc20Abi, 'view'>
//   ^? type FunctionNames = "symbol" | "name" | "allowance" | "balanceOf" | "decimals" | "totalSupply"

type TransferInputTypes = AbiParametersToPrimitiveTypes<
  // ^? type TransferInputTypes = readonly [`0x${string}`, bigint]
  ExtractAbiFunction<typeof erc20Abi, 'transfer'>['inputs']
>
```

--------------------------------

### Call `readContract` with ABI and Arguments

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/walkthrough.md

Demonstrates calling the `readContract` function with a predefined ABI and arguments for the 'balanceOf' function. The ABI includes multiple overloads for 'balanceOf'. Imports `abi` from a separate file.

```typescript
// @filename: abi.ts
export const abi = [
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'owner', type: 'address' }],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'collectionId', type: 'uint256' },
    ],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'tokenURI',
    type: 'function',
    stateMutability: 'pure',
    inputs: [{ name: 'id', type: 'uint256' }],
    outputs: [{ name: 'uri', type: 'string' }],
  },
  {
    name: 'safeTransferFrom',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'tokenId', type: 'uint256' },
    ],
    outputs: [],
  },
] as const
// @filename: readContract.ts
import { Abi } from 'abitype'

declare function readContract(config: {
  abi: Abi
  functionName: string
  args: readonly unknown[]
}): unknown
// ---cut---
import { abi } from './abi'

const res = readContract({
  abi,
  functionName: 'balanceOf',
  args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
})
```

--------------------------------

### Import Human-Readable ABIs from abitype/abis

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/abis.md

Imports human-readable versions of various Solidity ABI constants from the 'abitype/abis' entrypoint. These can be easier to understand and debug compared to their raw ABI counterparts.

```typescript
import {
  customSolidityErrorsHumanReadableAbi,
  ensHumanReadableAbi,
  ensRegistryWithFallbackHumanReadableAbi,
  erc20HumanReadableAbi,
  nestedTupleArrayHumanReadableAbi,
  nounsAuctionHouseHumanReadableAbi,
  seaportHumanReadableAbi,
  wagmiMintExampleHumanReadableAbi,
  wethHumanReadableAbi,
  writingEditionsFactoryHumanReadableAbi,
} from 'abitype/abis'
```

--------------------------------

### Import ABIs from abitype/abis

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/abis.md

Imports a collection of standard Solidity ABI constants from the 'abitype/abis' entrypoint. These are useful for testing smart contract interactions and for development purposes.

```typescript
import {
  customSolidityErrorsAbi,
  ensAbi,
  ensRegistryWithFallbackAbi,
  erc20Abi,
  nestedTupleArrayAbi,
  nounsAuctionHouseAbi,
  seaportAbi,
  wagmiMintExampleAbi,
  wethAbi,
  writingEditionsFactoryAbi,
  eip165Abi,
} from 'abitype/abis'
```

--------------------------------

### Configure ABIType with Third-Party Package

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Shows how to configure ABIType when it's being used indirectly through another package, like `viem`. It targets the `abitype` module within the third-party package's `node_modules` to apply custom type configurations, such as defining a `MyCustomBigIntType` for `bigIntType`.

```typescript
declare module 'viem/node_modules/abitype' {
  export interface Register {
    bigIntType: MyCustomBigIntType
  }
}
```

--------------------------------

### Format ABI: abitype vs ethers.js

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Compares formatting a JSON ABI into a human-readable ABI using abitype and ethers.js. abitype returns an inferred human-readable ABI, while ethers.js returns string arrays. Benchmarks indicate abitype offers substantial performance gains.

```typescript
import { formatAbi } from 'abitype'

const abi = formatAbi([
  {
    type: 'function',
    name: 'name',
    stateMutability: 'nonpayable',
    inputs: [
      {
        type: 'tuple',
        name: 'foo',
        components: [
          { type: 'string', name: 'name' },
          { type: 'uint256', name: 'age' },
        ],
      },
      { type: 'uint256', name: 'tokenId' },
    ],
    outputs: [],
  },
  {
    type: 'event',
    name: 'Foo',
    inputs: [{ type: 'address', name: 'bar', indexed: true }],
  },
])
abi
//^?
```

```typescript
import { Interface } from '@ethersproject/abi'

const iface = new Interface([
  {
    type: 'function',
    name: 'name',
    stateMutability: 'nonpayable',
    inputs: [
      {
        type: 'tuple',
        name: 'foo',
        components: [
          { type: 'string', name: 'name' },
          { type: 'uint256', name: 'age' },
        ],
      },
      { type: 'uint256', name: 'tokenId' },
    ],
    outputs: [],
  },
  {
    type: 'event',
    name: 'Foo',
    inputs: [{ type: 'address', name: 'bar', indexed: true }],
  },
])
const abi = iface.format('minimal')
//    ^?
```

```typescript
import { Interface } from 'ethers'

const iface = new Interface([
  {
    type: 'function',
    name: 'name',
    stateMutability: 'nonpayable',
    inputs: [
      {
        type: 'tuple',
        name: 'foo',
        components: [
          { type: 'string', name: 'name' },
          { type: 'uint256', name: 'age' },
        ],
      },
      { type: 'uint256', name: 'tokenId' },
    ],
    outputs: [],
  },
  {
    type: 'event',
    name: 'Foo',
    inputs: [{ type: 'address', name: 'bar', indexed: true }],
  },
])
const abi = iface.format(true)
//    ^?
```

--------------------------------

### Inferring Arguments for Contract Read Function (TypeScript)

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/walkthrough.md

Demonstrates how to infer the argument types for a read contract function using abitype's ExtractAbiFunction and AbiParametersToPrimitiveTypes. It handles potential function overloading by utilizing TypeScript's distributive types.

```typescript
// @filename: abi.ts
export const abi = [
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'owner', type: 'address' }],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'collectionId', type: 'uint256' },
    ],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'tokenURI',
    type: 'function',
    stateMutability: 'pure',
    inputs: [{ name: 'id', type: 'uint256' }],
    outputs: [{ name: 'uri', type: 'string' }],
  },
  {
    name: 'safeTransferFrom',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'tokenId', type: 'uint256' },
    ],
    outputs: [],
  },
] as const
// @filename: readContract.ts
// ---cut---
import {
  Abi,
  AbiParametersToPrimitiveTypes,
  ExtractAbiFunction,
  ExtractAbiFunctionNames,
} from 'abitype'
import { abi } from './abi'

declare function readContract<
  abi extends Abi,
  functionName extends ExtractAbiFunctionNames<abi, 'pure' | 'view'>
>(config: {
  abi: abi
  functionName: functionName | ExtractAbiFunctionNames<abi, 'pure' | 'view'>
  args: AbiParametersToPrimitiveTypes<
    ExtractAbiFunction<abi, functionName>['inputs'],
    'inputs'
  >
}): unknown

const res = readContract({
  abi,
  functionName: 'balanceOf',
  args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
  // ^?
})

```

--------------------------------

### Format Full ABI to Human-Readable Strings with Abitype

Source: https://context7.com/wevm/abitype/llms.txt

Formats a JSON ABI array into an array of human-readable ABI item strings. Useful for displaying ABI information in a user-friendly format. Dependencies: 'abitype'.

```typescript
import { formatAbi } from 'abitype'
import { erc20Abi } from 'abitype/abis'

const humanReadable = formatAbi(erc20Abi)
//   ^? const humanReadable: readonly [
//        "function name() view returns (string)",
//        "function symbol() view returns (string)",
//        "function decimals() view returns (uint8)",
//        "function totalSupply() view returns (uint256)",
//        "function balanceOf(address) view returns (uint256)",
//        "function transfer(address, uint256) returns (bool)",
//        "event Transfer(address indexed, address indexed, uint256)"
//      ]
```

--------------------------------

### Format ABI Parameter (abitype vs ethers.js)

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Formats a JSON ABI parameter into a human-readable ABI parameter. abitype returns an inferred ABI parameter, while ethers.js returns a string. Benchmarks indicate abitype offers superior performance.

```typescript
import { formatAbiParameter } from 'abitype'

const result = formatAbiParameter({ type: 'string', name: 'foo' })
//    ^? 
```

```typescript
import { ParamType } from '@ethersproject/abi'

const result = ParamType.from({ type: 'string', name: 'foo' }).format('minimal')
//    ^? 
```

```typescript
import { ParamType } from 'ethers'

const result = ParamType.from({ type: 'string', name: 'foo' }).format('minimal')
//    ^? 
```

--------------------------------

### Declare `readContract` Function with ABIType

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/walkthrough.md

Declares the `readContract` function signature. It accepts an ABI, function name, and arguments, returning `unknown` initially. Relies on the `abitype` library for ABI type definitions.

```typescript
import { Abi } from 'abitype'

declare function readContract(config: {
  abi: Abi
  functionName: string
  args: readonly unknown[]
}): unknown
```

--------------------------------

### Format ABI Function (abitype vs ethers.js)

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Formats a JSON ABI function item into a human-readable ABI item. abitype returns an inferred ABI item, while ethers.js returns a string. Benchmarks show abitype is significantly faster.

```typescript
import { formatAbiItem } from 'abitype'

const abiItem = formatAbiItem({
  type: 'function',
  name: 'foo',
  stateMutability: 'nonpayable',
  inputs: [
    { type: 'string', name: 'bar' },
    { type: 'string', name: 'baz' },
  ],
  outputs: [],
})
abiItem
//^?
```

```typescript
import { Fragment } from '@ethersproject/abi'

const iface = Fragment.from({
  type: 'function',
  name: 'foo',
  stateMutability: 'nonpayable',
  inputs: [
    { type: 'string', name: 'bar' },
    { type: 'string', name: 'baz' },
  ],
  outputs: [],
})
const abiItem = iface.format('minimal')
//    ^?
```

```typescript
import { Fragment } from 'ethers'

const iface = Fragment.from({
  type: 'function',
  name: 'foo',
  stateMutability: 'nonpayable',
  inputs: [
    { type: 'string', name: 'bar' },
    { type: 'string', name: 'baz' },
  ],
  outputs: [],
})
const abiItem = iface.format('minimal')
//    ^?
```

--------------------------------

### Define Contract ABI Array

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/walkthrough.md

Defines a constant array representing a smart contract's ABI. This structure is used by ABIType to infer function signatures, argument types, and return types. Includes overloads for 'balanceOf'.

```typescript
export const abi = [
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'owner', type: 'address' }],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'collectionId', type: 'uint256' },
    ],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'tokenURI',
    type: 'function',
    stateMutability: 'pure',
    inputs: [{ name: 'id', type: 'uint256' }],
    outputs: [{ name: 'uri', type: 'string' }],
  },
  {
    name: 'safeTransferFrom',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'tokenId', type: 'uint256' },
    ],
    outputs: [],
  },
] as const
```

--------------------------------

### Convert ABI Parameters to TypeScript Primitives (TypeScript)

Source: https://context7.com/wevm/abitype/llms.txt

Converts ABI parameter types (inputs or outputs) to their corresponding TypeScript primitive types. Requires the 'abitype' library and prior extraction of function types.

```typescript
import type { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from 'abitype'
import { erc20Abi } from 'abitype/abis'

type TransferInputs = AbiParametersToPrimitiveTypes<
  ExtractAbiFunction<typeof erc20Abi, 'transfer'>['inputs']
>
//   ^? type TransferInputs = readonly [`0x${string}`, bigint]

type BalanceOfOutputs = AbiParametersToPrimitiveTypes<
  ExtractAbiFunction<typeof erc20Abi, 'balanceOf'>['outputs']
>
//   ^? type BalanceOfOutputs = readonly [bigint]
```

--------------------------------

### Parse ABI Parameter: abitype vs ethers.js

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Compares parsing a human-readable ABI parameter into a JSON ABI parameter using abitype and ethers.js. abitype returns an inferred ABI parameter, while ethers.js returns a ParamType object. Benchmarks show abitype is significantly faster.

```typescript
import { parseAbiParameter } from 'abitype'

const abiParameter = parseAbiParameter('string foo')
//    ^?
```

```typescript
import { ParamType } from '@ethersproject/abi'

const abiParameter = ParamType.from('string foo')
//    ^?
```

```typescript
import { ParamType } from 'ethers'

const abiParameter = ParamType.from('string foo')
//    ^?
```

--------------------------------

### Format Single ABI Item to String with Abitype

Source: https://context7.com/wevm/abitype/llms.txt

Formats a structured ABI item object into a human-readable ABI string. This is the inverse of `parseAbiItem`. Dependencies: 'abitype'.

```typescript
import { formatAbiItem } from 'abitype'

const funcStr = formatAbiItem({
  name: 'transferFrom',
  type: 'function',
  stateMutability: 'nonpayable',
  inputs: [
    { name: 'from', type: 'address' },
    { name: 'to', type: 'address' },
    { name: 'amount', type: 'uint256' },
  ],
  outputs: [{ type: 'bool' }],
})
//   ^? const funcStr: "function transferFrom(address from, address to, uint256 amount) returns (bool)"
```

--------------------------------

### Parse Human-Readable ABI to JSON (TypeScript)

Source: https://context7.com/wevm/abitype/llms.txt

Parses human-readable ABI strings into the standard JSON ABI format. Requires the 'abitype' library. Outputs an array of ABI item objects.

```typescript
import { parseAbi } from 'abitype'

const abi = parseAbi([
  'function balanceOf(address owner) view returns (uint256)',
  'function transfer(address to, uint256 amount) returns (bool)',
  'event Transfer(address indexed from, address indexed to, uint256 amount)',
  'error InsufficientBalance(uint256 available, uint256 required)',
])
//   ^? const abi: readonly [
//        { name: "balanceOf", type: "function", stateMutability: "view", inputs: [...], outputs: [...] },
//        { name: "transfer", type: "function", stateMutability: "nonpayable", inputs: [...], outputs: [...] },
//        { name: "Transfer", type: "event", inputs: [...] },
//        { name: "InsufficientBalance", type: "error", inputs: [...] }
//      ]
```

--------------------------------

### Custom Type Configuration for Abitype

Source: https://context7.com/wevm/abitype/llms.txt

Explains how to customize Abitype's default type mappings by augmenting the `abitype` module declaration. This allows users to specify alternative TypeScript types for primitive EVM types (e.g., `address`, `uint256`) and configure limits like `fixedArrayMaxLength`.

```typescript
// In your global types file (e.g., abitype.d.ts)
declare module 'abitype' {
  export interface Register {
    addressType: string // Use plain string instead of `0x${string}`
    bigIntType: number // Use number for all integers
    fixedArrayMaxLength: 50 // Support arrays up to length 50
  }
}

// Now all ABIType operations use your custom types
import type { AbiParameterToPrimitiveType } from 'abitype'

type AddressType = AbiParameterToPrimitiveType<{ type: 'address' }>
//   ^? type AddressType = string (instead of `0x${string}`)

type BigIntType = AbiParameterToPrimitiveType<{ type: 'uint256' }>
//   ^? type BigIntType = number (instead of bigint)
```

--------------------------------

### Format Abi Parameters with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats an array of ABI parameters into a human-readable string. This utility is useful for presenting multiple parameter definitions concisely.

```typescript
import { FormatAbiParameters } from 'abitype'

type Result = FormatAbiParameters<[
  { type: 'address'; name: 'from' },
  { type: 'uint256'; name: 'tokenId' },
]>
```

--------------------------------

### Extract Event Names and Types (TypeScript)

Source: https://context7.com/wevm/abitype/llms.txt

Extracts event names and specific event ABI definitions from an ABI. Also demonstrates converting event input parameters to primitive types. Requires the 'abitype' library.

```typescript
import type { ExtractAbiEventNames, ExtractAbiEvent, AbiParametersToPrimitiveTypes } from 'abitype'
import { erc20Abi } from 'abitype/abis'

type EventNames = ExtractAbiEventNames<typeof erc20Abi>
//   ^? type EventNames = "Transfer" | "Approval"

type TransferEvent = ExtractAbiEvent<typeof erc20Abi, 'Transfer'>
//   ^? type TransferEvent = {
//        name: "Transfer"
//        type: "event"
//        inputs: readonly [
//          { name: "from", type: "address", indexed: true },
//          { name: "to", type: "address", indexed: true },
//          { name: "value", type: "uint256", indexed: false }
//        ]
//      }

type TransferEventArgs = AbiParametersToPrimitiveTypes<TransferEvent['inputs']>
//   ^? type TransferEventArgs = readonly [`0x${string}`, `0x${string}`, bigint]
```

--------------------------------

### Validate Individual ABI Components with Abitype

Source: https://context7.com/wevm/abitype/llms.txt

Validates individual ABI components like functions and parameters using abitype/zod. It shows how to use `safeParse` to check the validity of function signatures and parameter definitions, logging success or failure. This is crucial for ensuring ABI data is correctly structured.

```typescript
import { AbiFunction, AbiEvent, AbiParameter } from 'abitype/zod'

const functionResult = AbiFunction.safeParse({
  type: 'function',
  name: 'approve',
  inputs: [
    { type: 'address', name: 'spender' },
    { type: 'uint256', name: 'amount' },
  ],
  outputs: [{ type: 'bool' }],
  stateMutability: 'nonpayable',
})

if (functionResult.success) {
  console.log('Valid function:', functionResult.data)
}

const paramResult = AbiParameter.safeParse({
  type: 'tuple',
  name: 'person',
  components: [
    { type: 'string', name: 'name' },
    { type: 'uint256', name: 'age' },
  ],
})
```

--------------------------------

### Format ABI Parameter with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats a single structured AbiParameter object into its human-readable string representation. This is useful for displaying individual parameter types and names. Requires 'abitype' package.

```typescript
import { formatAbiParameter } from 'abitype'

const result = formatAbiParameter({ type: 'address', name: 'from' })
```

--------------------------------

### Configure ABIType Custom BigInt Type

Source: https://github.com/wevm/abitype/blob/main/docs/pages/config.md

Demonstrates how to extend the `Register` interface in ABIType to customize the `bigIntType`. This allows users to define a specific bigint type, such as `bigint & { foo: 'bar' }`, for use within their project. This is useful for adding custom properties or constraints to the bigint type used for ABI integer types.

```typescript
declare module 'abitype' {
  export interface Register {
    bigIntType: bigint & { foo: 'bar' }
  }
}

import { ResolvedRegister } from 'abitype'
type Result = ResolvedRegister['bigIntType']
//   ^?
```

--------------------------------

### Import AbiFallback Type from abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/types.md

Imports the `AbiFallback` type from the 'abitype' library, representing ABI fallback types.

```typescript
import { AbiFallback } from 'abitype'
```

--------------------------------

### Format Abi Item with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats a single ABI item (e.g., error, event, function) into a human-readable string. This is useful for displaying individual ABI components in a user-friendly format.

```typescript
import { FormatAbiItem } from 'abitype'

type Result = FormatAbiItem<{
  name: 'balanceOf'
  type: 'function'
  stateMutability: 'view'
  inputs: [{ type: 'address'; name: 'owner' }]
  outputs: [{ type: 'uint256' }]
}>
```

--------------------------------

### Adding Return Type Inference for Contract Read Function (TypeScript)

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/walkthrough.md

Extends the previous snippet by adding return type inference for a contract read function. It introduces an `abiFunction` generic slot to reuse the extracted function type for both arguments and return values, utilizing AbiParametersToPrimitiveTypes for output conversion.

```typescript
// @filename: abi.ts
export const abi = [
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: 'owner', type: 'address' }],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [
      { name: 'owner', type: 'address' },
      { name: 'collectionId', type: 'uint256' },
    ],
    outputs: [{ name: 'balance', type: 'uint256' }],
  },
  {
    name: 'tokenURI',
    type: 'function',
    stateMutability: 'pure',
    inputs: [{ name: 'id', type: 'uint256' }],
    outputs: [{ name: 'uri', type: 'string' }],
  },
  {
    name: 'safeTransferFrom',
    type: 'function',
    stateMutability: 'nonpayable',
    inputs: [
      { name: 'from', type: 'address' },
      { name: 'to', type: 'address' },
      { name: 'tokenId', type: 'uint256' },
    ],
    outputs: [],
  },
] as const
// @filename: readContract.ts
// ---cut---
import {
  Abi,
  AbiFunction,
  AbiParametersToPrimitiveTypes,
  ExtractAbiFunction,
  ExtractAbiFunctionNames,
} from 'abitype'
import { abi } from './abi'

declare function readContract<
  abi extends Abi,
  functionName extends ExtractAbiFunctionNames<abi, 'pure' | 'view'>,
  abiFunction extends AbiFunction = ExtractAbiFunction<
    abi,
    functionName
  >
>(config: {
  abi: abi
  functionName: functionName | ExtractAbiFunctionNames<abi, 'pure' | 'view'>
  args: AbiParametersToPrimitiveTypes<abiFunction['inputs'], 'inputs'>
}): AbiParametersToPrimitiveTypes<abiFunction['outputs'], 'outputs'>

const res = readContract({
  //  ^?

  
  abi,
  functionName: 'balanceOf',
  args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
})

```

--------------------------------

### Format Single ABI Item with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats a single ABI item (like an error, event, or function) into its human-readable string signature. This is useful for displaying individual ABI components. Requires 'abitype' package.

```typescript
import { formatAbiItem } from 'abitype'

const result = formatAbiItem({
  name: 'balanceOf',
  type: 'function',
  stateMutability: 'view',
  inputs: [{ type: 'address', name: 'owner' }],
  outputs: [{ type: 'uint256' }],
})
```

--------------------------------

### Import Solidity Types from abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/types.md

Imports various Solidity type aliases from the 'abitype' library for use as template strings.

```typescript
import {
  SolidityAddress,
  SolidityArray,
  SolidityBool,
  SolidityBytes,
  SolidityFunction,
  SolidityInt,
  SolidityString,
  SolidityTuple,
} from 'abitype'
```

--------------------------------

### Parse Human-Readable ABI Item with ethers.js

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Parses a single human-readable ABI item string into a Fragment object using ethers.js. Supports inline tuples but not struct signatures. Returns Fragment.

```typescript
import { Fragment } from '@ethersproject/abi'

const abiItem = Fragment.from(
  //  ^?


  'function name(tuple(string name, uint256 age) foo, uint256 tokenId)',
)
```

```typescript
import { Fragment } from 'ethers'

const abiItem = Fragment.from(
  //  ^?

  
  'function name(tuple(string name, uint256 age) foo, uint256 tokenId)',
)
```

--------------------------------

### Format ABI with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats a structured ABI array into a human-readable string representation. This function takes an array of ABI items (functions, events, errors) and returns an array of their string signatures. Requires 'abitype' package.

```typescript
import { formatAbi } from 'abitype'

const result = formatAbi([
  {
    name: 'balanceOf',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ type: 'address', name: 'owner' }],
    outputs: [{ type: 'uint256' }],
  },
  {
    name: 'Transfer',
    type: 'event',
    inputs: [
      { type: 'address', name: 'from', indexed: true },
      { type: 'address', name: 'to', indexed: true },
      { type: 'uint256', name: 'amount' },
    ],
  },
])
```

--------------------------------

### Convert Human-Readable ABI to JSON ABI - TypeScript

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

This snippet demonstrates the conversion from a human-readable ABI format to the standard JSON ABI format using TypeScript. It illustrates how signatures like functions, events, and errors are represented in both formats. No external dependencies are explicitly mentioned.

```typescript
const abi = [
  'constructor()',
  'function balanceOf(address owner) view returns (uint256)',
  'event Transfer(address indexed from, address indexed to, uint256 amount)',
  'error ApprovalCallerNotOwnerNorApproved()',
] as const
```

```typescript
const abi = [
  {
    inputs: [],
    stateMutability: 'nonpayable',
    type: 'constructor',
  },
  {
    inputs: [{ name: 'owner', type: 'address' }],
    name: 'balanceOf',
    outputs: [{ type: 'uint256' }],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [
      {
        name: 'from',
        type: 'address',
        indexed: true,
      },
      {
        name: 'to',
        type: 'address',
        indexed: true,
      },
      {
        name: 'tokenId',
        type: 'uint256',
        indexed: true,
      },
    ],
    name: 'Transfer',
    type: 'event',
  },
  { inputs: [], name: 'ApprovalCallerNotOwnerNorApproved', type: 'error' },
] as const
```

--------------------------------

### Format ABI Parameters with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats an array of structured AbiParameter objects into a single human-readable string representing all parameters. This function is helpful for generating function signatures or event signatures. Requires 'abitype' package.

```typescript
import { formatAbiParameters } from 'abitype'

const result = formatAbiParameters([
  { type: 'address', name: 'from' },
  { type: 'uint256', name: 'tokenId' },
])
```

--------------------------------

### Format Abi Parameter with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/human.md

Formats a single ABI parameter into a human-readable string. This function is helpful for displaying individual parameter definitions in a clear manner.

```typescript
import { FormatAbiParameter } from 'abitype'

type Result = FormatAbiParameter<{ type: 'address'; name: 'from' }>
```

--------------------------------

### Import AbiParameterKind Type from abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/types.md

Imports the `AbiParameterKind` type from the 'abitype' library, specifying the kind of ABI parameter ('inputs' or 'outputs').

```typescript
import { AbiParameterKind } from 'abitype'
```

--------------------------------

### Parse Human-Readable ABI with ethers.js

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Parses a human-readable ABI string into fragments using ethers.js. Supports inline tuples but not struct signatures directly. Returns readonly Fragment[].

```typescript
import { Interface } from '@ethersproject/abi'

const iface = new Interface([
  'function name(tuple(string name, uint256 age) foo, uint256 tokenId)',
  'event Foo(address indexed bar)',
])
const abi = iface.fragments
//    ^?

```

```typescript
import { Interface } from 'ethers'

const iface = new Interface([
  'function name(tuple(string name, uint256 age) foo, uint256 tokenId)',
  'event Foo(address indexed bar)',
])
const abi = iface.fragments
//    ^?

```

--------------------------------

### Parse Human-Readable ABI with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Parses a human-readable ABI string into a structured ABI format using abitype. Supports inline structs and mixed named/unnamed parameters. Returns inferred ABI.

```typescript
import { parseAbi } from 'abitype'

const abi = parseAbi([
  'function name((string name, uint256 age) foo, uint256 tokenId)',
  'event Foo(address indexed bar)',
])
abi
//^?














```

```typescript
import { parseAbi } from 'abitype'

const abi = parseAbi([
  'struct Foo { string name; uint256 age }',
  'function name((string name, uint256 age) foo, uint256 tokenId)',
  'event Foo(address indexed bar)',
])
abi
//^?














```

--------------------------------

### Parse Human-Readable ABI Item with abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/guide/comparisons.md

Parses a single human-readable ABI item string into a structured ABI item format using abitype. Supports inline structs and mixed parameters. Returns inferred ABI item.

```typescript
import { parseAbiItem } from 'abitype'

const abiItem = parseAbiItem(
  //  ^?













  'function name((string name, uint256 age) foo, uint256 tokenId)',
)
```

--------------------------------

### Parse ABI Parameters with Abitype

Source: https://context7.com/wevm/abitype/llms.txt

Parses a comma-separated string of ABI types into an array of parameter objects. It supports basic types, tuples, and arrays of tuples. Dependencies: 'abitype'.

```typescript
import { parseAbiParameters } from 'abitype'

const params = parseAbiParameters('address from, address to, uint256 tokenId')
//   ^? const params: readonly [
//        { name: "from", type: "address" },
//        { name: "to", type: "address" },
//        { name: "tokenId", type: "uint256" }
//      ]

const complexParams = parseAbiParameters('(string name, uint256 age)[] users, bytes32 hash')
//   ^? const complexParams: readonly [
//        {
//          name: "users",
//          type: "tuple[]",
//          components: readonly [
//            { name: "name", type: "string" },
//            { name: "age", type: "uint256" }
//          ]
//        },
//        { name: "hash", type: "bytes32" }
//      ]
```

--------------------------------

### Import AbiParameter Type from abitype

Source: https://github.com/wevm/abitype/blob/main/docs/pages/api/types.md

Imports the `AbiParameter` type from the 'abitype' library, used for ABI function, error, and constructor parameters.

```typescript
import { AbiParameter } from 'abitype'
```
Tokens:
Raw