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

package/utils/errors/getCallError.ts

@@ -1,13 +1,28 @@
 import type { CallParameters } from '../../actions/public/call.js'
 import type { BaseError } from '../../errors/base.js'
-import { CallExecutionError } from '../../errors/contract.js'
+import {
+  CallExecutionError,
+  type CallExecutionErrorType,
+} from '../../errors/contract.js'
 import { UnknownNodeError } from '../../errors/node.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 
-import { type GetNodeErrorParameters, getNodeError } from './getNodeError.js'
+import {
+  type GetNodeErrorParameters,
+  type GetNodeErrorReturnType,
+  getNodeError,
+} from './getNodeError.js'
 
-export function getCallError(
-  err: BaseError,
+export type GetCallErrorReturnType<cause = ErrorType> = Omit<
+  CallExecutionErrorType,
+  'cause'
+> & {
+  cause: cause | GetNodeErrorReturnType
+}
+
+export function getCallError<err extends ErrorType<string>>(
+  err: err,
   {
     docsPath,
     ...args
@@ -15,11 +30,17 @@ export function getCallError(
     chain?: Chain
     docsPath?: string
   },
-) {
-  let cause = getNodeError(err, args as GetNodeErrorParameters)
-  if (cause instanceof UnknownNodeError) cause = err
+): GetCallErrorReturnType<err> {
+  const cause = (() => {
+    const cause = getNodeError(
+      err as {} as BaseError,
+      args as GetNodeErrorParameters,
+    )
+    if (cause instanceof UnknownNodeError) return err as {} as BaseError
+    return cause
+  })()
   return new CallExecutionError(cause, {
     docsPath,
     ...args,
-  })
+  }) as GetCallErrorReturnType<err>
 }

package/utils/errors/getContractError.ts

@@ -4,16 +4,30 @@ import { AbiDecodingZeroDataError } from '../../errors/abi.js'
 import { BaseError } from '../../errors/base.js'
 import {
   ContractFunctionExecutionError,
+  type ContractFunctionExecutionErrorType,
   ContractFunctionRevertedError,
+  type ContractFunctionRevertedErrorType,
   ContractFunctionZeroDataError,
+  type ContractFunctionZeroDataErrorType,
   RawContractError,
 } from '../../errors/contract.js'
 import { InternalRpcError } from '../../errors/rpc.js'
+import type { ErrorType } from '../../errors/utils.js'
 
 const EXECUTION_REVERTED_ERROR_CODE = 3
 
