viem 1.13.2 → 1.14.0

package/utils/address/getContractAddress.ts

@@ -1,15 +1,16 @@
 import type { Address } from 'abitype'
 
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { concat } from '../data/concat.js'
-import { isBytes } from '../data/isBytes.js'
-import { pad } from '../data/pad.js'
-import { slice } from '../data/slice.js'
-import { toBytes } from '../encoding/toBytes.js'
-import { toRlp } from '../encoding/toRlp.js'
-import { keccak256 } from '../hash/keccak256.js'
+import { type ConcatErrorType, concat } from '../data/concat.js'
+import { type IsBytesErrorType, isBytes } from '../data/isBytes.js'
+import { type PadErrorType, pad } from '../data/pad.js'
+import { type SliceErrorType, slice } from '../data/slice.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import { type ToRlpErrorType, toRlp } from '../encoding/toRlp.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 
-import { getAddress } from './getAddress.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type GetAddressErrorType, getAddress } from './getAddress.js'
 
 export type GetCreateAddressOptions = {
   from: Address
@@ -39,6 +40,13 @@ export function getContractAddress(opts: GetContractAddressOptions) {
   return getCreateAddress(opts)
 }
 
+export type GetCreateAddressErrorType =
+  | Keccak256ErrorType
+  | GetAddressErrorType
+  | ToBytesErrorType
+  | ToRlpErrorType
+  | ErrorType
+
 export function getCreateAddress(opts: GetCreateAddressOptions) {
   const from = toBytes(getAddress(opts.from))
 
@@ -50,6 +58,17 @@ export function getCreateAddress(opts: GetCreateAddressOptions) {
   )
 }
 
+export type GetCreate2AddressErrorType =
+  | ConcatErrorType
+  | Keccak256ErrorType
+  | GetAddressErrorType
+  | IsBytesErrorType
+  | PadErrorType
+  | SliceErrorType
+  | ToBytesErrorType
+  | ToRlpErrorType
+  | ErrorType
+
 export function getCreate2Address(opts: GetCreate2AddressOptions) {
   const from = toBytes(getAddress(opts.from))
   const salt = pad(isBytes(opts.salt) ? opts.salt : toBytes(opts.salt), {

package/utils/address/isAddress.ts

@@ -1,7 +1,10 @@
 import type { Address } from 'abitype'
+import type { ErrorType } from '../../errors/utils.js'
 
 const addressRegex = /^0x[a-fA-F0-9]{40}$/
 
+export type IsAddressErrorType = ErrorType
+
 export function isAddress(address: string): address is Address {
   return addressRegex.test(address)
 }

package/utils/address/isAddressEqual.ts

@@ -1,9 +1,15 @@
 import type { Address } from 'abitype'
 
-import { InvalidAddressError } from '../../errors/address.js'
-
+import {
+  InvalidAddressError,
+  type InvalidAddressErrorType,
+} from '../../errors/address.js'
+import type { ErrorType } from '../../errors/utils.js'
 import { isAddress } from './isAddress.js'
 
+export type IsAddressEqualReturnType = boolean
+export type IsAddressEqualErrorType = InvalidAddressErrorType | ErrorType
+
 export function isAddressEqual(a: Address, b: Address) {
   if (!isAddress(a)) throw new InvalidAddressError({ address: a })
   if (!isAddress(b)) throw new InvalidAddressError({ address: b })

package/utils/buildRequest.ts

@@ -1,31 +1,61 @@
 import { BaseError } from '../errors/base.js'
-import { HttpRequestError } from '../errors/request.js'
+import {
+  HttpRequestError,
+  type HttpRequestErrorType,
+  type RpcRequestErrorType,
+  type TimeoutErrorType,
+  type WebSocketRequestErrorType,
+} from '../errors/request.js'
 import {
   ChainDisconnectedError,
+  type ChainDisconnectedErrorType,
   InternalRpcError,
+  type InternalRpcErrorType,
   InvalidInputRpcError,
+  type InvalidInputRpcErrorType,
   InvalidParamsRpcError,
+  type InvalidParamsRpcErrorType,
   InvalidRequestRpcError,
+  type InvalidRequestRpcErrorType,
   JsonRpcVersionUnsupportedError,
+  type JsonRpcVersionUnsupportedErrorType,
   LimitExceededRpcError,
+  type LimitExceededRpcErrorType,
   MethodNotFoundRpcError,
+  type MethodNotFoundRpcErrorType,
   MethodNotSupportedRpcError,
+  type MethodNotSupportedRpcErrorType,
   ParseRpcError,
+  type ParseRpcErrorType,
   ProviderDisconnectedError,
+  type ProviderDisconnectedErrorType,
   type ProviderRpcErrorCode,
   ResourceNotFoundRpcError,
+  type ResourceNotFoundRpcErrorType,
   ResourceUnavailableRpcError,
+  type ResourceUnavailableRpcErrorType,
   type RpcError,
   type RpcErrorCode,
+  type RpcErrorType,
   SwitchChainError,
+  type SwitchChainErrorType,
   TransactionRejectedRpcError,
+  type TransactionRejectedRpcErrorType,
   UnauthorizedProviderError,
+  type UnauthorizedProviderErrorType,
   UnknownRpcError,
+  type UnknownRpcErrorType,
   UnsupportedProviderMethodError,
+  type UnsupportedProviderMethodErrorType,
   UserRejectedRequestError,
+  type UserRejectedRequestErrorType,
 } from '../errors/rpc.js'
+import type { ErrorType } from '../errors/utils.js'
+import type { CreateBatchSchedulerErrorType } from './promise/createBatchScheduler.js'
+import { type WithRetryErrorType, withRetry } from './promise/withRetry.js'
+import type { GetSocketErrorType } from './rpc.js'
 
-import { withRetry } from './promise/withRetry.js'
+export type IsDeterministicErrorType = ErrorType
 
 export const isDeterministicError = (error: Error) => {
   if ('code' in error)
@@ -50,6 +80,36 @@ export const isDeterministicError = (error: Error) => {
   return false
 }
 
+export type RequestErrorType =
+  | ChainDisconnectedErrorType
+  | CreateBatchSchedulerErrorType
+  | HttpRequestErrorType
+  | InternalRpcErrorType
+  | InvalidInputRpcErrorType
+  | InvalidParamsRpcErrorType
+  | InvalidRequestRpcErrorType
+  | GetSocketErrorType
+  | JsonRpcVersionUnsupportedErrorType
+  | LimitExceededRpcErrorType
+  | MethodNotFoundRpcErrorType
+  | MethodNotSupportedRpcErrorType
+  | ParseRpcErrorType
+  | ProviderDisconnectedErrorType
+  | ResourceNotFoundRpcErrorType
+  | ResourceUnavailableRpcErrorType
+  | RpcErrorType
+  | RpcRequestErrorType
+  | SwitchChainErrorType
+  | TimeoutErrorType
+  | TransactionRejectedRpcErrorType
+  | UnauthorizedProviderErrorType
+  | UnknownRpcErrorType
+  | UnsupportedProviderMethodErrorType
+  | UserRejectedRequestErrorType
+  | WebSocketRequestErrorType
+  | WithRetryErrorType
+  | ErrorType
+
 export function buildRequest<TRequest extends (args: any) => Promise<any>>(
   request: TRequest,
   {

package/utils/ccip.ts

@@ -14,6 +14,7 @@ import type { GetErrorArgs } from '../types/contract.js'
 import type { Hex } from '../types/misc.js'
 
 import type { Client } from '../clients/createClient.js'
+import type { ErrorType } from '../errors/utils.js'
 import { decodeErrorResult } from './abi/decodeErrorResult.js'
 import { encodeAbiParameters } from './abi/encodeAbiParameters.js'
 import { isAddressEqual } from './address/isAddressEqual.js'
@@ -49,6 +50,8 @@ export const offchainLookupAbiItem = {
   ],
 } as const satisfies Abi[number]
 
+export type OffchainLookupErrorType = ErrorType
+
 export async function offchainLookup<TChain extends Chain | undefined,>(
   client: Client<Transport, TChain>,
   {
@@ -102,6 +105,8 @@ export async function offchainLookup<TChain extends Chain | undefined,>(
   }
 }
 
+export type CcipFetchErrorType = ErrorType
+
 export async function ccipFetch({
   data,
   sender,

package/utils/chain.ts

@@ -1,8 +1,12 @@
 import {
   ChainDoesNotSupportContract,
+  type ChainDoesNotSupportContractErrorType,
   ChainMismatchError,
+  type ChainMismatchErrorType,
   ChainNotFoundError,
+  type ChainNotFoundErrorType,
 } from '../errors/chain.js'
+import type { ErrorType } from '../errors/utils.js'
 import type {
   Chain,
   ChainConfig,
@@ -16,6 +20,11 @@ export type AssertCurrentChainParameters = {
   currentChainId: number
 }
 
+export type AssertCurrentChainErrorType =
+  | ChainNotFoundErrorType
+  | ChainMismatchErrorType
+  | ErrorType
+
 export function assertCurrentChain({
   chain,
   currentChainId,
@@ -45,6 +54,9 @@ export function defineChain<
   } as unknown as Assign<chain, ChainConfig<formatters>>
 }
 
+export type GetChainContractAddressErrorType =
+  ChainDoesNotSupportContractErrorType
+
 export function getChainContractAddress({
   blockNumber,
   chain,

package/utils/contract/extractFunctionParts.ts

@@ -1,5 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
+
 const paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/
 
+export type ExtractFunctionPartsErrorType = ErrorType
+
 export function extractFunctionParts(def: string) {
   const parts = def.match(paramsRegex)
   const type = parts?.[2] || undefined
@@ -8,10 +12,14 @@ export function extractFunctionParts(def: string) {
   return { type, name, params }
 }
 
+export type ExtractFunctionNameErrorType = ErrorType
+
 export function extractFunctionName(def: string) {
   return extractFunctionParts(def).name
 }
 
+export type ExtractFunctionParamsErrorType = ErrorType
+
 export function extractFunctionParams(def: string) {
   const params = extractFunctionParts(def).params
   const splitParams = params?.split(',').map((x) => x.trim().split(' '))
@@ -22,6 +30,8 @@ export function extractFunctionParams(def: string) {
   }))
 }
 
+export type ExtractFunctionTypeErrorType = ErrorType
+
 export function extractFunctionType(def: string) {
   return extractFunctionParts(def).type
 }

package/utils/cursor.ts

@@ -2,6 +2,7 @@ import {
   NegativeOffsetError,
   PositionOutOfBoundsError,
 } from '../errors/cursor.js'
+import type { ErrorType } from '../errors/utils.js'
 import type { ByteArray } from '../types/misc.js'
 
 export type Cursor = {
@@ -32,6 +33,20 @@ export type Cursor = {
   setPosition(position: number): void
 }
 
+export type CreateCursorErrorType = ErrorType
+
+export type CursorErrorType =
+  | CursorAssertPositionErrorType
+  | CursorDecrementPositionErrorType
+  | CursorIncrementPositionErrorType
+  | ErrorType
+
+export type CursorAssertPositionErrorType = PositionOutOfBoundsError | ErrorType
+
+export type CursorDecrementPositionErrorType = NegativeOffsetError | ErrorType
+
+export type CursorIncrementPositionErrorType = NegativeOffsetError | ErrorType
+
 const staticCursor: Cursor = {
   bytes: new Uint8Array(),
   dataView: new DataView(new ArrayBuffer(0)),

package/utils/data/concat.ts

@@ -1,8 +1,14 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 export type ConcatReturnType<TValue extends Hex | ByteArray> =
   TValue extends Hex ? Hex : ByteArray
 
+export type ConcatErrorType =
+  | ConcatBytesErrorType
+  | ConcatHexErrorType
+  | ErrorType
+
 export function concat<TValue extends Hex | ByteArray>(
   values: TValue[],
 ): ConcatReturnType<TValue> {
@@ -11,6 +17,8 @@ export function concat<TValue extends Hex | ByteArray>(
   return concatBytes(values as ByteArray[]) as ConcatReturnType<TValue>
 }
 
+export type ConcatBytesErrorType = ErrorType
+
 export function concatBytes(values: ByteArray[]): ByteArray {
   let length = 0
   for (const arr of values) {
@@ -25,6 +33,8 @@ export function concatBytes(values: ByteArray[]): ByteArray {
   return result
 }
 
+export type ConcatHexErrorType = ErrorType
+
 export function concatHex(values: Hex[]): Hex {
   return `0x${(values as Hex[]).reduce(
     (acc, x) => acc + x.replace('0x', ''),

package/utils/data/isBytes.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray } from '../../types/misc.js'
 
+export type IsBytesErrorType = ErrorType
+
 export function isBytes(value: unknown): value is ByteArray {
   if (!value) return false
   if (typeof value !== 'object') return false

package/utils/data/isBytesEqual.ts

@@ -1,8 +1,14 @@
 import { equalBytes } from '@noble/curves/abstract/utils'
 
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { toBytes } from '../encoding/toBytes.js'
-import { isHex } from './isHex.js'
+import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+
+export type IsBytesEqualErrorType =
+  | IsHexErrorType
+  | ToBytesErrorType
+  | ErrorType
 
 export function isBytesEqual(a_: ByteArray | Hex, b_: ByteArray | Hex) {
   const a = isHex(a_) ? toBytes(a_) : a_

package/utils/data/isHex.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 
+export type IsHexErrorType = ErrorType
+
 export function isHex(
   value: unknown,
   { strict = true }: { strict?: boolean } = {},

package/utils/data/pad.ts

@@ -1,4 +1,8 @@
-import { SizeExceedsPaddingSizeError } from '../../errors/data.js'
+import {
+  SizeExceedsPaddingSizeError,
+  type SizeExceedsPaddingSizeErrorType,
+} from '../../errors/data.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 type PadOptions = {
@@ -9,6 +13,8 @@ export type PadReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type PadErrorType = PadHexErrorType | PadBytesErrorType | ErrorType
+
 export function pad<TValue extends ByteArray | Hex>(
   hexOrBytes: TValue,
   { dir, size = 32 }: PadOptions = {},
@@ -18,6 +24,8 @@ export function pad<TValue extends ByteArray | Hex>(
   return padBytes(hexOrBytes, { dir, size }) as PadReturnType<TValue>
 }
 
+export type PadHexErrorType = SizeExceedsPaddingSizeErrorType | ErrorType
+
 export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
   if (size === null) return hex_
   const hex = hex_.replace('0x', '')
@@ -34,6 +42,8 @@ export function padHex(hex_: Hex, { dir, size = 32 }: PadOptions = {}) {
   )}` as Hex
 }
 
+export type PadBytesErrorType = SizeExceedsPaddingSizeErrorType | ErrorType
+
 export function padBytes(
   bytes: ByteArray,
   { dir, size = 32 }: PadOptions = {},

package/utils/data/size.ts

@@ -1,6 +1,9 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
-import { isHex } from './isHex.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+
+export type SizeErrorType = IsHexErrorType | ErrorType
 
 /**
  * @description Retrieves the size of the value (in bytes).

package/utils/data/slice.ts

@@ -1,13 +1,23 @@
-import { SliceOffsetOutOfBoundsError } from '../../errors/data.js'
+import {
+  SliceOffsetOutOfBoundsError,
+  type SliceOffsetOutOfBoundsErrorType,
+} from '../../errors/data.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
-import { isHex } from './isHex.js'
-import { size } from './size.js'
+import { type IsHexErrorType, isHex } from './isHex.js'
+import { type SizeErrorType, size } from './size.js'
 
 export type SliceReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type SliceErrorType =
+  | IsHexErrorType
+  | SliceBytesErrorType
+  | SliceHexErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the hex or byte array given a start/end bytes offset.
  *
@@ -30,6 +40,11 @@ export function slice<TValue extends ByteArray | Hex>(
   }) as SliceReturnType<TValue>
 }
 
+export type AssertStartOffsetErrorType =
+  | SliceOffsetOutOfBoundsErrorType
+  | SizeErrorType
+  | ErrorType
+
 function assertStartOffset(value: Hex | ByteArray, start?: number) {
   if (typeof start === 'number' && start > 0 && start > size(value) - 1)
     throw new SliceOffsetOutOfBoundsError({
@@ -39,6 +54,11 @@ function assertStartOffset(value: Hex | ByteArray, start?: number) {
     })
 }
 
+export type AssertEndOffsetErrorType =
+  | SliceOffsetOutOfBoundsErrorType
+  | SizeErrorType
+  | ErrorType
+
 function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
   if (
     typeof start === 'number' &&
@@ -53,6 +73,11 @@ function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
   }
 }
 
+export type SliceBytesErrorType =
+  | AssertStartOffsetErrorType
+  | AssertEndOffsetErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the byte array given a start/end bytes offset.
  *
@@ -72,6 +97,11 @@ export function sliceBytes(
   return value
 }
 
+export type SliceHexErrorType =
+  | AssertStartOffsetErrorType
+  | AssertEndOffsetErrorType
+  | ErrorType
+
 /**
  * @description Returns a section of the hex value given a start/end bytes offset.
  *

package/utils/data/trim.ts

@@ -1,3 +1,4 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
 
 type TrimOptions = {
@@ -7,6 +8,8 @@ export type TrimReturnType<TValue extends ByteArray | Hex> = TValue extends Hex
   ? Hex
   : ByteArray
 
+export type TrimErrorType = ErrorType
+
 export function trim<TValue extends ByteArray | Hex>(
   hexOrBytes: TValue,
   { dir = 'left' }: TrimOptions = {},

package/utils/encoding/fromBytes.ts

@@ -1,9 +1,17 @@
 import { InvalidBytesBooleanError } from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { trim } from '../data/trim.js'
+import { type TrimErrorType, trim } from '../data/trim.js'
 
-import { assertSize, hexToBigInt, hexToNumber } from './fromHex.js'
-import { bytesToHex } from './toHex.js'
+import {
+  type AssertSizeErrorType,
+  type HexToBigIntErrorType,
+  type HexToNumberErrorType,
+  assertSize,
+  hexToBigInt,
+  hexToNumber,
+} from './fromHex.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 export type FromBytesParameters<
   TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean',
@@ -16,7 +24,7 @@ export type FromBytesParameters<
       to: TTo
     }
 
-type FromBytesReturnType<TTo> = TTo extends 'string'
+export type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
   ? Hex
@@ -28,6 +36,14 @@ type FromBytesReturnType<TTo> = TTo extends 'string'
   ? boolean
   : never
 
+export type FromBytesErrorType =
+  | BytesToHexErrorType
+  | BytesToBigIntErrorType
+  | BytesToBoolErrorType
+  | BytesToNumberErrorType
+  | BytesToStringErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
  *
@@ -63,7 +79,7 @@ export function fromBytes<
   if (to === 'number')
     return bytesToNumber(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'bigint')
-    return bytesToBigint(bytes, opts) as FromBytesReturnType<TTo>
+    return bytesToBigInt(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'boolean')
     return bytesToBool(bytes, opts) as FromBytesReturnType<TTo>
   if (to === 'string')
@@ -78,6 +94,11 @@ export type BytesToBigIntOpts = {
   size?: number
 }
 
+export type BytesToBigIntErrorType =
+  | BytesToHexErrorType
+  | HexToBigIntErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a bigint.
  *
@@ -88,11 +109,11 @@ export type BytesToBigIntOpts = {
  * @returns BigInt value.
  *
  * @example
- * import { bytesToBigint } from 'viem'
- * const data = bytesToBigint(new Uint8Array([1, 164]))
+ * import { bytesToBigInt } from 'viem'
+ * const data = bytesToBigInt(new Uint8Array([1, 164]))
  * // 420n
  */
-export function bytesToBigint(
+export function bytesToBigInt(
   bytes: ByteArray,
   opts: BytesToBigIntOpts = {},
 ): bigint {
@@ -106,6 +127,11 @@ export type BytesToBoolOpts = {
   size?: number
 }
 
+export type BytesToBoolErrorType =
+  | AssertSizeErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a boolean.
  *
@@ -136,6 +162,11 @@ export function bytesToBool(
 
 export type BytesToNumberOpts = BytesToBigIntOpts
 
+export type BytesToNumberErrorType =
+  | BytesToHexErrorType
+  | HexToNumberErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a number.
  *
@@ -164,6 +195,11 @@ export type BytesToStringOpts = {
   size?: number
 }
 
+export type BytesToStringErrorType =
+  | AssertSizeErrorType
+  | TrimErrorType
+  | ErrorType
+
 /**
  * Decodes a byte array into a UTF-8 string.
  *