viem 2.0.0-alpha.9 → 2.0.0-beta.0

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,
@@ -8,76 +15,109 @@ export {
 } from './ccip.js'
 
 export {
+  type AssertCurrentChainErrorType,
   type AssertCurrentChainParameters,
   assertCurrentChain,
-  defineChain,
+} from './chain/assertCurrentChain.js'
+export { defineChain } from './chain/defineChain.js'
+export {
+  type ExtractChainErrorType,
+  type ExtractChainParameters,
+  type ExtractChainReturnType,
+  extractChain,
+} from './chain/extractChain.js'
+export {
+  type GetChainContractAddressErrorType,
   getChainContractAddress,
-} from './chain.js'
+} from './chain/getChainContractAddress.js'
+
 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 +128,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 +262,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 +279,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,
@@ -10,6 +12,11 @@ type PendingPromise<TReturnType extends readonly unknown[] = any> = {
 
 type SchedulerItem = { args: unknown; pendingPromise: PendingPromise }
 
+type BatchResultsCompareFn<TResult = unknown> = (
+  a: TResult,
+  b: TResult,
+) => number
+
 export type CreateBatchSchedulerArguments<
   TParameters = unknown,
   TReturnType extends readonly unknown[] = readonly unknown[],
@@ -18,7 +25,9 @@ export type CreateBatchSchedulerArguments<
   id: number | string
   shouldSplitBatch?: (args: TParameters[]) => boolean
   wait?: number
+  sort?: BatchResultsCompareFn<TReturnType[number]>
 }
+
 export type CreateBatchSchedulerReturnType<
   TParameters = unknown,
   TReturnType extends readonly unknown[] = readonly unknown[],
@@ -29,6 +38,8 @@ export type CreateBatchSchedulerReturnType<
     : (args: TParameters) => Promise<Resolved<TReturnType>>
 }
 
+export type CreateBatchSchedulerErrorType = ErrorType
+
 const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
 export function createBatchScheduler<
@@ -39,6 +50,7 @@ export function createBatchScheduler<
   id,
   shouldSplitBatch,
   wait = 0,
+  sort,
 }: CreateBatchSchedulerArguments<
   TParameters,
   TReturnType
@@ -53,6 +65,7 @@ export function createBatchScheduler<
 
     fn(args as TParameters[])
       .then((data) => {
+        if (sort && Array.isArray(data)) data.sort(sort)
         scheduler.forEach(({ pendingPromise }, i) =>
           pendingPromise.resolve?.([data[i], data]),
         )

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,12 +1,16 @@
+import type { ErrorType } from '../../errors/utils.js'
+
+export type WithTimeoutErrorType = ErrorType
+
 export function withTimeout<TData>(
   fn: ({ signal }: { signal?: AbortController['signal'] }) => Promise<TData>,
   {
-    errorInstance,
+    errorInstance = new Error('timed out'),
     timeout,
     signal,
   }: {
     // The error instance to throw when the timeout is reached.
-    errorInstance: Error
+    errorInstance?: Error
     // The timeout (in ms).
     timeout: number
     // Whether or not the timeout should use an abort signal.