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

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>,
   {

package/utils/promise/withTimeout.ts

@@ -1,3 +1,7 @@
+import type { ErrorType } from '../../errors/utils.js'
+
+export type WithTimeoutErrorType = ErrorType
+
 export function withTimeout<TData>(
   fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
   {

package/utils/rpc.ts

@@ -4,12 +4,20 @@ import type { MessageEvent } from 'isomorphic-ws'
 
 import {
   HttpRequestError,
+  type HttpRequestErrorType,
   TimeoutError,
+  type TimeoutErrorType,
   WebSocketRequestError,
 } from '../errors/request.js'
-
-import { createBatchScheduler } from './promise/createBatchScheduler.js'
-import { withTimeout } from './promise/withTimeout.js'
+import type { ErrorType } from '../errors/utils.js'
+import {
+  type CreateBatchSchedulerErrorType,
+  createBatchScheduler,
+} from './promise/createBatchScheduler.js'
+import {
+  type WithTimeoutErrorType,
+  withTimeout,
+} from './promise/withTimeout.js'
 import { stringify } from './stringify.js'
 
 let id = 0
@@ -70,6 +78,12 @@ export type HttpReturnType<
   TBody extends RpcRequest | RpcRequest[] = RpcRequest,
 > = TBody extends RpcRequest[] ? RpcResponse[] : RpcResponse
 
+export type HttpErrorType =
+  | HttpRequestErrorType
+  | TimeoutErrorType
+  | WithTimeoutErrorType
+  | ErrorType
+
 async function http<TBody extends RpcRequest | RpcRequest[]>(
   url: string,
   { body, fetchOptions = {}, timeout = 10_000 }: HttpOptions<TBody>,
@@ -146,6 +160,8 @@ export type Socket = WebSocket & {
   subscriptions: CallbackMap
 }
 
+export type GetSocketErrorType = CreateBatchSchedulerErrorType | ErrorType
+
 export const socketsCache = /*#__PURE__*/ new Map<string, Socket>()
 
 export async function getSocket(url: string) {
@@ -219,6 +235,8 @@ export type WebSocketOptions = {
 
 export type WebSocketReturnType = Socket
 
+export type WebSocketErrorType = WebSocketRequestError | ErrorType
+
 function webSocket(
   socket: Socket,
   { body, onResponse }: WebSocketOptions,
@@ -269,6 +287,12 @@ export type WebSocketAsyncOptions = {
 
 export type WebSocketAsyncReturnType = RpcResponse
 
+export type WebSocketAsyncErrorType =
+  | WebSocketErrorType
+  | TimeoutErrorType
+  | WithTimeoutErrorType
+  | ErrorType
+
 async function webSocketAsync(
   socket: Socket,
   { body, timeout = 10_000 }: WebSocketAsyncOptions,