-export function getContractError(
-  err: BaseError,
+export type GetContractErrorReturnType<cause = ErrorType> = Omit<
+  ContractFunctionExecutionErrorType,
+  'cause'
+> & {
+  cause:
+    | cause
+    | ContractFunctionZeroDataErrorType
+    | ContractFunctionRevertedErrorType
+}
+
+export function getContractError<err extends ErrorType<string>>(
+  err: err,
   {
     abi,
     address,
@@ -29,7 +43,7 @@ export function getContractError(
     functionName: string
     sender?: Address
   },
-) {
+): GetContractErrorReturnType {
   const { code, data, message, shortMessage } = (
     err instanceof RawContractError
       ? err
@@ -38,27 +52,29 @@ export function getContractError(
       : {}
   ) as RawContractError
 
-  let cause = err
-  if (err instanceof AbiDecodingZeroDataError) {
-    cause = new ContractFunctionZeroDataError({ functionName })
-  } else if (
-    [EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) &&
-    (data || message || shortMessage)
-  ) {
-    cause = new ContractFunctionRevertedError({
-      abi,
-      data: typeof data === 'object' ? data.data : data,
-      functionName,
-      message: shortMessage ?? message,
-    })
-  }
+  const cause = (() => {
+    if (err instanceof AbiDecodingZeroDataError)
+      return new ContractFunctionZeroDataError({ functionName })
+    if (
+      [EXECUTION_REVERTED_ERROR_CODE, InternalRpcError.code].includes(code) &&
+      (data || message || shortMessage)
+    ) {
+      return new ContractFunctionRevertedError({
+        abi,
+        data: typeof data === 'object' ? data.data : data,
+        functionName,
+        message: shortMessage ?? message,
+      })
+    }
+    return err
+  })()
 
-  return new ContractFunctionExecutionError(cause, {
+  return new ContractFunctionExecutionError(cause as BaseError, {
     abi,
     args,
     contractAddress: address,
     docsPath,
     functionName,
     sender,
-  })
+  }) as GetContractErrorReturnType
 }

package/utils/errors/getEstimateGasError.ts

@@ -1,14 +1,27 @@
 import type { Account } from '../../accounts/types.js'
 import type { EstimateGasParameters } from '../../actions/public/estimateGas.js'
 import type { BaseError } from '../../errors/base.js'
-import { EstimateGasExecutionError } from '../../errors/estimateGas.js'
+import {
+  EstimateGasExecutionError,
+  type EstimateGasExecutionErrorType,
+} from '../../errors/estimateGas.js'
 import { UnknownNodeError } from '../../errors/node.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 
-import { type GetNodeErrorParameters, getNodeError } from './getNodeError.js'
+import {
+  type GetNodeErrorParameters,
+  type GetNodeErrorReturnType,
+  getNodeError,
+} from './getNodeError.js'
 
-export function getEstimateGasError(
-  err: BaseError,
+export type GetEstimateGasErrorReturnType<cause = ErrorType> = Omit<
+  EstimateGasExecutionErrorType,
+  'cause'
+> & { cause: cause | GetNodeErrorReturnType }
+
+export function getEstimateGasError<err extends ErrorType<string>>(
+  err: err,
   {
     docsPath,
     ...args
@@ -17,11 +30,17 @@ export function getEstimateGasError(
     chain?: Chain
     docsPath?: string
   },
-) {
-  let cause = getNodeError(err, args as GetNodeErrorParameters)
-  if (cause instanceof UnknownNodeError) cause = err
+): GetEstimateGasErrorReturnType<err> {
+  const cause = (() => {
+    const cause = getNodeError(
+      err as {} as BaseError,
+      args as GetNodeErrorParameters,
+    )
+    if (cause instanceof UnknownNodeError) return err as {} as BaseError
+    return cause
+  })()
   return new EstimateGasExecutionError(cause, {
     docsPath,
     ...args,
-  })
+  }) as GetEstimateGasErrorReturnType<err>
 }

package/utils/errors/getNodeError.ts

@@ -2,17 +2,29 @@ import type { SendTransactionParameters } from '../../actions/wallet/sendTransac
 import { BaseError } from '../../errors/base.js'
 import {
   ExecutionRevertedError,
+  type ExecutionRevertedErrorType,
   FeeCapTooHighError,
+  type FeeCapTooHighErrorType,
   FeeCapTooLowError,
+  type FeeCapTooLowErrorType,
   InsufficientFundsError,
+  type InsufficientFundsErrorType,
   IntrinsicGasTooHighError,
+  type IntrinsicGasTooHighErrorType,
   IntrinsicGasTooLowError,
+  type IntrinsicGasTooLowErrorType,
   NonceMaxValueError,
+  type NonceMaxValueErrorType,
   NonceTooHighError,
+  type NonceTooHighErrorType,
   NonceTooLowError,
+  type NonceTooLowErrorType,
   TipAboveFeeCapError,
+  type TipAboveFeeCapErrorType,
   TransactionTypeNotSupportedError,
+  type TransactionTypeNotSupportedErrorType,
   UnknownNodeError,
+  type UnknownNodeErrorType,
 } from '../../errors/node.js'
 import { RpcRequestError } from '../../errors/request.js'
 import {
@@ -30,7 +42,24 @@ export function containsNodeError(err: BaseError) {
 
 export type GetNodeErrorParameters = Partial<SendTransactionParameters<any>>
 
-export function getNodeError(err: BaseError, args: GetNodeErrorParameters) {
+export type GetNodeErrorReturnType =
+  | ExecutionRevertedErrorType
+  | FeeCapTooHighErrorType
+  | FeeCapTooLowErrorType
+  | NonceTooHighErrorType
+  | NonceTooLowErrorType
+  | NonceMaxValueErrorType
+  | InsufficientFundsErrorType
+  | IntrinsicGasTooHighErrorType
+  | IntrinsicGasTooLowErrorType
+  | TransactionTypeNotSupportedErrorType
+  | TipAboveFeeCapErrorType
+  | UnknownNodeErrorType
+
+export function getNodeError(
+  err: BaseError,
+  args: GetNodeErrorParameters,
+): GetNodeErrorReturnType {
   const message = (err.details || '').toLowerCase()
 
   const executionRevertedError = err.walk(
@@ -40,43 +69,43 @@ export function getNodeError(err: BaseError, args: GetNodeErrorParameters) {
     return new ExecutionRevertedError({
       cause: err,
       message: executionRevertedError.details,
-    })
+    }) as any
   } else if (ExecutionRevertedError.nodeMessage.test(message))
     return new ExecutionRevertedError({
       cause: err,
       message: err.details,
-    })
+    }) as any
   else if (FeeCapTooHighError.nodeMessage.test(message))
     return new FeeCapTooHighError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
-    })
+    }) as any
   else if (FeeCapTooLowError.nodeMessage.test(message))
     return new FeeCapTooLowError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
