viem 1.13.2 → 1.15.0

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))
 }

package/utils/hash/isHash.ts

@@ -1,6 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { size } from '../data/size.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type SizeErrorType, size } from '../data/size.js'
+
+export type IsHashErrorType = IsHexErrorType | SizeErrorType | ErrorType
 
 export function isHash(hash: string): hash is Hex {
   return isHex(hash) && size(hash) === 32

package/utils/hash/keccak256.ts

@@ -1,9 +1,10 @@
 import { keccak_256 } from '@noble/hashes/sha3'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { toBytes } from '../encoding/toBytes.js'
-import { toHex } from '../encoding/toHex.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import { type ToHexErrorType, toHex } from '../encoding/toHex.js'
 
 type To = 'hex' | 'bytes'
 
@@ -11,6 +12,12 @@ export type Keccak256Hash<TTo extends To> =
   | (TTo extends 'bytes' ? ByteArray : never)
   | (TTo extends 'hex' ? Hex : never)
 
+export type Keccak256ErrorType =
+  | IsHexErrorType
+  | ToBytesErrorType
+  | ToHexErrorType
+  | ErrorType
+
 export function keccak256<TTo extends To = 'hex'>(
   value: Hex | ByteArray,
   to_?: TTo,

package/utils/index.ts

@@ -1,6 +1,13 @@
-export { buildRequest } from './buildRequest.js'
+export {
+  type IsDeterministicErrorType,
+  type RequestErrorType,
+  isDeterministicError,
+  buildRequest,
+} from './buildRequest.js'
 
 export {
+  type CcipFetchErrorType,
+  type OffchainLookupErrorType,
   ccipFetch,
   offchainLookup,
   offchainLookupAbiItem,
@@ -9,6 +16,8 @@ export {
 
 export {
   type AssertCurrentChainParameters,
+  type AssertCurrentChainErrorType,
+  type GetChainContractAddressErrorType,
   assertCurrentChain,
   defineChain,
   getChainContractAddress,
@@ -16,68 +25,90 @@ export {
 export { arrayRegex, bytesRegex, integerRegex } from './regex.js'
 
 export {
+  type GetSocketErrorType,
+  type HttpErrorType,
   type HttpOptions,
   type HttpReturnType,
   type RpcRequest,
   type RpcResponse,
   type Socket,
+  type WebSocketAsyncErrorType,
   type WebSocketAsyncOptions,
   type WebSocketAsyncReturnType,
+  type WebSocketErrorType,
   type WebSocketOptions,
   type WebSocketReturnType,
   getSocket,
   rpc,
 } from './rpc.js'
-export { stringify } from './stringify.js'
-export { validateTypedData } from './typedData.js'
+export { type StringifyErrorType, stringify } from './stringify.js'
+export {
+  type DomainSeparatorErrorType,
+  validateTypedData,
+} from './typedData.js'
 export {
+  type DecodeAbiParametersErrorType,
   type DecodeAbiParametersReturnType,
   decodeAbiParameters,
 } from './abi/decodeAbiParameters.js'
 export {
+  type DecodeErrorResultErrorType,
   type DecodeErrorResultParameters,
   type DecodeErrorResultReturnType,
   decodeErrorResult,
 } from './abi/decodeErrorResult.js'
 export {
+  type DecodeEventLogErrorType,
   type DecodeEventLogParameters,
   type DecodeEventLogReturnType,
   decodeEventLog,
 } from './abi/decodeEventLog.js'
 export {
+  type DecodeFunctionDataErrorType,
   type DecodeFunctionDataParameters,
   decodeFunctionData,
 } from './abi/decodeFunctionData.js'
 export {
+  type DecodeFunctionResultErrorType,
   type DecodeFunctionResultParameters,
   type DecodeFunctionResultReturnType,
   decodeFunctionResult,
 } from './abi/decodeFunctionResult.js'
 export {
+  type EncodeAbiParametersErrorType,
   type EncodeAbiParametersReturnType,
   encodeAbiParameters,
 } from './abi/encodeAbiParameters.js'
 export {
+  type EncodeDeployDataErrorType,
   type EncodeDeployDataParameters,
   encodeDeployData,
 } from './abi/encodeDeployData.js'
 export {
+  type EncodeErrorResultErrorType,
   type EncodeErrorResultParameters,
   encodeErrorResult,
 } from './abi/encodeErrorResult.js'
 export {
+  type EncodeArgErrorType,
   type EncodeEventTopicsParameters,
   encodeEventTopics,
 } from './abi/encodeEventTopics.js'
 export {
+  type EncodeFunctionDataErrorType,
   type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from './abi/encodeFunctionData.js'
 export {
+  type EncodeFunctionResultErrorType,
   type EncodeFunctionResultParameters,
   encodeFunctionResult,
 } from './abi/encodeFunctionResult.js'
-export { type GetAbiItemParameters, getAbiItem } from './abi/getAbiItem.js'
+export {
+  type GetAbiItemErrorType,
+  type GetAbiItemParameters,
+  getAbiItem,
+} from './abi/getAbiItem.js'
 export {
   type ParseAbi,
   type ParseAbiItem,
@@ -88,59 +119,133 @@ export {
   parseAbiParameter,
   parseAbiParameters,
 } from 'abitype'
-export { encodePacked } from './abi/encodePacked.js'
-export { formatAbiItemWithArgs } from './abi/formatAbiItemWithArgs.js'
-export { formatAbiItem, formatAbiParams } from './abi/formatAbiItem.js'
-export { parseAccount } from '../accounts/utils/parseAccount.js'
-export { publicKeyToAddress } from '../accounts/utils/publicKeyToAddress.js'
+export { type EncodePackedErrorType, encodePacked } from './abi/encodePacked.js'
+export {
+  type FormatAbiItemWithArgsErrorType,
+  formatAbiItemWithArgs,
+} from './abi/formatAbiItemWithArgs.js'
+export {
+  type FormatAbiItemErrorType,
+  type FormatAbiParamErrorType,
+  type FormatAbiParamsErrorType,
+  formatAbiItem,
+  formatAbiParams,
+} from './abi/formatAbiItem.js'
+export {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../accounts/utils/parseAccount.js'
+export {
+  type PublicKeyToAddressErrorType,
+  publicKeyToAddress,
+} from '../accounts/utils/publicKeyToAddress.js'
 export {
   type GetContractAddressOptions,
+  type GetCreate2AddressErrorType,
   type GetCreate2AddressOptions,
+  type GetCreateAddressErrorType,
   type GetCreateAddressOptions,
   getContractAddress,
   getCreateAddress,
   getCreate2Address,
 } from './address/getContractAddress.js'
-export { getAddress } from './address/getAddress.js'
-export { isAddress } from './address/isAddress.js'
-export { isAddressEqual } from './address/isAddressEqual.js'
 export {
+  type ChecksumAddressErrorType,
+  getAddress,
+} from './address/getAddress.js'
+export { type IsAddressErrorType, isAddress } from './address/isAddress.js'
+export {
+  type IsAddressEqualErrorType,
+  isAddressEqual,
+} from './address/isAddressEqual.js'
+export {
+  type ExtractFunctionNameErrorType,
+  type ExtractFunctionParamsErrorType,
+  type ExtractFunctionPartsErrorType,
+  type ExtractFunctionTypeErrorType,
   extractFunctionName,
   extractFunctionParams,
   extractFunctionType,
   extractFunctionParts,
 } from './contract/extractFunctionParts.js'
-export { concat, concatBytes, concatHex } from './data/concat.js'
-export { isBytes } from './data/isBytes.js'
-export { isHex } from './data/isHex.js'
-export { pad, padBytes, padHex } from './data/pad.js'
-export { size } from './data/size.js'
-export { slice, sliceBytes, sliceHex } from './data/slice.js'
-export { trim } from './data/trim.js'
 export {
+  type ConcatBytesErrorType,
+  type ConcatErrorType,
+  type ConcatHexErrorType,
+  concat,
+  concatBytes,
+  concatHex,
+} from './data/concat.js'
+export { type IsBytesErrorType, isBytes } from './data/isBytes.js'
+export { type IsHexErrorType, isHex } from './data/isHex.js'
+export {
+  type PadBytesErrorType,
+  type PadErrorType,
+  type PadHexErrorType,
+  pad,
+  padBytes,
+  padHex,
+} from './data/pad.js'
+export { type SizeErrorType, size } from './data/size.js'
+export {
+  type AssertEndOffsetErrorType,
+  type AssertStartOffsetErrorType,
+  type SliceBytesErrorType,
+  type SliceErrorType,
+  type SliceHexErrorType,
+  type SliceReturnType,
+  slice,
+  sliceBytes,
+  sliceHex,
+} from './data/slice.js'
+export { type TrimErrorType, type TrimReturnType, trim } from './data/trim.js'
+export {
+  type DefineBlockErrorType,
   type FormattedBlock,
+  type FormatBlockErrorType,
   defineBlock,
   formatBlock,
 } from './formatters/block.js'
 export {
+  type DefineTransactionErrorType,
   type FormattedTransaction,
+  type FormatTransactionErrorType,
   defineTransaction,
   formatTransaction,
   transactionType,
 } from './formatters/transaction.js'
-export { formatLog } from './formatters/log.js'
+export { type FormatLogErrorType, formatLog } from './formatters/log.js'
 export {
+  type DefineTransactionReceiptErrorType,
+  type FormatTransactionReceiptErrorType,
   type FormattedTransactionReceipt,
   defineTransactionReceipt,
 } from './formatters/transactionReceipt.js'
 export {
+  type DefineTransactionRequestErrorType,
+  type FormatTransactionRequestErrorType,
   type FormattedTransactionRequest,
   defineTransactionRequest,
   formatTransactionRequest,
 } from './formatters/transactionRequest.js'
-export { extract } from './formatters/extract.js'
-export { type ToRlpReturnType, toRlp } from './encoding/toRlp.js'
-export {
+export { type ExtractErrorType, extract } from './formatters/extract.js'
+export {
+  type BytesToRlpErrorType,
+  type HexToRlpErrorType,
+  type ToRlpErrorType,
+  type ToRlpReturnType,
+  toRlp,
+} from './encoding/toRlp.js'
+export {
+  type BoolToBytesErrorType,
+  type BoolToBytesOpts,
+  type HexToBytesErrorType,
+  type HexToBytesOpts,
+  type NumberToBytesErrorType,
+  type StringToBytesErrorType,
+  type StringToBytesOpts,
+  type ToBytesErrorType,
+  type ToBytesParameters,
   boolToBytes,
   toBytes,
   hexToBytes,
@@ -148,6 +253,16 @@ export {
   stringToBytes,
 } from './encoding/toBytes.js'
 export {
+  type BoolToHexErrorType,
+  type BoolToHexOpts,
+  type BytesToHexErrorType,
+  type BytesToHexOpts,
+  type NumberToHexErrorType,
+  type NumberToHexOpts,
+  type StringToHexErrorType,
+  type StringToHexOpts,
+  type ToHexErrorType,
+  type ToHexParameters,
   boolToHex,
   bytesToHex,
   toHex,
@@ -155,93 +270,174 @@ export {
   stringToHex,
 } from './encoding/toHex.js'
 export {
-  bytesToBigint,
+  type BytesToBigIntErrorType,
+  type BytesToBigIntOpts,
+  type BytesToBoolErrorType,
+  type BytesToBoolOpts,
+  type BytesToNumberErrorType,
+  type BytesToNumberOpts,
+  type BytesToStringErrorType,
+  type BytesToStringOpts,
+  type FromBytesErrorType,
+  type FromBytesParameters,
+  type FromBytesReturnType,
+  bytesToBigInt,
+  /** @deprecated – use `bytesToBigInt` */
+  bytesToBigInt as bytesToBigint,
   bytesToBool,
   bytesToNumber,
   bytesToString,
   fromBytes,
 } from './encoding/fromBytes.js'
 export {
+  type AssertSizeErrorType,
+  type FromHexErrorType,
+  type FromHexParameters,
+  type FromHexReturnType,
+  type HexToBigIntErrorType,
+  type HexToBigIntOpts,
+  type HexToBoolErrorType,
+  type HexToBoolOpts,
+  type HexToNumberErrorType,
+  type HexToNumberOpts,
+  type HexToStringErrorType,
+  type HexToStringOpts,
   fromHex,
   hexToBool,
   hexToBigInt,
   hexToNumber,
   hexToString,
 } from './encoding/fromHex.js'
-export { fromRlp } from './encoding/fromRlp.js'
-export { containsNodeError, getNodeError } from './errors/getNodeError.js'
-export { getCallError } from './errors/getCallError.js'
-export { getContractError } from './errors/getContractError.js'
-export { getEstimateGasError } from './errors/getEstimateGasError.js'
-export { getTransactionError } from './errors/getTransactionError.js'
-export { defineFormatter } from './formatters/formatter.js'
-export { getEventSelector } from './hash/getEventSelector.js'
-export { getFunctionSelector } from './hash/getFunctionSelector.js'
-export { isHash } from './hash/isHash.js'
-export { keccak256 } from './hash/keccak256.js'
 export {
+  type FromRlpErrorType,
+  fromRlp,
+} from './encoding/fromRlp.js'
+export {
+  type GetNodeErrorParameters,
+  type GetNodeErrorReturnType,
+  containsNodeError,
+  getNodeError,
+} from './errors/getNodeError.js'
+export {
+  type GetCallErrorReturnType,
+  getCallError,
+} from './errors/getCallError.js'
+export {
+  type GetContractErrorReturnType,
+  getContractError,
+} from './errors/getContractError.js'
+export {
+  type GetEstimateGasErrorReturnType,
+  getEstimateGasError,
+} from './errors/getEstimateGasError.js'
+export {
+  type GetTransactionErrorParameters,
+  type GetTransactionErrorReturnType,
+  getTransactionError,
+} from './errors/getTransactionError.js'
+export {
+  type DefineFormatterErrorType,
+  defineFormatter,
+} from './formatters/formatter.js'
+export {
+  type GetEventSelectorErrorType,
+  getEventSelector,
+} from './hash/getEventSelector.js'
+export {
+  type GetFunctionSelectorErrorType,
+  getFunctionSelector,
+} from './hash/getFunctionSelector.js'
+export { type IsHashErrorType, isHash } from './hash/isHash.js'
+export { type Keccak256ErrorType, keccak256 } from './hash/keccak256.js'
+export {
+  type HashDomainErrorType,
   type HashTypedDataParameters,
   type HashTypedDataReturnType,
   hashTypedData,
 } from './signature/hashTypedData.js'
 export {
+  type RecoverAddressErrorType,
   type RecoverAddressParameters,
   type RecoverAddressReturnType,
   recoverAddress,
 } from './signature/recoverAddress.js'
 export {
+  type RecoverMessageAddressErrorType,
   type RecoverMessageAddressParameters,
   type RecoverMessageAddressReturnType,
   recoverMessageAddress,
 } from './signature/recoverMessageAddress.js'
 export {
+  type RecoverPublicKeyErrorType,
   type RecoverPublicKeyParameters,
   type RecoverPublicKeyReturnType,
   recoverPublicKey,
 } from './signature/recoverPublicKey.js'
 export {
+  type RecoverTypedDataAddressErrorType,
   type RecoverTypedDataAddressParameters,
   type RecoverTypedDataAddressReturnType,
   recoverTypedDataAddress,
 } from './signature/recoverTypedDataAddress.js'
 export {
+  type VerifyMessageErrorType,
   type VerifyMessageParameters,
   type VerifyMessageReturnType,
   verifyMessage,
 } from './signature/verifyMessage.js'
 export {
+  type VerifyTypedDataErrorType,
   type VerifyTypedDataParameters,
   type VerifyTypedDataReturnType,
   verifyTypedData,
 } from './signature/verifyTypedData.js'
-export { hashMessage } from './signature/hashMessage.js'
 export {
+  type HashMessage,
+  type HashMessageErrorType,
+  hashMessage,
+} from './signature/hashMessage.js'
+export {
+  type GetSerializedTransactionTypeErrorType,
   type GetSerializedTransactionType,
   getSerializedTransactionType,
 } from './transaction/getSerializedTransactionType.js'
 export {
+  type GetTransationTypeErrorType,
   type GetTransactionType,
   getTransactionType,
 } from './transaction/getTransactionType.js'
-export { assertRequest } from './transaction/assertRequest.js'
 export {
+  type AssertRequestErrorType,
+  assertRequest,
+} from './transaction/assertRequest.js'
+export {
+  type AssertTransactionEIP1559ErrorType,
+  type AssertTransactionEIP2930ErrorType,
+  type AssertTransactionLegacyErrorType,
   assertTransactionEIP1559,
   assertTransactionEIP2930,
   assertTransactionLegacy,
 } from './transaction/assertTransaction.js'
-export { parseTransaction } from './transaction/parseTransaction.js'
+export {
+  type ParseTransactionErrorType,
+  parseTransaction,
+} from './transaction/parseTransaction.js'
 export {
   /** @deprecated import `prepareTransactionRequest` from `viem/actions` instead. */
   prepareTransactionRequest,
 } from '../actions/wallet/prepareTransactionRequest.js'
 export {
   serializeTransaction,
+  type SerializeTransactionErrorType,
   type SerializeTransactionFn,
 } from './transaction/serializeTransaction.js'
-export { serializeAccessList } from './transaction/serializeAccessList.js'
-export { formatEther } from './unit/formatEther.js'
-export { formatGwei } from './unit/formatGwei.js'
-export { formatUnits } from './unit/formatUnits.js'
-export { parseUnits } from './unit/parseUnits.js'
-export { parseEther } from './unit/parseEther.js'
-export { parseGwei } from './unit/parseGwei.js'
+export {
+  type SerializeAccessListErrorType,
+  serializeAccessList,
+} from './transaction/serializeAccessList.js'
+export { type FormatEtherErrorType, formatEther } from './unit/formatEther.js'
+export { type FormatGweiErrorType, formatGwei } from './unit/formatGwei.js'
+export { type FormatUnitsErrorType, formatUnits } from './unit/formatUnits.js'
+export { type ParseUnitsErrorType, parseUnits } from './unit/parseUnits.js'
+export { type ParseEtherErrorType, parseEther } from './unit/parseEther.js'
+export { type ParseGweiErrorType, parseGwei } from './unit/parseGwei.js'

package/utils/observe.ts

@@ -1,8 +1,11 @@
+import type { ErrorType } from '../errors/utils.js'
 import type { MaybePromise } from '../types/utils.js'
 
 type Callback = ((...args: any[]) => any) | undefined
 type Callbacks = Record<string, Callback>
 
+export type ObserveErrorType = ErrorType
+
 export const listenersCache = /*#__PURE__*/ new Map<
   string,
   { id: number; fns: Callbacks }[]

package/utils/poll.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../errors/utils.js'
 import { wait } from './wait.js'
 
 type PollOptions<TData> = {
@@ -9,6 +10,8 @@ type PollOptions<TData> = {
   interval: number
 }
 
+export type PollErrorType = ErrorType
+
 /**
  * @description Polls a function at a specified interval.
  */

package/utils/promise/createBatchScheduler.ts

@@ -1,3 +1,5 @@
+import type { ErrorType } from '../../errors/utils.js'
+
 type Resolved<TReturnType extends readonly unknown[] = any> = [
   result: TReturnType[number],
   results: TReturnType,
@@ -19,6 +21,7 @@ export type CreateBatchSchedulerArguments<
   shouldSplitBatch?: (args: TParameters[]) => boolean
   wait?: number
 }
+
 export type CreateBatchSchedulerReturnType<
   TParameters = unknown,
   TReturnType extends readonly unknown[] = readonly unknown[],
@@ -29,6 +32,8 @@ export type CreateBatchSchedulerReturnType<
     : (args: TParameters) => Promise<Resolved<TReturnType>>
 }
 
+export type CreateBatchSchedulerErrorType = ErrorType
+
 const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
 export function createBatchScheduler<

package/utils/promise/withCache.ts

@@ -1,6 +1,10 @@
+import type { ErrorType } from '../../errors/utils.js'
+
 export const promiseCache = /*#__PURE__*/ new Map()
 export const responseCache = /*#__PURE__*/ new Map()
 
+export type GetCacheErrorType = ErrorType
+
 export function getCache<TData>(cacheKey: string) {
   const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
     clear: () => cache.delete(cacheKey),

package/utils/promise/withRetry.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import { wait } from '../wait.js'
 
+export type WithRetryErrorType = ErrorType
+
 export function withRetry<TData>(
   fn: () => Promise<TData>,
   {