viem 0.0.0-portable-types-20230522163654 → 0.0.0-refactor-generics-20230831161903

package/src/clients/transports/webSocket.ts

@@ -1,9 +1,9 @@
 import type { WebSocket } from 'isomorphic-ws'
 
+import { RpcRequestError } from '../../errors/request.js'
 import { UrlRequiredError } from '../../errors/transport.js'
 import type { Hash } from '../../types/misc.js'
 import { type RpcResponse, getSocket, rpc } from '../../utils/rpc.js'
-
 import {
   type Transport,
   type TransportConfig,
@@ -72,11 +72,18 @@ export function webSocket(
         key,
         name,
         async request({ method, params }) {
+          const body = { method, params }
           const socket = await getSocket(url_)
-          const { result } = await rpc.webSocketAsync(socket, {
-            body: { method, params },
+          const { error, result } = await rpc.webSocketAsync(socket, {
+            body,
             timeout,
           })
+          if (error)
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
           return result
         },
         retryCount,
@@ -97,31 +104,32 @@ export function webSocket(
                   method: 'eth_subscribe',
                   params,
                 },
-                onData: (data) => {
-                  if (typeof data.id === 'number') {
-                    resolve(data)
+                onResponse(response) {
+                  if (response.error) {
+                    reject(response.error)
+                    onError?.(response.error)
                     return
                   }
-                  if (data.method !== 'eth_subscription') return
-                  onData(data.params)
-                },
-                onError: (error) => {
-                  reject(error)
-                  onError?.(error)
+
+                  if (typeof response.id === 'number') {
+                    resolve(response)
+                    return
+                  }
+                  if (response.method !== 'eth_subscription') return
+                  onData(response.params)
                 },
               }),
           )
           return {
             subscriptionId,
             async unsubscribe() {
-              return new Promise<any>((resolve, reject) =>
+              return new Promise<any>((resolve) =>
                 rpc.webSocket(socket, {
                   body: {
                     method: 'eth_unsubscribe',
                     params: [subscriptionId],
                   },
-                  onData: resolve,
-                  onError: reject,
+                  onResponse: resolve,
                 }),
               )
             },

package/src/constants/abis.ts

@@ -43,7 +43,21 @@ export const multicall3Abi = [
   },
 ] as const
 
-export const universalResolverAbi = [
+const universalResolverErrors = [
+  {
+    inputs: [],
+    name: 'ResolverNotFound',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'ResolverWildcardNotSupported',
+    type: 'error',
+  },
+] as const
+
+export const universalResolverResolveAbi = [
+  ...universalResolverErrors,
   {
     name: 'resolve',
     type: 'function',
@@ -59,6 +73,22 @@ export const universalResolverAbi = [
   },
 ] as const
 
+export const universalResolverReverseAbi = [
+  ...universalResolverErrors,
+  {
+    name: 'reverse',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ type: 'bytes', name: 'reverseName' }],
+    outputs: [
+      { type: 'string', name: 'resolvedName' },
+      { type: 'address', name: 'resolvedAddress' },
+      { type: 'address', name: 'reverseResolver' },
+      { type: 'address', name: 'resolver' },
+    ],
+  },
+] as const
+
 export const textResolverAbi = [
   {
     name: 'text',
@@ -72,7 +102,7 @@ export const textResolverAbi = [
   },
 ] as const
 
-export const singleAddressResolverAbi = [
+export const addressResolverAbi = [
   {
     name: 'addr',
     type: 'function',
@@ -80,6 +110,16 @@ export const singleAddressResolverAbi = [
     inputs: [{ name: 'name', type: 'bytes32' }],
     outputs: [{ name: '', type: 'address' }],
   },
+  {
+    name: 'addr',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [
+      { name: 'name', type: 'bytes32' },
+      { name: 'coinType', type: 'uint256' },
+    ],
+    outputs: [{ name: '', type: 'bytes' }],
+  },
 ] as const
 
 // ERC-1271

package/src/constants/number.ts

@@ -0,0 +1,98 @@
+export const maxInt8 = 2n ** (8n - 1n) - 1n
+export const maxInt16 = 2n ** (16n - 1n) - 1n
+export const maxInt24 = 2n ** (24n - 1n) - 1n
+export const maxInt32 = 2n ** (32n - 1n) - 1n
+export const maxInt40 = 2n ** (40n - 1n) - 1n
+export const maxInt48 = 2n ** (48n - 1n) - 1n
+export const maxInt56 = 2n ** (56n - 1n) - 1n
+export const maxInt64 = 2n ** (64n - 1n) - 1n
+export const maxInt72 = 2n ** (72n - 1n) - 1n
+export const maxInt80 = 2n ** (80n - 1n) - 1n
+export const maxInt88 = 2n ** (88n - 1n) - 1n
+export const maxInt96 = 2n ** (96n - 1n) - 1n
+export const maxInt104 = 2n ** (104n - 1n) - 1n
+export const maxInt112 = 2n ** (112n - 1n) - 1n
+export const maxInt120 = 2n ** (120n - 1n) - 1n
+export const maxInt128 = 2n ** (128n - 1n) - 1n
+export const maxInt136 = 2n ** (136n - 1n) - 1n
+export const maxInt144 = 2n ** (144n - 1n) - 1n
+export const maxInt152 = 2n ** (152n - 1n) - 1n
+export const maxInt160 = 2n ** (160n - 1n) - 1n
+export const maxInt168 = 2n ** (168n - 1n) - 1n
+export const maxInt176 = 2n ** (176n - 1n) - 1n
+export const maxInt184 = 2n ** (184n - 1n) - 1n
+export const maxInt192 = 2n ** (192n - 1n) - 1n
+export const maxInt200 = 2n ** (200n - 1n) - 1n
+export const maxInt208 = 2n ** (208n - 1n) - 1n
+export const maxInt216 = 2n ** (216n - 1n) - 1n
+export const maxInt224 = 2n ** (224n - 1n) - 1n
+export const maxInt232 = 2n ** (232n - 1n) - 1n
+export const maxInt240 = 2n ** (240n - 1n) - 1n
+export const maxInt248 = 2n ** (248n - 1n) - 1n
+export const maxInt256 = 2n ** (256n - 1n) - 1n
+
+export const minInt8 = -(2n ** (8n - 1n))
+export const minInt16 = -(2n ** (16n - 1n))
+export const minInt24 = -(2n ** (24n - 1n))
+export const minInt32 = -(2n ** (32n - 1n))
+export const minInt40 = -(2n ** (40n - 1n))
+export const minInt48 = -(2n ** (48n - 1n))
+export const minInt56 = -(2n ** (56n - 1n))
+export const minInt64 = -(2n ** (64n - 1n))
+export const minInt72 = -(2n ** (72n - 1n))
+export const minInt80 = -(2n ** (80n - 1n))
+export const minInt88 = -(2n ** (88n - 1n))
+export const minInt96 = -(2n ** (96n - 1n))
+export const minInt104 = -(2n ** (104n - 1n))
+export const minInt112 = -(2n ** (112n - 1n))
+export const minInt120 = -(2n ** (120n - 1n))
+export const minInt128 = -(2n ** (128n - 1n))
+export const minInt136 = -(2n ** (136n - 1n))
+export const minInt144 = -(2n ** (144n - 1n))
+export const minInt152 = -(2n ** (152n - 1n))
+export const minInt160 = -(2n ** (160n - 1n))
+export const minInt168 = -(2n ** (168n - 1n))
+export const minInt176 = -(2n ** (176n - 1n))
+export const minInt184 = -(2n ** (184n - 1n))
+export const minInt192 = -(2n ** (192n - 1n))
+export const minInt200 = -(2n ** (200n - 1n))
+export const minInt208 = -(2n ** (208n - 1n))
+export const minInt216 = -(2n ** (216n - 1n))
+export const minInt224 = -(2n ** (224n - 1n))
+export const minInt232 = -(2n ** (232n - 1n))
+export const minInt240 = -(2n ** (240n - 1n))
+export const minInt248 = -(2n ** (248n - 1n))
+export const minInt256 = -(2n ** (256n - 1n))
+
+export const maxUint8 = 2n ** 8n - 1n
+export const maxUint16 = 2n ** 16n - 1n
+export const maxUint24 = 2n ** 24n - 1n
+export const maxUint32 = 2n ** 32n - 1n
+export const maxUint40 = 2n ** 40n - 1n
+export const maxUint48 = 2n ** 48n - 1n
+export const maxUint56 = 2n ** 56n - 1n
+export const maxUint64 = 2n ** 64n - 1n
+export const maxUint72 = 2n ** 72n - 1n
+export const maxUint80 = 2n ** 80n - 1n
+export const maxUint88 = 2n ** 88n - 1n
+export const maxUint96 = 2n ** 96n - 1n
+export const maxUint104 = 2n ** 104n - 1n
+export const maxUint112 = 2n ** 112n - 1n
+export const maxUint120 = 2n ** 120n - 1n
+export const maxUint128 = 2n ** 128n - 1n
+export const maxUint136 = 2n ** 136n - 1n
+export const maxUint144 = 2n ** 144n - 1n
+export const maxUint152 = 2n ** 152n - 1n
+export const maxUint160 = 2n ** 160n - 1n
+export const maxUint168 = 2n ** 168n - 1n
+export const maxUint176 = 2n ** 176n - 1n
+export const maxUint184 = 2n ** 184n - 1n
+export const maxUint192 = 2n ** 192n - 1n
+export const maxUint200 = 2n ** 200n - 1n
+export const maxUint208 = 2n ** 208n - 1n
+export const maxUint216 = 2n ** 216n - 1n
+export const maxUint224 = 2n ** 224n - 1n
+export const maxUint232 = 2n ** 232n - 1n
+export const maxUint240 = 2n ** 240n - 1n
+export const maxUint248 = 2n ** 248n - 1n
+export const maxUint256 = 2n ** 256n - 1n

package/src/contract.ts

@@ -23,9 +23,13 @@ export {
   type MulticallReturnType,
   multicall,
 } from './actions/public/multicall.js'
-export {
-  type OnLogsFn,
-  type OnLogsParameter,
+export type {
+  WatchEventOnLogsFn,
+  /** @deprecated - use `WatchEventOnLogsFn` instead. */
+  WatchEventOnLogsFn as OnLogsFn,
+  WatchEventOnLogsParameter,
+  /** @deprecated - use `WatchEventOnLogsParameter` instead. */
+  WatchEventOnLogsParameter as OnLogsParameter,
 } from './actions/public/watchEvent.js'
 export {
   type ReadContractParameters,

package/src/errors/abi.ts

@@ -1,6 +1,5 @@
-import type { AbiParameter } from 'abitype'
+import type { AbiEvent, AbiParameter } from 'abitype'
 
-import type { AbiItem } from '../types/contract.js'
 import type { Hex } from '../types/misc.js'
 import { formatAbiItem, formatAbiParams } from '../utils/abi/formatAbiItem.js'
 import { size } from '../utils/data/size.js'
@@ -164,17 +163,21 @@ export class AbiErrorNotFoundError extends BaseError {
 
 export class AbiErrorSignatureNotFoundError extends BaseError {
   override name = 'AbiErrorSignatureNotFoundError'
+
+  signature: Hex
+
   constructor(signature: Hex, { docsPath }: { docsPath: string }) {
     super(
       [
         `Encoded error signature "${signature}" not found on ABI.`,
         'Make sure you are using the correct ABI and that the error exists on it.',
-        `You can look up the signature here: https://openchain.xyz/signatures?query=${signature}.`,
+        `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`,
       ].join('\n'),
       {
         docsPath,
       },
     )
+    this.signature = signature
   }
 }
 
@@ -278,15 +281,22 @@ export class BytesSizeMismatchError extends BaseError {
 export class DecodeLogDataMismatch extends BaseError {
   override name = 'DecodeLogDataMismatch'
 
+  abiItem: AbiEvent
   data: Hex
   params: readonly AbiParameter[]
   size: number
 
   constructor({
+    abiItem,
     data,
     params,
     size,
-  }: { data: Hex; params: readonly AbiParameter[]; size: number }) {
+  }: {
+    abiItem: AbiEvent
+    data: Hex
+    params: readonly AbiParameter[]
+    size: number
+  }) {
     super(
       [
         `Data size of ${size} bytes is too small for non-indexed event parameters.`,
@@ -299,6 +309,7 @@ export class DecodeLogDataMismatch extends BaseError {
       },
     )
 
+    this.abiItem = abiItem
     this.data = data
     this.params = params
     this.size = size
@@ -307,11 +318,14 @@ export class DecodeLogDataMismatch extends BaseError {
 
 export class DecodeLogTopicsMismatch extends BaseError {
   override name = 'DecodeLogTopicsMismatch'
+
+  abiItem: AbiEvent
+
   constructor({
     abiItem,
     param,
   }: {
-    abiItem: AbiItem
+    abiItem: AbiEvent
     param: AbiParameter & { indexed: boolean }
   }) {
     super(
@@ -321,6 +335,8 @@ export class DecodeLogTopicsMismatch extends BaseError {
         } on event "${formatAbiItem(abiItem, { includeName: true })}".`,
       ].join('\n'),
     )
+
+    this.abiItem = abiItem
   }
 }
 

package/src/errors/base.ts

@@ -60,13 +60,16 @@ export class BaseError extends Error {
     this.shortMessage = shortMessage
   }
 
-  walk(fn?: (err: unknown) => boolean) {
-    return this.#walk(this, fn)
+  walk(): Error
+  walk(fn: (err: unknown) => boolean): Error | null
+  walk(fn?: any): any {
+    return walk(this, fn)
   }
+}
 
-  #walk(err: unknown, fn?: (err: unknown) => boolean): unknown {
-    if (fn?.(err)) return err
-    if ((err as Error).cause) return this.#walk((err as Error).cause, fn)
-    return err
-  }
+function walk(err: unknown, fn?: (err: unknown) => boolean): unknown {
+  if (fn?.(err)) return err
+  if (err && typeof err === 'object' && 'cause' in err)
+    return walk(err.cause, fn)
+  return fn ? null : err
 }

package/src/errors/contract.ts

@@ -15,6 +15,7 @@ import { getAbiItem } from '../utils/abi/getAbiItem.js'
 import { formatEther } from '../utils/unit/formatEther.js'
 import { formatGwei } from '../utils/unit/formatGwei.js'
 
+import { AbiErrorSignatureNotFoundError } from './abi.js'
 import { BaseError } from './base.js'
 import { prettyPrint } from './transaction.js'
 import { getContractAddress } from './utils.js'
@@ -154,6 +155,7 @@ export class ContractFunctionRevertedError extends BaseError {
 
   data?: DecodeErrorResultReturnType
   reason?: string
+  signature?: Hex
 
   constructor({
     abi,
@@ -161,56 +163,75 @@ export class ContractFunctionRevertedError extends BaseError {
     functionName,
     message,
   }: { abi: Abi; data?: Hex; functionName: string; message?: string }) {
+    let cause: Error | undefined
     let decodedData: DecodeErrorResultReturnType | undefined = undefined
     let metaMessages
     let reason
     if (data && data !== '0x') {
-      decodedData = decodeErrorResult({ abi, data })
-      const { abiItem, errorName, args: errorArgs } = decodedData
-      if (errorName === 'Error') {
-        reason = (errorArgs as [string])[0]
-      } else if (errorName === 'Panic') {
-        const [firstArg] = errorArgs as [number]
-        reason = panicReasons[firstArg as keyof typeof panicReasons]
-      } else {
-        const errorWithParams = abiItem
-          ? formatAbiItem(abiItem, { includeName: true })
-          : undefined
-        const formattedArgs =
-          abiItem && errorArgs
-            ? formatAbiItemWithArgs({
-                abiItem,
-                args: errorArgs,
-                includeFunctionName: false,
-                includeName: false,
-              })
+      try {
+        decodedData = decodeErrorResult({ abi, data })
+        const { abiItem, errorName, args: errorArgs } = decodedData
+        if (errorName === 'Error') {
+          reason = (errorArgs as [string])[0]
+        } else if (errorName === 'Panic') {
+          const [firstArg] = errorArgs as [number]
+          reason = panicReasons[firstArg as keyof typeof panicReasons]
+        } else {
+          const errorWithParams = abiItem
+            ? formatAbiItem(abiItem, { includeName: true })
             : undefined
+          const formattedArgs =
+            abiItem && errorArgs
+              ? formatAbiItemWithArgs({
+                  abiItem,
+                  args: errorArgs,
+                  includeFunctionName: false,
+                  includeName: false,
+                })
+              : undefined
 
-        metaMessages = [
-          errorWithParams ? `Error: ${errorWithParams}` : '',
-          formattedArgs && formattedArgs !== '()'
-            ? `       ${[...Array(errorName?.length ?? 0).keys()]
-                .map(() => ' ')
-                .join('')}${formattedArgs}`
-            : '',
-        ]
+          metaMessages = [
+            errorWithParams ? `Error: ${errorWithParams}` : '',
+            formattedArgs && formattedArgs !== '()'
+              ? `       ${[...Array(errorName?.length ?? 0).keys()]
+                  .map(() => ' ')
+                  .join('')}${formattedArgs}`
+              : '',
+          ]
+        }
+      } catch (err) {
+        cause = err as Error
       }
     } else if (message) reason = message
 
+    let signature: Hex | undefined
+    if (cause instanceof AbiErrorSignatureNotFoundError) {
+      signature = cause.signature
+      metaMessages = [
+        `Unable to decode signature "${signature}" as it was not found on the provided ABI.`,
+        'Make sure you are using the correct ABI and that the error exists on it.',
+        `You can look up the decoded signature here: https://openchain.xyz/signatures?query=${signature}.`,
+      ]
+    }
+
     super(
-      reason && reason !== 'execution reverted'
+      (reason && reason !== 'execution reverted') || signature
         ? [
-            `The contract function "${functionName}" reverted with the following reason:`,
-            reason,
+            `The contract function "${functionName}" reverted with the following ${
+              signature ? 'signature' : 'reason'
+            }:`,
+            reason || signature,
           ].join('\n')
         : `The contract function "${functionName}" reverted.`,
       {
+        cause,
         metaMessages,
       },
     )
 
-    this.reason = reason
     this.data = decodedData
+    this.reason = reason
+    this.signature = signature
   }
 }
 

package/src/errors/fee.ts

@@ -0,0 +1,27 @@
+import { formatGwei } from '../utils/unit/formatGwei.js'
+import { BaseError } from './base.js'
+
+export class BaseFeeScalarError extends BaseError {
+  override name = 'BaseFeeScalarError'
+  constructor() {
+    super('`baseFeeMultiplier` must be greater than 1.')
+  }
+}
+
+export class Eip1559FeesNotSupportedError extends BaseError {
+  override name = 'Eip1559FeesNotSupportedError'
+  constructor() {
+    super('Chain does not support EIP-1559 fees.')
+  }
+}
+
+export class MaxFeePerGasTooLowError extends BaseError {
+  override name = 'MaxFeePerGasTooLowError'
+  constructor({ maxPriorityFeePerGas }: { maxPriorityFeePerGas: bigint }) {
+    super(
+      `\`maxFeePerGas\` cannot be less than the \`maxPriorityFeePerGas\` (${formatGwei(
+        maxPriorityFeePerGas,
+      )} gwei).`,
+    )
+  }
+}

package/src/errors/node.ts

@@ -88,7 +88,8 @@ export class NonceTooHighError extends BaseError {
 }
 
 export class NonceTooLowError extends BaseError {
-  static nodeMessage = /nonce too low|transaction already imported/
+  static nodeMessage =
+    /nonce too low|transaction already imported|already known/
   override name = 'NonceTooLowError'
   constructor({ cause, nonce }: { cause?: BaseError; nonce?: number } = {}) {
     super(

package/src/errors/request.ts

@@ -6,7 +6,7 @@ import { getUrl } from './utils.js'
 export class HttpRequestError extends BaseError {
   override name = 'HttpRequestError'
 
-  body?: { [key: string]: unknown }
+  body?: { [x: string]: unknown } | { [y: string]: unknown }[]
   headers?: Headers
   status?: number
   url: string
@@ -18,7 +18,7 @@ export class HttpRequestError extends BaseError {
     status,
     url,
   }: {
-    body?: { [key: string]: unknown }
+    body?: { [x: string]: unknown } | { [y: string]: unknown }[]
     details?: string
     headers?: Headers
     status?: number
@@ -68,7 +68,7 @@ export class RpcRequestError extends BaseError {
     error,
     url,
   }: {
-    body: { [key: string]: unknown }
+    body: { [x: string]: unknown } | { [y: string]: unknown }[]
     error: { code: number; message: string }
     url: string
   }) {
@@ -88,7 +88,7 @@ export class TimeoutError extends BaseError {
     body,
     url,
   }: {
-    body: { [key: string]: unknown }
+    body: { [x: string]: unknown } | { [y: string]: unknown }[]
     url: string
   }) {
     super('The request took too long to respond.', {