-    })
+    }) as any
   else if (NonceTooHighError.nodeMessage.test(message))
-    return new NonceTooHighError({ cause: err, nonce: args?.nonce })
+    return new NonceTooHighError({ cause: err, nonce: args?.nonce }) as any
   else if (NonceTooLowError.nodeMessage.test(message))
-    return new NonceTooLowError({ cause: err, nonce: args?.nonce })
+    return new NonceTooLowError({ cause: err, nonce: args?.nonce }) as any
   else if (NonceMaxValueError.nodeMessage.test(message))
-    return new NonceMaxValueError({ cause: err, nonce: args?.nonce })
+    return new NonceMaxValueError({ cause: err, nonce: args?.nonce }) as any
   else if (InsufficientFundsError.nodeMessage.test(message))
-    return new InsufficientFundsError({ cause: err })
+    return new InsufficientFundsError({ cause: err }) as any
   else if (IntrinsicGasTooHighError.nodeMessage.test(message))
-    return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas })
+    return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas }) as any
   else if (IntrinsicGasTooLowError.nodeMessage.test(message))
-    return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas })
+    return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas }) as any
   else if (TransactionTypeNotSupportedError.nodeMessage.test(message))
-    return new TransactionTypeNotSupportedError({ cause: err })
+    return new TransactionTypeNotSupportedError({ cause: err }) as any
   else if (TipAboveFeeCapError.nodeMessage.test(message))
     return new TipAboveFeeCapError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
       maxPriorityFeePerGas: args?.maxPriorityFeePerGas,
-    })
+    }) as any
   return new UnknownNodeError({
     cause: err,
-  })
+  }) as any
 }

package/utils/errors/getTransactionError.ts

@@ -2,10 +2,18 @@ import type { Account } from '../../accounts/types.js'
 import type { SendTransactionParameters } from '../../actions/wallet/sendTransaction.js'
 import type { BaseError } from '../../errors/base.js'
 import { UnknownNodeError } from '../../errors/node.js'
-import { TransactionExecutionError } from '../../errors/transaction.js'
+import {
+  TransactionExecutionError,
+  type TransactionExecutionErrorType,
+} from '../../errors/transaction.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 
-import { type GetNodeErrorParameters, getNodeError } from './getNodeError.js'
+import {
+  type GetNodeErrorParameters,
+  type GetNodeErrorReturnType,
+  getNodeError,
+} from './getNodeError.js'
 
 export type GetTransactionErrorParameters = Omit<
   SendTransactionParameters,
@@ -16,14 +24,25 @@ export type GetTransactionErrorParameters = Omit<
   docsPath?: string
 }
 
-export function getTransactionError(
-  err: BaseError,
+export type GetTransactionErrorReturnType<cause = ErrorType> = Omit<
+  TransactionExecutionErrorType,
+  'cause'
+> & { cause: cause | GetNodeErrorReturnType }
+
+export function getTransactionError<err extends ErrorType<string>>(
+  err: err,
   { docsPath, ...args }: GetTransactionErrorParameters,
-) {
-  let cause = getNodeError(err, args as GetNodeErrorParameters)
-  if (cause instanceof UnknownNodeError) cause = err
+): GetTransactionErrorReturnType<err> {
+  const cause = (() => {
+    const cause = getNodeError(
+      err as {} as BaseError,
+      args as GetNodeErrorParameters,
+    )
+    if (cause instanceof UnknownNodeError) return err as {} as BaseError
+    return cause
+  })()
   return new TransactionExecutionError(cause, {
     docsPath,
     ...args,
-  })
+  }) as GetTransactionErrorReturnType<err>
 }

package/utils/formatters/block.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Block, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
@@ -8,7 +9,7 @@ import type { Hash } from '../../types/misc.js'
 import type { RpcBlock } from '../../types/rpc.js'
 import type { Prettify } from '../../types/utils.js'
 
-import { defineFormatter } from './formatter.js'
+import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 import { type FormattedTransaction, formatTransaction } from './transaction.js'
 
 type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
@@ -39,6 +40,8 @@ export type FormattedBlock<
   transactions: _Transactions
 }
 
