viem 0.0.0-main.20230929T005223 → 0.0.0-main.20230929T011129

package/utils/encoding/fromRlp.ts

@@ -1,9 +1,17 @@
-import { BaseError } from '../../errors/base.js'
-import { InvalidHexValueError } from '../../errors/encoding.js'
+import { BaseError, type BaseErrorType } from '../../errors/base.js'
+import {
+  InvalidHexValueError,
+  type InvalidHexValueErrorType,
+} from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { type Cursor, createCursor } from '../cursor.js'
-import { hexToBytes } from './toBytes.js'
-import { bytesToHex } from './toHex.js'
+import {
+  type CreateCursorErrorType,
+  type Cursor,
+  createCursor,
+} from '../cursor.js'
+import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 import type { RecursiveArray } from './toRlp.js'
 
@@ -13,6 +21,13 @@ export type FromRlpReturnType<to extends To> =
   | (to extends 'bytes' ? RecursiveArray<ByteArray> : never)
   | (to extends 'hex' ? RecursiveArray<Hex> : never)
 
+export type FromRlpErrorType =
+  | CreateCursorErrorType
+  | FromRlpCursorErrorType
+  | HexToBytesErrorType
+  | InvalidHexValueErrorType
+  | ErrorType
+
 export function fromRlp<to extends To = 'hex'>(
   value: ByteArray | Hex,
   to: to | To | undefined = 'hex',
@@ -32,6 +47,8 @@ export function fromRlp<to extends To = 'hex'>(
   return result as FromRlpReturnType<to>
 }
 
+export type RlpToBytesErrorType = FromRlpErrorType | ErrorType
+
 export function rlpToBytes<to extends To = 'bytes'>(
   bytes: ByteArray,
   to: to | To | undefined = 'bytes',
@@ -39,6 +56,8 @@ export function rlpToBytes<to extends To = 'bytes'>(
   return fromRlp(bytes, to)
 }
 
+export type RlpToHexErrorType = FromRlpErrorType | ErrorType
+
 export function rlpToHex<to extends To = 'hex'>(
   hex: Hex,
   to: to | To | undefined = 'hex',
@@ -46,6 +65,12 @@ export function rlpToHex<to extends To = 'hex'>(
   return fromRlp(hex, to)
 }
 
+export type FromRlpCursorErrorType =
+  | BytesToHexErrorType
+  | ReadLengthErrorType
+  | ReadListErrorType
+  | ErrorType
+
 function fromRlpCursor<to extends To = 'hex'>(
   cursor: Cursor,
   to: to | To | undefined = 'hex',
@@ -70,6 +95,8 @@ function fromRlpCursor<to extends To = 'hex'>(
   return readList(cursor, length, to) as {} as FromRlpReturnType<to>
 }
 
+export type ReadLengthErrorType = BaseErrorType | ErrorType
+
 function readLength(cursor: Cursor, prefix: number, offset: number) {
   if (offset === 0x80 && prefix < 0x80) return 1
   if (prefix <= offset + 55) return prefix - offset
@@ -80,6 +107,8 @@ function readLength(cursor: Cursor, prefix: number, offset: number) {
   throw new BaseError('Invalid RLP prefix')
 }
 
+export type ReadListErrorType = ErrorType
+
 function readList<to extends To>(cursor: Cursor, length: number, to: to | To) {
   const position = cursor.position
   const value: FromRlpReturnType<to>[] = []

package/utils/encoding/toBytes.ts

@@ -1,10 +1,15 @@
 import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
-import { pad } from '../data/pad.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+import { type PadErrorType, pad } from '../data/pad.js'
 
-import { assertSize } from './fromHex.js'
-import { type NumberToHexOpts, numberToHex } from './toHex.js'
+import { type AssertSizeErrorType, assertSize } from './fromHex.js'
+import {
+  type NumberToHexErrorType,
+  type NumberToHexOpts,
+  numberToHex,
+} from './toHex.js'
 
 const encoder = /*#__PURE__*/ new TextEncoder()
 
@@ -13,6 +18,14 @@ export type ToBytesParameters = {
   size?: number
 }
 
+export type ToBytesErrorType =
+  | NumberToBytesErrorType
+  | BoolToBytesErrorType
+  | HexToBytesErrorType
+  | StringToBytesErrorType
+  | IsHexErrorType
+  | ErrorType
+
 /**
  * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
  *
@@ -49,11 +62,16 @@ export function toBytes(
   return stringToBytes(value, opts)
 }
 
-export type BoolToHexOpts = {
+export type BoolToBytesOpts = {
   /** Size of the output bytes. */
   size?: number
 }
 
+export type BoolToBytesErrorType =
+  | AssertSizeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a boolean into a byte array.
  *
@@ -73,7 +91,7 @@ export type BoolToHexOpts = {
  * const data = boolToBytes(true, { size: 32 })
  * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
  */
-export function boolToBytes(value: boolean, opts: BoolToHexOpts = {}) {
+export function boolToBytes(value: boolean, opts: BoolToBytesOpts = {}) {
   const bytes = new Uint8Array(1)
   bytes[0] = Number(value)
   if (typeof opts.size === 'number') {
@@ -108,6 +126,8 @@ export type HexToBytesOpts = {
   size?: number
 }
 
+export type HexToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a hex string into a byte array.
  *
@@ -154,6 +174,11 @@ export function hexToBytes(hex_: Hex, opts: HexToBytesOpts = {}): ByteArray {
   return bytes
 }
 
+export type NumberToBytesErrorType =
+  | NumberToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
 /**
  * Encodes a number into a byte array.
  *
@@ -183,6 +208,11 @@ export type StringToBytesOpts = {
   size?: number
 }
 
+export type StringToBytesErrorType =
+  | AssertSizeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a UTF-8 string into a byte array.
  *

package/utils/encoding/toHex.ts

@@ -1,8 +1,12 @@
-import { IntegerOutOfRangeError } from '../../errors/encoding.js'
+import {
+  IntegerOutOfRangeError,
+  type IntegerOutOfRangeErrorType,
+} from '../../errors/encoding.js'
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { pad } from '../data/pad.js'
+import { type PadErrorType, pad } from '../data/pad.js'
 
-import { assertSize } from './fromHex.js'
+import { type AssertSizeErrorType, assertSize } from './fromHex.js'
 
 const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) =>
   i.toString(16).padStart(2, '0'),
@@ -13,6 +17,13 @@ export type ToHexParameters = {
   size?: number
 }
 
+export type ToHexErrorType =
+  | BoolToHexErrorType
+  | BytesToHexErrorType
+  | NumberToHexErrorType
+  | StringToHexErrorType
+  | ErrorType
+
 /**
  * Encodes a string, number, bigint, or ByteArray into a hex string
  *
@@ -56,6 +67,8 @@ export type BoolToHexOpts = {
   size?: number
 }
 
+export type BoolToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a boolean into a hex string
  *
@@ -94,6 +107,8 @@ export type BytesToHexOpts = {
   size?: number
 }
 
+export type BytesToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType
+
 /**
  * Encodes a bytes array into a hex string
  *
@@ -140,6 +155,11 @@ export type NumberToHexOpts =
       size?: number
     }
 
+export type NumberToHexErrorType =
+  | IntegerOutOfRangeErrorType
+  | PadErrorType
+  | ErrorType
+
 /**
  * Encodes a number or bigint into a hex string
  *
@@ -201,6 +221,8 @@ export type StringToHexOpts = {
   size?: number
 }
 
+export type StringToHexErrorType = BytesToHexErrorType | ErrorType
+
 const encoder = /*#__PURE__*/ new TextEncoder()
 
 /**

package/utils/encoding/toRlp.ts

@@ -1,9 +1,14 @@
+import type { ErrorType } from '../../errors/utils.js'
 import { BaseError } from '../../index.js'
 import type { ByteArray, Hex } from '../../types/misc.js'
-import { type Cursor, createCursor } from '../cursor.js'
+import {
+  type CreateCursorErrorType,
+  type Cursor,
+  createCursor,
+} from '../cursor.js'
 
-import { hexToBytes } from './toBytes.js'
-import { bytesToHex } from './toHex.js'
+import { type HexToBytesErrorType, hexToBytes } from './toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from './toHex.js'
 
 export type RecursiveArray<T> = T | RecursiveArray<T>[]
 
@@ -18,6 +23,12 @@ export type ToRlpReturnType<to extends To> =
   | (to extends 'bytes' ? ByteArray : never)
   | (to extends 'hex' ? Hex : never)
 
+export type ToRlpErrorType =
+  | CreateCursorErrorType
+  | BytesToHexErrorType
+  | HexToBytesErrorType
+  | ErrorType
+
 export function toRlp<to extends To = 'hex'>(
   bytes: RecursiveArray<ByteArray> | RecursiveArray<Hex>,
   to: to | To | undefined = 'hex',
@@ -30,6 +41,8 @@ export function toRlp<to extends To = 'hex'>(
   return cursor.bytes as ToRlpReturnType<to>
 }
 
+export type BytesToRlpErrorType = ToRlpErrorType | ErrorType
+
 export function bytesToRlp<to extends To = 'bytes'>(
   bytes: RecursiveArray<ByteArray>,
   to: to | To | undefined = 'bytes',
@@ -37,6 +50,8 @@ export function bytesToRlp<to extends To = 'bytes'>(
   return toRlp(bytes, to)
 }
 
+export type HexToRlpErrorType = ToRlpErrorType | ErrorType
+
 export function hexToRlp<to extends To = 'hex'>(
   hex: RecursiveArray<Hex>,
   to: to | To | undefined = 'hex',

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -1,9 +1,16 @@
 import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
 import type { Chain } from '../../../types/chain.js'
 import type { AssetGatewayUrls } from '../../../types/ens.js'
 
 import {
+  type GetJsonImageErrorType,
+  type GetMetadataAvatarUriErrorType,
+  type GetNftTokenUriErrorType,
+  type ParseAvatarUriErrorType,
+  type ParseNftUriErrorType,
+  type ResolveAvatarUriErrorType,
   getJsonImage,
   getMetadataAvatarUri,
   getNftTokenUri,
@@ -12,6 +19,11 @@ import {
   resolveAvatarUri,
 } from './utils.js'
 
+export type ParseAvatarRecordErrorType =
+  | ParseNftAvatarUriErrorType
+  | ParseAvatarUriErrorType
+  | ErrorType
+
 export async function parseAvatarRecord<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   {
@@ -27,6 +39,15 @@ export async function parseAvatarRecord<TChain extends Chain | undefined>(
   return parseAvatarUri({ uri: record, gatewayUrls })
 }
 
+export type ParseNftAvatarUriErrorType =
+  | ParseNftUriErrorType
+  | GetNftTokenUriErrorType
+  | ResolveAvatarUriErrorType
+  | ParseAvatarUriErrorType
+  | GetJsonImageErrorType
+  | GetMetadataAvatarUriErrorType
+  | ErrorType
+
 async function parseNftAvatarUri<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   {

package/utils/ens/avatar/utils.ts

@@ -1,14 +1,22 @@
 import type { Address } from 'abitype'
 
-import { readContract } from '../../../actions/public/readContract.js'
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
 import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
 import {
   EnsAvatarInvalidMetadataError,
+  type EnsAvatarInvalidMetadataErrorType,
   EnsAvatarInvalidNftUriError,
+  type EnsAvatarInvalidNftUriErrorType,
   EnsAvatarUnsupportedNamespaceError,
+  type EnsAvatarUnsupportedNamespaceErrorType,
   EnsAvatarUriResolutionError,
+  type EnsAvatarUriResolutionErrorType,
 } from '../../../errors/ens.js'
+import type { ErrorType } from '../../../errors/utils.js'
 import type { Chain } from '../../../types/chain.js'
 import type { AssetGatewayUrls } from '../../../types/ens.js'
 
@@ -25,6 +33,8 @@ const ipfsHashRegex =
 const base64Regex = /^data:([a-zA-Z\-/+]*);base64,([^"].*)/
 const dataURIRegex = /^data:([a-zA-Z\-/+]*)?(;[a-zA-Z0-9].*?)?(,)/
 
+export type IsImageUriErrorType = ErrorType
+
 export async function isImageUri(uri: string) {
   try {
     const res = await fetch(uri, { method: 'HEAD' })
@@ -56,12 +66,19 @@ export async function isImageUri(uri: string) {
   }
 }
 
+export type GetGatewayErrorType = ErrorType
+
 export function getGateway(custom: string | undefined, defaultGateway: string) {
   if (!custom) return defaultGateway
   if (custom.endsWith('/')) return custom.slice(0, -1)
   return custom
 }
 
+export type ResolveAvatarUriErrorType =
+  | GetGatewayErrorType
+  | EnsAvatarUriResolutionErrorType
+  | ErrorType
+
 export function resolveAvatarUri({
   uri,
   gatewayUrls,
@@ -125,6 +142,10 @@ export function resolveAvatarUri({
   throw new EnsAvatarUriResolutionError({ uri })
 }
 
+export type GetJsonImageErrorType =
+  | EnsAvatarInvalidMetadataErrorType
+  | ErrorType
+
 export function getJsonImage(data: any) {
   // validation check for json data, must include one of theses properties
   if (
@@ -137,6 +158,12 @@ export function getJsonImage(data: any) {
   return data.image || data.image_url || data.image_data
 }
 
+export type GetMetadataAvatarUriErrorType =
+  | EnsAvatarUriResolutionErrorType
+  | ParseAvatarUriErrorType
+  | GetJsonImageErrorType
+  | ErrorType
+
 export async function getMetadataAvatarUri({
   gatewayUrls,
   uri,
@@ -156,6 +183,12 @@ export async function getMetadataAvatarUri({
   }
 }
 
+export type ParseAvatarUriErrorType =
+  | ResolveAvatarUriErrorType
+  | IsImageUriErrorType
+  | EnsAvatarUriResolutionErrorType
+  | ErrorType
+
 export async function parseAvatarUri({
   gatewayUrls,
   uri,
@@ -180,6 +213,8 @@ type ParsedNft = {
   tokenID: string
 }
 
+export type ParseNftUriErrorType = EnsAvatarInvalidNftUriErrorType | ErrorType
+
 export function parseNftUri(uri_: string): ParsedNft {
   let uri = uri_
   // parse valid nft spec (CAIP-22/CAIP-29)
@@ -214,6 +249,11 @@ export function parseNftUri(uri_: string): ParsedNft {
   }
 }
 
+export type GetNftTokenUriErrorType =
+  | ReadContractErrorType
+  | EnsAvatarUnsupportedNamespaceErrorType
+  | ErrorType
+
 export async function getNftTokenUri<TChain extends Chain | undefined>(
   client: Client<Transport, TChain>,
   { nft }: { nft: ParsedNft },

package/utils/ens/encodeLabelhash.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
 
+export type EncodeLabelhashErrorType = ErrorType
+
 export function encodeLabelhash(hash: Hex): `[${string}]` {
   return `[${hash.slice(2)}]`
 }

package/utils/ens/encodedLabelToLabelhash.ts

@@ -1,5 +1,8 @@
+import type { ErrorType } from '../../errors/utils.js'
 import type { Hex } from '../../types/misc.js'
-import { isHex } from '../data/isHex.js'
+import { type IsHexErrorType, isHex } from '../data/isHex.js'
+
+export type EncodedLabelToLabelhashErrorType = IsHexErrorType | ErrorType
 
 export function encodedLabelToLabelhash(label: string): Hex | null {
   if (label.length !== 66) return null

package/utils/ens/errors.ts

@@ -1,6 +1,9 @@
 import { panicReasons } from '../../constants/solidity.js'
 import { BaseError } from '../../errors/base.js'
 import { ContractFunctionRevertedError } from '../../errors/contract.js'
+import type { ErrorType } from '../../errors/utils.js'
+
+export type IsNullUniversalResolverErrorErrorType = ErrorType
 
 /*
  * @description Checks if error is a valid null result UniversalResolver error

package/utils/ens/labelhash.ts

@@ -1,7 +1,21 @@
-import { stringToBytes } from '../encoding/toBytes.js'
-import { bytesToHex } from '../encoding/toHex.js'
-import { keccak256 } from '../hash/keccak256.js'
-import { encodedLabelToLabelhash } from './encodedLabelToLabelhash.js'
+import type { ErrorType } from '../../errors/utils.js'
+import {
+  type StringToBytesErrorType,
+  stringToBytes,
+} from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import {
+  type EncodedLabelToLabelhashErrorType,
+  encodedLabelToLabelhash,
+} from './encodedLabelToLabelhash.js'
+
+export type LabelhashErrorType =
+  | BytesToHexErrorType
+  | EncodedLabelToLabelhashErrorType
+  | Keccak256ErrorType
+  | StringToBytesErrorType
+  | ErrorType
 
 /**
  * @description Hashes ENS label

package/utils/ens/namehash.ts

@@ -1,8 +1,26 @@
-import { concat } from '../data/concat.js'
-import { stringToBytes, toBytes } from '../encoding/toBytes.js'
-import { bytesToHex } from '../encoding/toHex.js'
-import { keccak256 } from '../hash/keccak256.js'
-import { encodedLabelToLabelhash } from './encodedLabelToLabelhash.js'
+import type { ErrorType } from '../../errors/utils.js'
+import { type ConcatErrorType, concat } from '../data/concat.js'
+import {
+  type StringToBytesErrorType,
+  type ToBytesErrorType,
+  stringToBytes,
+  toBytes,
+} from '../encoding/toBytes.js'
+import { type BytesToHexErrorType, bytesToHex } from '../encoding/toHex.js'
+import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
+import {
+  type EncodedLabelToLabelhashErrorType,
+  encodedLabelToLabelhash,
+} from './encodedLabelToLabelhash.js'
+
+export type NamehashErrorType =
+  | BytesToHexErrorType
+  | EncodedLabelToLabelhashErrorType
+  | ToBytesErrorType
+  | Keccak256ErrorType
+  | StringToBytesErrorType
+  | ConcatErrorType
+  | ErrorType
 
 /**
  * @description Hashes ENS name

package/utils/ens/normalize.ts

@@ -1,4 +1,7 @@
 import { ens_normalize } from '@adraffy/ens-normalize'
+import type { ErrorType } from '../../errors/utils.js'
+
+export type NormalizeErrorType = ErrorType
 
 /**
  * @description Normalizes ENS name according to ENSIP-15.

package/utils/ens/packetToBytes.ts

@@ -1,8 +1,21 @@
 // Adapted from https://github.com/mafintosh/dns-packet
+import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray } from '../../types/misc.js'
-import { stringToBytes } from '../encoding/toBytes.js'
-import { encodeLabelhash } from './encodeLabelhash.js'
-import { labelhash } from './labelhash.js'
+import {
+  type StringToBytesErrorType,
+  stringToBytes,
+} from '../encoding/toBytes.js'
+import {
+  type EncodeLabelhashErrorType,
+  encodeLabelhash,
+} from './encodeLabelhash.js'
+import { type LabelhashErrorType, labelhash } from './labelhash.js'
+
+export type PacketToBytesErrorType =
+  | EncodeLabelhashErrorType
+  | LabelhashErrorType
+  | StringToBytesErrorType
+  | ErrorType
 
 /*
  * @description Encodes a DNS packet into a ByteArray containing a UDP payload.

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