viem 2.0.0-alpha.12 → 2.0.0-alpha.13

package/utils/abi/decodeFunctionResult.ts

@@ -2,7 +2,9 @@ import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
 import {
   AbiFunctionNotFoundError,
+  type AbiFunctionNotFoundErrorType,
   AbiFunctionOutputsNotFoundError,
+  type AbiFunctionOutputsNotFoundErrorType,
 } from '../../errors/abi.js'
 import type {
   ContractFunctionArgs,
@@ -12,9 +14,13 @@ import type {
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { decodeAbiParameters } from './decodeAbiParameters.js'
-import { getAbiItem } from './getAbiItem.js'
+import {
+  type DecodeAbiParametersErrorType,
+  decodeAbiParameters,
+} from './decodeAbiParameters.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/decodeFunctionResult'
 
@@ -111,6 +117,13 @@ export type DecodeFunctionResultReturnType<
   args
 >
 
+export type DecodeFunctionResultErrorType =
+  | AbiFunctionNotFoundErrorType
+  | AbiFunctionOutputsNotFoundErrorType
+  | DecodeAbiParametersErrorType
+  | GetAbiItemErrorType
+  | ErrorType
+
 export function decodeFunctionResult<
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi> | undefined = undefined,

package/utils/abi/encodeAbiParameters.ts

@@ -6,22 +6,44 @@ import type {
 
 import {
   AbiEncodingArrayLengthMismatchError,
+  type AbiEncodingArrayLengthMismatchErrorType,
   AbiEncodingBytesSizeMismatchError,
+  type AbiEncodingBytesSizeMismatchErrorType,
   AbiEncodingLengthMismatchError,
+  type AbiEncodingLengthMismatchErrorType,
   InvalidAbiEncodingTypeError,
+  type InvalidAbiEncodingTypeErrorType,
   InvalidArrayError,
+  type InvalidArrayErrorType,
 } from '../../errors/abi.js'
-import { InvalidAddressError } from '../../errors/address.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
-import { isAddress } from '../address/isAddress.js'
-import { concat } from '../data/concat.js'
-import { padHex } from '../data/pad.js'
-import { size } from '../data/size.js'
-import { slice } from '../data/slice.js'
-import { boolToHex, numberToHex, stringToHex } from '../encoding/toHex.js'
+import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+import { type ConcatErrorType, concat } from '../data/concat.js'
+import { type PadHexErrorType, padHex } from '../data/pad.js'
+import { type SizeErrorType, size } from '../data/size.js'
+import { type SliceErrorType, slice } from '../data/slice.js'
+import {
+  type BoolToHexErrorType,
+  type NumberToHexErrorType,
+  type StringToHexErrorType,
+  boolToHex,
+  numberToHex,
+  stringToHex,
+} from '../encoding/toHex.js'
 
 export type EncodeAbiParametersReturnType = Hex
 
+export type EncodeAbiParametersErrorType =
+  | AbiEncodingLengthMismatchErrorType
+  | PrepareParamsErrorType
+  | EncodeParamsErrorType
+  | ErrorType
+
 /**
  * @description Encodes a list of primitive values into an ABI-encoded hex value.
  */
@@ -55,6 +77,8 @@ type PreparedParam = { dynamic: boolean; encoded: Hex }
 type TupleAbiParameter = AbiParameter & { components: readonly AbiParameter[] }
 type Tuple = AbiParameterToPrimitiveType<TupleAbiParameter>
 
+export type PrepareParamsErrorType = ErrorType
+
 function prepareParams<const TParams extends readonly AbiParameter[]>({
   params,
   values,
@@ -69,6 +93,11 @@ function prepareParams<const TParams extends readonly AbiParameter[]>({
   return preparedParams
 }
 
+export type PrepareParamErrorType =
+  | GetArrayComponentsErrorType
+  | InvalidAbiEncodingTypeErrorType
+  | ErrorType
+
 function prepareParam<const TParam extends AbiParameter>({
   param,
   value,
@@ -109,6 +138,11 @@ function prepareParam<const TParam extends AbiParameter>({
 
 /////////////////////////////////////////////////////////////////
 
+export type EncodeParamsErrorType =
+  | NumberToHexErrorType
+  | SizeErrorType
+  | ErrorType
+
 function encodeParams(preparedParams: PreparedParam[]): Hex {
   // 1. Compute the size of the static part of the parameters.
   let staticSize = 0
@@ -139,11 +173,25 @@ function encodeParams(preparedParams: PreparedParam[]): Hex {
 
 /////////////////////////////////////////////////////////////////
 
+export type EncodeAddressErrorType =
+  | InvalidAddressErrorType
+  | IsAddressErrorType
+  | ErrorType
+
 function encodeAddress(value: Hex): PreparedParam {
   if (!isAddress(value)) throw new InvalidAddressError({ address: value })
   return { dynamic: false, encoded: padHex(value.toLowerCase() as Hex) }
 }
 
+export type EncodeArrayErrorType =
+  | AbiEncodingArrayLengthMismatchErrorType
+  | ConcatErrorType
+  | EncodeParamsErrorType
+  | InvalidArrayErrorType
+  | NumberToHexErrorType
+  | PrepareParamErrorType
+  | ErrorType
+
 function encodeArray<const TParam extends AbiParameter>(
   value: AbiParameterToPrimitiveType<TParam>,
   {
@@ -189,6 +237,14 @@ function encodeArray<const TParam extends AbiParameter>(
   }
 }
 
+export type EncodeBytesErrorType =
+  | AbiEncodingBytesSizeMismatchErrorType
+  | ConcatErrorType
+  | PadHexErrorType
+  | NumberToHexErrorType
+  | SizeErrorType
+  | ErrorType
+
 function encodeBytes<const TParam extends AbiParameter>(
   value: Hex,
   { param }: { param: TParam },
@@ -217,10 +273,17 @@ function encodeBytes<const TParam extends AbiParameter>(
   return { dynamic: false, encoded: padHex(value, { dir: 'right' }) }
 }
 
+export type EncodeBoolErrorType =
+  | PadHexErrorType
+  | BoolToHexErrorType
+  | ErrorType
+
 function encodeBool(value: boolean): PreparedParam {
   return { dynamic: false, encoded: padHex(boolToHex(value)) }
 }
 
+export type EncodeNumberErrorType = NumberToHexErrorType | ErrorType
+
 function encodeNumber(
   value: number,
   { signed }: { signed: boolean },
@@ -234,6 +297,15 @@ function encodeNumber(
   }
 }
 
+export type EncodeStringErrorType =
+  | ConcatErrorType
+  | NumberToHexErrorType
+  | PadHexErrorType
+  | SizeErrorType
+  | SliceErrorType
+  | StringToHexErrorType
+  | ErrorType
+
 function encodeString(value: string): PreparedParam {
   const hexValue = stringToHex(value)
   const partsLength = Math.ceil(size(hexValue) / 32)
@@ -254,6 +326,12 @@ function encodeString(value: string): PreparedParam {
   }
 }
 
+export type EncodeTupleErrorType =
+  | ConcatErrorType
+  | EncodeParamsErrorType
+  | PrepareParamErrorType
+  | ErrorType
+
 function encodeTuple<
   const TParam extends AbiParameter & { components: readonly AbiParameter[] },
 >(
@@ -280,6 +358,8 @@ function encodeTuple<
   }
 }
 
+export type GetArrayComponentsErrorType = ErrorType
+
 export function getArrayComponents(
   type: string,
 ): [length: number | null, innerType: string] | undefined {

package/utils/abi/encodeDeployData.ts

@@ -2,14 +2,18 @@ import type { Abi } from 'abitype'
 
 import {
   AbiConstructorNotFoundError,
+  type AbiConstructorNotFoundErrorType,
   AbiConstructorParamsNotFoundError,
 } from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import { concatHex } from '../data/concat.js'
-
 import type { UnionEvaluate } from '../../types/utils.js'
-import { encodeAbiParameters } from './encodeAbiParameters.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from './encodeAbiParameters.js'
 
 const docsPath = '/docs/contract/encodeDeployData'
 
@@ -36,6 +40,12 @@ export type EncodeDeployDataParameters<
 
 export type EncodeDeployDataReturnType = Hex
 
+export type EncodeDeployDataErrorType =
+  | AbiConstructorNotFoundErrorType
+  | ConcatHexErrorType
+  | EncodeAbiParametersErrorType
+  | ErrorType
+
 export function encodeDeployData<const abi extends Abi | readonly unknown[]>(
   parameters: EncodeDeployDataParameters<abi>,
 ): EncodeDeployDataReturnType {

package/utils/abi/encodeErrorResult.ts

@@ -9,13 +9,20 @@ import type {
   ContractErrorName,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import { concatHex } from '../data/concat.js'
-import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
+import {
+  type GetFunctionSelectorErrorType,
+  getFunctionSelector,
+} from '../hash/getFunctionSelector.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from './encodeAbiParameters.js'
+import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeErrorResult'
 
@@ -51,6 +58,14 @@ export type EncodeErrorResultParameters<
 
 export type EncodeErrorResultReturnType = Hex
 
+export type EncodeErrorResultErrorType =
+  | GetAbiItemErrorType
+  | FormatAbiItemErrorType
+  | GetFunctionSelectorErrorType
+  | EncodeAbiParametersErrorType
+  | ConcatHexErrorType
+  | ErrorType
+
 export function encodeErrorResult<
   const abi extends Abi | readonly unknown[],
   errorName extends ContractErrorName<abi> | undefined = undefined,

package/utils/abi/encodeEventTopics.ts

@@ -5,22 +5,34 @@ import type {
   ExtractAbiEvents,
 } from 'abitype'
 
-import { AbiEventNotFoundError } from '../../errors/abi.js'
-import { FilterTypeNotSupportedError } from '../../errors/log.js'
+import {
+  AbiEventNotFoundError,
+  type AbiEventNotFoundErrorType,
+} from '../../errors/abi.js'
+import {
+  FilterTypeNotSupportedError,
+  type FilterTypeNotSupportedErrorType,
+} from '../../errors/log.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   ContractEventArgs,
   ContractEventName,
   EventDefinition,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import { toBytes } from '../encoding/toBytes.js'
-import { getEventSelector } from '../hash/getEventSelector.js'
-import { keccak256 } from '../hash/keccak256.js'
-
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import {
+  type GetEventSelectorErrorType,
+  getEventSelector,
+} from '../hash/getEventSelector.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from './encodeAbiParameters.js'
+import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeEventTopics'
 
@@ -54,6 +66,14 @@ export type EncodeEventTopicsParameters<
 > &
   (hasEvents extends true ? unknown : never)
 
+export type EncodeEventTopicsErrorType =
+  | AbiEventNotFoundErrorType
+  | EncodeArgErrorType
+  | FormatAbiItemErrorType
+  | GetAbiItemErrorType
+  | GetEventSelectorErrorType
+  | ErrorType
+
 export function encodeEventTopics<
   const abi extends Abi | readonly unknown[],
   eventName extends ContractEventName<abi> | undefined = undefined,
@@ -100,6 +120,13 @@ export function encodeEventTopics<
   return [signature, ...topics]
 }
 
+export type EncodeArgErrorType =
+  | Keccak256ErrorType
+  | ToBytesErrorType
+  | EncodeAbiParametersErrorType
+  | FilterTypeNotSupportedErrorType
+  | ErrorType
+
 function encodeArg({
   param,
   value,

package/utils/abi/encodeFunctionData.ts

@@ -1,18 +1,28 @@
 import type { Abi, AbiStateMutability, ExtractAbiFunctions } from 'abitype'
 
-import { AbiFunctionNotFoundError } from '../../errors/abi.js'
+import {
+  AbiFunctionNotFoundError,
+  type AbiFunctionNotFoundErrorType,
+} from '../../errors/abi.js'
 import type {
   ContractFunctionArgs,
   ContractFunctionName,
 } from '../../types/contract.js'
-import { concatHex } from '../data/concat.js'
-import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
+import {
+  type GetFunctionSelectorErrorType,
+  getFunctionSelector,
+} from '../hash/getFunctionSelector.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { formatAbiItem } from './formatAbiItem.js'
-import { getAbiItem } from './getAbiItem.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from './encodeAbiParameters.js'
+import { type FormatAbiItemErrorType, formatAbiItem } from './formatAbiItem.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeFunctionData'
 
@@ -55,6 +65,15 @@ export type EncodeFunctionDataParameters<
 
 export type EncodeFunctionDataReturnType = Hex
 
+export type EncodeFunctionDataErrorType =
+  | AbiFunctionNotFoundErrorType
+  | ConcatHexErrorType
+  | EncodeAbiParametersErrorType
+  | FormatAbiItemErrorType
+  | GetAbiItemErrorType
+  | GetFunctionSelectorErrorType
+  | ErrorType
+
 export function encodeFunctionData<
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi> | undefined = undefined,

package/utils/abi/encodeFunctionResult.ts

@@ -9,10 +9,14 @@ import type {
   ContractFunctionReturnType,
 } from '../../types/contract.js'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { encodeAbiParameters } from './encodeAbiParameters.js'
-import { getAbiItem } from './getAbiItem.js'
+import {
+  type EncodeAbiParametersErrorType,
+  encodeAbiParameters,
+} from './encodeAbiParameters.js'
+import { type GetAbiItemErrorType, getAbiItem } from './getAbiItem.js'
 
 const docsPath = '/docs/contract/encodeFunctionResult'
 
@@ -53,6 +57,13 @@ export type EncodeFunctionResultParameters<
 
 export type EncodeFunctionResultReturnType = Hex
 
+export type EncodeFunctionResultErrorType =
+  | AbiFunctionOutputsNotFoundError
+  | AbiFunctionNotFoundError
+  | EncodeAbiParametersErrorType
+  | GetAbiItemErrorType
+  | ErrorType
+
 export function encodeFunctionResult<
   const abi extends Abi | readonly unknown[],
   functionName extends ContractFunctionName<abi> | undefined = undefined,

package/utils/abi/encodePacked.ts

@@ -12,15 +12,28 @@ import type {
 
 import {
   AbiEncodingLengthMismatchError,
+  type AbiEncodingLengthMismatchErrorType,
   BytesSizeMismatchError,
+  type BytesSizeMismatchErrorType,
   UnsupportedPackedAbiType,
 } from '../../errors/abi.js'
-import { InvalidAddressError } from '../../errors/address.js'
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
-import { isAddress } from '../address/isAddress.js'
-import { concatHex } from '../data/concat.js'
-import { pad } from '../data/pad.js'
-import { boolToHex, numberToHex, stringToHex } from '../encoding/toHex.js'
+import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
+import { type ConcatHexErrorType, concatHex } from '../data/concat.js'
+import { type PadErrorType, pad } from '../data/pad.js'
+import {
+  type BoolToHexErrorType,
+  type NumberToHexErrorType,
+  type StringToHexErrorType,
+  boolToHex,
+  numberToHex,
+  stringToHex,
+} from '../encoding/toHex.js'
 import { arrayRegex, bytesRegex, integerRegex } from '../regex.js'
 
 type PackedAbiType =
@@ -39,6 +52,12 @@ type EncodePackedValues<
     : unknown
 }
 
+export type EncodePackedErrorType =
+  | AbiEncodingLengthMismatchErrorType
+  | ConcatHexErrorType
+  | EncodeErrorType
+  | ErrorType
+
 export function encodePacked<
   const TPackedAbiTypes extends readonly PackedAbiType[] | readonly unknown[],
 >(types: TPackedAbiTypes, values: EncodePackedValues<TPackedAbiTypes>): Hex {
@@ -57,6 +76,17 @@ export function encodePacked<
   return concatHex(data)
 }
 
+type EncodeErrorType =
+  | BoolToHexErrorType
+  | BytesSizeMismatchErrorType
+  | InvalidAddressErrorType
+  | IsAddressErrorType
+  | NumberToHexErrorType
+  | PadErrorType
+  | StringToHexErrorType
+  | UnsupportedPackedAbiType
+  | ErrorType
+
 function encode<const TPackedAbiType extends PackedAbiType | unknown>(
   type: TPackedAbiType,
   value: EncodePackedValues<[TPackedAbiType]>[0],

package/utils/abi/formatAbiItem.ts

@@ -1,8 +1,17 @@
 import type { AbiParameter } from 'abitype'
 
-import { InvalidDefinitionTypeError } from '../../errors/abi.js'
+import {
+  InvalidDefinitionTypeError,
+  type InvalidDefinitionTypeErrorType,
+} from '../../errors/abi.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { AbiItem } from '../../types/contract.js'
 
+export type FormatAbiItemErrorType =
+  | FormatAbiParamsErrorType
+  | InvalidDefinitionTypeErrorType
+  | ErrorType
+
 export function formatAbiItem(
   abiItem: AbiItem,
   { includeName = false }: { includeName?: boolean } = {},
@@ -17,6 +26,8 @@ export function formatAbiItem(
   return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`
 }
 
+export type FormatAbiParamsErrorType = ErrorType
+
 export function formatAbiParams(
   params: readonly AbiParameter[] | undefined,
   { includeName = false }: { includeName?: boolean } = {},
@@ -27,6 +38,8 @@ export function formatAbiParams(
     .join(includeName ? ', ' : ',')
 }
 
+export type FormatAbiParamErrorType = ErrorType
+
 function formatAbiParam(
   param: AbiParameter,
   { includeName }: { includeName: boolean },

package/utils/abi/formatAbiItemWithArgs.ts

@@ -1,8 +1,11 @@
 import type { AbiParameter } from 'abitype'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { AbiItem } from '../../types/contract.js'
 import { stringify } from '../stringify.js'
 
+export type FormatAbiItemWithArgsErrorType = ErrorType
+
 export function formatAbiItemWithArgs({
   abiItem,
   args,

package/utils/abi/getAbiItem.ts

@@ -1,5 +1,6 @@
 import type { Abi, AbiParameter, Address } from 'abitype'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   AbiItem,
   AbiItemArgs,
@@ -9,10 +10,13 @@ import type {
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { UnionEvaluate } from '../../types/utils.js'
-import { isAddress } from '../address/isAddress.js'
-import { isHex } from '../data/isHex.js'
-import { getEventSelector } from '../hash/getEventSelector.js'
-import { getFunctionSelector } from '../hash/getFunctionSelector.js'
+import { type IsHexErrorType, isHex } from '../../utils/data/isHex.js'
+import { getEventSelector } from '../../utils/hash/getEventSelector.js'
+import {
+  type GetFunctionSelectorErrorType,
+  getFunctionSelector,
+} from '../../utils/hash/getFunctionSelector.js'
+import { type IsAddressErrorType, isAddress } from '../address/isAddress.js'
 
 export type GetAbiItemParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -48,6 +52,12 @@ export type GetAbiItemParameters<
       }
 >
 
+export type GetAbiItemErrorType =
+  | IsArgOfTypeErrorType
+  | IsHexErrorType
+  | GetFunctionSelectorErrorType
+  | ErrorType
+
 export type GetAbiItemReturnType<
   abi extends Abi | readonly unknown[] = Abi,
   name extends AbiItemName<abi> = AbiItemName<abi>,
@@ -107,6 +117,8 @@ export function getAbiItem<
   return abiItems[0] as GetAbiItemReturnType<abi, name, args>
 }
 
+export type IsArgOfTypeErrorType = IsAddressErrorType | ErrorType
+
 export function isArgOfType(arg: unknown, abiParameter: AbiParameter): boolean {
   const argType = typeof arg
   const abiParameterType = abiParameter.type

package/utils/address/getAddress.ts

@@ -1,10 +1,18 @@
 import type { Address } from 'abitype'
 
 import { InvalidAddressError } from '../../errors/address.js'
-import { stringToBytes } from '../encoding/toBytes.js'
-import { keccak256 } from '../hash/keccak256.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type StringToBytesErrorType,
+  stringToBytes,
+} from '../encoding/toBytes.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import { type IsAddressErrorType, isAddress } from './isAddress.js'
 
-import { isAddress } from './isAddress.js'
+export type ChecksumAddressErrorType =
+  | Keccak256ErrorType
+  | StringToBytesErrorType
+  | ErrorType
 
 export function checksumAddress(address_: Address, chainId?: number): Address {
   const hexAddress = chainId
@@ -27,6 +35,11 @@ export function checksumAddress(address_: Address, chainId?: number): Address {
   return `0x${address.join('')}`
 }
 
+export type GetAddressErrorType =
+  | ChecksumAddressErrorType
+  | IsAddressErrorType
+  | ErrorType
+
 export function getAddress(address: string, chainId?: number): Address {
   if (!isAddress(address)) throw new InvalidAddressError({ address })
   return checksumAddress(address, chainId)