+export type FormatBlockErrorType = ErrorType
+
 export function formatBlock(block: Partial<RpcBlock>) {
   const transactions = block.transactions?.map((transaction) => {
     if (typeof transaction === 'string') return transaction
@@ -63,4 +66,6 @@ export function formatBlock(block: Partial<RpcBlock>) {
   } as Block
 }
 
+export type DefineBlockErrorType = DefineFormatterErrorType | ErrorType
+
 export const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock)

package/utils/formatters/extract.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ChainFormatter } from '../../types/chain.js'
 
+export type ExtractErrorType = ErrorType
+
 /**
  * @description Picks out the keys from `value` that exist in the formatter.
  */

package/utils/formatters/feeHistory.ts

@@ -1,6 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { FeeHistory } from '../../types/fee.js'
 import type { RpcFeeHistory } from '../../types/rpc.js'
 
+export type FormatFeeHistoryErrorType = ErrorType
+
 export function formatFeeHistory(feeHistory: RpcFeeHistory): FeeHistory {
   return {
     baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),

package/utils/formatters/formatter.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Assign, Prettify } from '../../types/utils.js'
 
+export type DefineFormatterErrorType = ErrorType
+
 export function defineFormatter<TType extends string, TParameters, TReturnType>(
   type: TType,
   format: (_: TParameters) => TReturnType,

package/utils/formatters/log.ts

@@ -1,6 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Log } from '../../types/log.js'
 import type { RpcLog } from '../../types/rpc.js'
 
