viem 2.14.1 → 2.15.0

package/utils/buildRequest.ts

@@ -55,9 +55,13 @@ import type {
   EIP1193RequestFn,
   EIP1193RequestOptions,
 } from '../types/eip1193.js'
+import { stringToHex } from './encoding/toHex.js'
+import { keccak256 } from './hash/keccak256.js'
 import type { CreateBatchSchedulerErrorType } from './promise/createBatchScheduler.js'
+import { withDedupe } from './promise/withDedupe.js'
 import { type WithRetryErrorType, withRetry } from './promise/withRetry.js'
 import type { GetSocketRpcClientErrorType } from './rpc/socket.js'
+import { stringify } from './stringify.js'
 
 export type RequestErrorType =
   | ChainDisconnectedErrorType
@@ -94,98 +98,110 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
   options: EIP1193RequestOptions = {},
 ): EIP1193RequestFn {
   return async (args, overrideOptions = {}) => {
-    const { retryDelay = 150, retryCount = 3 } = {
+    const {
+      dedupe = false,
+      retryDelay = 150,
+      retryCount = 3,
+      uid,
+    } = {
       ...options,
       ...overrideOptions,
     }
-    return withRetry(
-      async () => {
-        try {
-          return await request(args)
-        } catch (err_) {
-          const err = err_ as unknown as RpcError<
-            RpcErrorCode | ProviderRpcErrorCode
-          >
-          switch (err.code) {
-            // -32700
-            case ParseRpcError.code:
-              throw new ParseRpcError(err)
-            // -32600
-            case InvalidRequestRpcError.code:
-              throw new InvalidRequestRpcError(err)
-            // -32601
-            case MethodNotFoundRpcError.code:
-              throw new MethodNotFoundRpcError(err)
-            // -32602
-            case InvalidParamsRpcError.code:
-              throw new InvalidParamsRpcError(err)
-            // -32603
-            case InternalRpcError.code:
-              throw new InternalRpcError(err)
-            // -32000
-            case InvalidInputRpcError.code:
-              throw new InvalidInputRpcError(err)
-            // -32001
-            case ResourceNotFoundRpcError.code:
-              throw new ResourceNotFoundRpcError(err)
-            // -32002
-            case ResourceUnavailableRpcError.code:
-              throw new ResourceUnavailableRpcError(err)
-            // -32003
-            case TransactionRejectedRpcError.code:
-              throw new TransactionRejectedRpcError(err)
-            // -32004
-            case MethodNotSupportedRpcError.code:
-              throw new MethodNotSupportedRpcError(err)
-            // -32005
-            case LimitExceededRpcError.code:
-              throw new LimitExceededRpcError(err)
-            // -32006
-            case JsonRpcVersionUnsupportedError.code:
-              throw new JsonRpcVersionUnsupportedError(err)
-            // 4001
-            case UserRejectedRequestError.code:
-              throw new UserRejectedRequestError(err)
-            // 4100
-            case UnauthorizedProviderError.code:
-              throw new UnauthorizedProviderError(err)
-            // 4200
-            case UnsupportedProviderMethodError.code:
-              throw new UnsupportedProviderMethodError(err)
-            // 4900
-            case ProviderDisconnectedError.code:
-              throw new ProviderDisconnectedError(err)
-            // 4901
-            case ChainDisconnectedError.code:
-              throw new ChainDisconnectedError(err)
-            // 4902
-            case SwitchChainError.code:
-              throw new SwitchChainError(err)
-            // CAIP-25: User Rejected Error
-            // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
-            case 5000:
-              throw new UserRejectedRequestError(err)
-            default:
-              if (err_ instanceof BaseError) throw err_
-              throw new UnknownRpcError(err as Error)
-          }
-        }
-      },
-      {
-        delay: ({ count, error }) => {
-          // If we find a Retry-After header, let's retry after the given time.
-          if (error && error instanceof HttpRequestError) {
-            const retryAfter = error?.headers?.get('Retry-After')
-            if (retryAfter?.match(/\d/))
-              return Number.parseInt(retryAfter) * 1000
-          }
+    const requestId = dedupe
+      ? keccak256(stringToHex(`${uid}.${stringify(args)}`))
+      : undefined
+    return withDedupe(
+      () =>
+        withRetry(
+          async () => {
+            try {
+              return await request(args)
+            } catch (err_) {
+              const err = err_ as unknown as RpcError<
+                RpcErrorCode | ProviderRpcErrorCode
+              >
+              switch (err.code) {
+                // -32700
+                case ParseRpcError.code:
+                  throw new ParseRpcError(err)
+                // -32600
+                case InvalidRequestRpcError.code:
+                  throw new InvalidRequestRpcError(err)
+                // -32601
+                case MethodNotFoundRpcError.code:
+                  throw new MethodNotFoundRpcError(err)
+                // -32602
+                case InvalidParamsRpcError.code:
+                  throw new InvalidParamsRpcError(err)
+                // -32603
+                case InternalRpcError.code:
+                  throw new InternalRpcError(err)
+                // -32000
+                case InvalidInputRpcError.code:
+                  throw new InvalidInputRpcError(err)
+                // -32001
+                case ResourceNotFoundRpcError.code:
+                  throw new ResourceNotFoundRpcError(err)
+                // -32002
+                case ResourceUnavailableRpcError.code:
+                  throw new ResourceUnavailableRpcError(err)
+                // -32003
+                case TransactionRejectedRpcError.code:
+                  throw new TransactionRejectedRpcError(err)
+                // -32004
+                case MethodNotSupportedRpcError.code:
+                  throw new MethodNotSupportedRpcError(err)
+                // -32005
+                case LimitExceededRpcError.code:
+                  throw new LimitExceededRpcError(err)
+                // -32006
+                case JsonRpcVersionUnsupportedError.code:
+                  throw new JsonRpcVersionUnsupportedError(err)
+                // 4001
+                case UserRejectedRequestError.code:
+                  throw new UserRejectedRequestError(err)
+                // 4100
+                case UnauthorizedProviderError.code:
+                  throw new UnauthorizedProviderError(err)
+                // 4200
+                case UnsupportedProviderMethodError.code:
+                  throw new UnsupportedProviderMethodError(err)
+                // 4900
+                case ProviderDisconnectedError.code:
+                  throw new ProviderDisconnectedError(err)
+                // 4901
+                case ChainDisconnectedError.code:
+                  throw new ChainDisconnectedError(err)
+                // 4902
+                case SwitchChainError.code:
+                  throw new SwitchChainError(err)
+                // CAIP-25: User Rejected Error
+                // https://docs.walletconnect.com/2.0/specs/clients/sign/error-codes#rejected-caip-25
+                case 5000:
+                  throw new UserRejectedRequestError(err)
+                default:
+                  if (err_ instanceof BaseError) throw err_
+                  throw new UnknownRpcError(err as Error)
+              }
+            }
+          },
+          {
+            delay: ({ count, error }) => {
+              // If we find a Retry-After header, let's retry after the given time.
+              if (error && error instanceof HttpRequestError) {
+                const retryAfter = error?.headers?.get('Retry-After')
+                if (retryAfter?.match(/\d/))
+                  return Number.parseInt(retryAfter) * 1000
+              }
 
-          // Otherwise, let's retry with an exponential backoff.
-          return ~~(1 << count) * retryDelay
-        },
-        retryCount,
-        shouldRetry: ({ error }) => shouldRetry(error),
-      },
+              // Otherwise, let's retry with an exponential backoff.
+              return ~~(1 << count) * retryDelay
+            },
+            retryCount,
+            shouldRetry: ({ error }) => shouldRetry(error),
+          },
+        ),
+      { enabled: dedupe, id: requestId },
     )
   }
 }

package/utils/index.ts

@@ -491,3 +491,10 @@ 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'
+export {
+  type CreateNonceManagerParameters,
+  type NonceManager,
+  type NonceManagerSource,
+  createNonceManager,
+  nonceManager,
+} from './nonceManager.js'

package/utils/nonceManager.ts

@@ -0,0 +1,132 @@
+import type { Address } from 'abitype'
+
+import { getTransactionCount } from '../actions/public/getTransactionCount.js'
+import type { Client } from '../clients/createClient.js'
+import type { MaybePromise } from '../types/utils.js'
+import { LruMap } from './lru.js'
+
+export type CreateNonceManagerParameters = {
+  source: NonceManagerSource
+}
+
+type FunctionParameters = {
+  address: Address
+  chainId: number
+}
+
+export type NonceManager = {
+  /** Get and increment a nonce. */
+  consume: (
+    parameters: FunctionParameters & { client: Client },
+  ) => Promise<number>
+  /** Increment a nonce. */
+  increment: (chainId: FunctionParameters) => void
+  /** Get a nonce. */
+  get: (chainId: FunctionParameters & { client: Client }) => Promise<number>
+  /** Reset a nonce. */
+  reset: (chainId: FunctionParameters) => void
+}
+
+/**
+ * Creates a nonce manager for auto-incrementing transaction nonces.
+ *
+ * - Docs: https://viem.sh/docs/accounts/createNonceManager
+ *
+ * @example
+ * ```ts
+ * const nonceManager = createNonceManager({
+ *   source: jsonRpc(),
+ * })
+ * ```
+ */
+export function createNonceManager(
+  parameters: CreateNonceManagerParameters,
+): NonceManager {
+  const { source } = parameters
+
+  const deltaMap = new Map()
+  const nonceMap = new LruMap<number>(8192)
+  const promiseMap = new Map<string, Promise<number>>()
+
+  const getKey = ({ address, chainId }: FunctionParameters) =>
+    `${address}.${chainId}`
+
+  return {
+    async consume({ address, chainId, client }) {
+      const key = getKey({ address, chainId })
+      const promise = this.get({ address, chainId, client })
+
+      this.increment({ address, chainId })
+      const nonce = await promise
+
+      await source.set({ address, chainId }, nonce)
+      nonceMap.set(key, nonce)
+
+      return nonce
+    },
+    async increment({ address, chainId }) {
+      const key = getKey({ address, chainId })
+      const delta = deltaMap.get(key) ?? 0
+      deltaMap.set(key, delta + 1)
+    },
+    async get({ address, chainId, client }) {
+      const key = getKey({ address, chainId })
+
+      let promise = promiseMap.get(key)
+      if (!promise) {
+        promise = (async () => {
+          try {
+            const nonce = await source.get({ address, chainId, client })
+            const previousNonce = nonceMap.get(key) ?? 0
+            if (nonce <= previousNonce) return previousNonce + 1
+            nonceMap.delete(key)
+            return nonce
+          } finally {
+            this.reset({ address, chainId })
+          }
+        })()
+        promiseMap.set(key, promise)
+      }
+
+      const delta = deltaMap.get(key) ?? 0
+      return delta + (await promise)
+    },
+    reset({ address, chainId }) {
+      const key = getKey({ address, chainId })
+      deltaMap.delete(key)
+      promiseMap.delete(key)
+    },
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// Sources
+
+export type NonceManagerSource = {
+  /** Get a nonce. */
+  get(parameters: FunctionParameters & { client: Client }): MaybePromise<number>
+  /** Set a nonce. */
+  set(parameters: FunctionParameters, nonce: number): MaybePromise<void>
+}
+
+/** JSON-RPC source for a nonce manager. */
+export function jsonRpc(): NonceManagerSource {
+  return {
+    async get(parameters) {
+      const { address, client } = parameters
+      return getTransactionCount(client, {
+        address,
+        blockTag: 'pending',
+      })
+    },
+    set() {},
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////
+// Default
+
+/** Default Nonce Manager with a JSON-RPC source. */
+export const nonceManager = /*#__PURE__*/ createNonceManager({
+  source: jsonRpc(),
+})

package/utils/promise/withDedupe.ts

@@ -0,0 +1,21 @@
+import { LruMap } from '../lru.js'
+
+/** @internal */
+export const promiseCache = /*#__PURE__*/ new LruMap<Promise<any>>(8192)
+
+type WithDedupeOptions = {
+  enabled?: boolean | undefined
+  id?: string | undefined
+}
+
+/** Deduplicates in-flight promises. */
+export function withDedupe<data>(
+  fn: () => Promise<data>,
+  { enabled = true, id }: WithDedupeOptions,
+): Promise<data> {
+  if (!enabled || !id) return fn()
+  if (promiseCache.get(id)) return promiseCache.get(id)!
+  const promise = fn().finally(() => promiseCache.delete(id))
+  promiseCache.set(id, promise)
+  return promise
+}