+export type FormatLogErrorType = ErrorType
+
 export function formatLog(
   log: Partial<RpcLog>,
   { args, eventName }: { args?: unknown; eventName?: string } = {},

package/utils/formatters/transaction.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
@@ -8,7 +9,7 @@ import type { RpcTransaction } from '../../types/rpc.js'
 import type { Transaction } from '../../types/transaction.js'
 import type { UnionLooseOmit } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
-import { defineFormatter } from './formatter.js'
+import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
 type TransactionPendingDependencies =
   | 'blockHash'
@@ -40,6 +41,8 @@ export const transactionType = {
   '0x2': 'eip1559',
 } as const
 
+export type FormatTransactionErrorType = ErrorType
+
 export function formatTransaction(transaction: Partial<RpcTransaction>) {
   const transaction_ = {
     ...transaction,
@@ -79,6 +82,8 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
   return transaction_ as Transaction
 }
 
+export type DefineTransactionErrorType = DefineFormatterErrorType | ErrorType
+
 export const defineTransaction = /*#__PURE__*/ defineFormatter(
   'transaction',
   formatTransaction,

package/utils/formatters/transactionReceipt.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   Chain,
   ExtractChainFormatterReturnType,
@@ -6,7 +7,7 @@ import type { RpcTransactionReceipt } from '../../types/rpc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 
-import { defineFormatter } from './formatter.js'
+import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
@@ -23,6 +24,8 @@ const statuses = {
   '0x1': 'success',
 } as const
 
+export type FormatTransactionReceiptErrorType = ErrorType
+
 export function formatTransactionReceipt(
   transactionReceipt: Partial<RpcTransactionReceipt>,
 ) {
@@ -61,6 +64,10 @@ export function formatTransactionReceipt(
   } as TransactionReceipt
 }
 
+export type DefineTransactionReceiptErrorType =
+  | DefineFormatterErrorType
+  | ErrorType
+
 export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter(
   'transactionReceipt',
   formatTransactionReceipt,

package/utils/formatters/transactionRequest.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type {
   Chain,
   ExtractChainFormatterParameters,
@@ -5,7 +6,7 @@ import type {
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
 import { numberToHex } from '../encoding/toHex.js'
-import { defineFormatter } from './formatter.js'
+import { type DefineFormatterErrorType, defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
   TChain extends Chain | undefined = Chain | undefined,
@@ -21,6 +22,8 @@ export const rpcTransactionType = {
   eip1559: '0x2',
 } as const
 
+export type FormatTransactionRequestErrorType = ErrorType
+
 export function formatTransactionRequest(
   transactionRequest: Partial<TransactionRequest>,
 ) {
@@ -57,6 +60,10 @@ export function formatTransactionRequest(
   } as RpcTransactionRequest
 }
 
+export type DefineTransactionRequestErrorType =
+  | DefineFormatterErrorType
+  | ErrorType
+
 export const defineTransactionRequest = /*#__PURE__*/ defineFormatter(
   'transactionRequest',
   formatTransactionRequest,

package/utils/hash/getEventSelector.ts

@@ -1,10 +1,16 @@
 import type { AbiEvent } from 'abitype'
 
-import { toBytes } from '../encoding/toBytes.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
 import { getEventSignature } from './getEventSignature.js'
-import { keccak256 } from './keccak256.js'
+import { type Keccak256ErrorType, keccak256 } from './keccak256.js'
 
 const hash = (value: string) => keccak256(toBytes(value))
 
+export type GetEventSelectorErrorType =
+  | Keccak256ErrorType
+  | ToBytesErrorType
+  | ErrorType
+
 export const getEventSelector = (fn: string | AbiEvent) =>
   hash(getEventSignature(fn))

package/utils/hash/getEventSignature.ts

@@ -1,6 +1,14 @@
 import type { AbiEvent, AbiFunction } from 'abitype'
 
-import { getFunctionSignature } from './getFunctionSignature.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type GetFunctionSignatureErrorType,
+  getFunctionSignature,
+} from './getFunctionSignature.js'
+
+export type GetEventSignatureErrorType =
+  | GetFunctionSignatureErrorType
+  | ErrorType
 
 export const getEventSignature = (fn: string | AbiEvent) => {
   return getFunctionSignature(fn as {} as AbiFunction)

package/utils/hash/getFunctionSelector.ts

@@ -1,11 +1,22 @@
 import type { AbiFunction } from 'abitype'
-import { slice } from '../data/slice.js'
 
-import { toBytes } from '../encoding/toBytes.js'
-import { getFunctionSignature } from './getFunctionSignature.js'
-import { keccak256 } from './keccak256.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type SliceErrorType, slice } from '../data/slice.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import {
+  type GetFunctionSignatureErrorType,
+  getFunctionSignature,
+} from './getFunctionSignature.js'
+import { type Keccak256ErrorType, keccak256 } from './keccak256.js'
 
 const hash = (value: string) => keccak256(toBytes(value))
 
+export type GetFunctionSelectorErrorType =
+  | GetFunctionSignatureErrorType
+  | Keccak256ErrorType
+  | SliceErrorType
+  | ToBytesErrorType
+  | ErrorType
+
 export const getFunctionSelector = (fn: string | AbiFunction) =>
   slice(hash(getFunctionSignature(fn)), 0, 4)

package/utils/hash/getFunctionSignature.ts

@@ -1,11 +1,23 @@
 import type { AbiFunction } from 'abitype'
 
-import { formatAbiItem } from '../abi/formatAbiItem.js'
+import type { ErrorType } from '../../errors/utils.js'
 import {
+  type FormatAbiItemErrorType,
+  formatAbiItem,
+} from '../abi/formatAbiItem.js'
+import {
+  type ExtractFunctionNameErrorType,
+  type ExtractFunctionParamsErrorType,
   extractFunctionName,
   extractFunctionParams,
 } from '../contract/extractFunctionParts.js'
 
+export type GetFunctionSignatureErrorType =
+  | ExtractFunctionNameErrorType
+  | ExtractFunctionParamsErrorType
+  | FormatAbiItemErrorType
+  | ErrorType
+
 export const getFunctionSignature = (fn: string | AbiFunction) => {
   if (typeof fn === 'string') {
     const name = extractFunctionName(fn)

package/utils/hash/hashFunction.ts

@@ -1,16 +1,35 @@
 import type { AbiEvent, AbiFunction } from 'abitype'
-import { formatAbiItem } from '../abi/formatAbiItem.js'
-import { toBytes } from '../encoding/toBytes.js'
+import {
+  type FormatAbiItemErrorType,
+  formatAbiItem,
+} from '../abi/formatAbiItem.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
 
-import { getFunctionSignature } from './getFunctionSignature.js'
-import { keccak256 } from './keccak256.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type GetFunctionSignatureErrorType,
+  getFunctionSignature,
+} from './getFunctionSignature.js'
+import { type Keccak256ErrorType, keccak256 } from './keccak256.js'
 
 const hash = (value: string) => keccak256(toBytes(value))
 
+export type HashFunctionErrorType =
+  | Keccak256ErrorType
+  | ToBytesErrorType
+  | GetFunctionSignatureErrorType
+  | ErrorType
+
 export function hashFunction(def: string) {
   return hash(getFunctionSignature(def))
 }
 
+export type HashAbiItemErrorType =
+  | Keccak256ErrorType
+  | ToBytesErrorType
+  | FormatAbiItemErrorType
+  | ErrorType
+
 export function hashAbiItem(abiItem: AbiFunction | AbiEvent) {
   return hash(formatAbiItem(abiItem))
 }