viem 2.48.11 → 2.49.2

package/clients/transports/http.ts

@@ -81,6 +81,17 @@ export type HttpTransportErrorType =
   | UrlRequiredErrorType
   | ErrorType
 
+let signalId = 0
+const signalIds = new WeakMap<AbortSignal, number>()
+function getSignalId(signal: AbortSignal | undefined) {
+  if (!signal) return 'default'
+  const id = signalIds.get(signal)
+  if (id !== undefined) return id
+  const nextId = signalId++
+  signalIds.set(signal, nextId)
+  return nextId
+}
+
 /**
  * @description Creates a HTTP transport that connects to a JSON-RPC API.
  */
@@ -125,11 +136,14 @@ export function http<
         key,
         methods,
         name,
-        async request({ method, params }) {
+        async request({ method, params }, options) {
           const body = { method, params }
+          const fetchOptions = options?.signal
+            ? { signal: options.signal }
+            : undefined
 
           const { schedule } = createBatchScheduler({
-            id: url_,
+            id: `${url_}.${getSignalId(options?.signal)}`,
             wait,
             shouldSplitBatch(requests) {
               return requests.length > batchSize
@@ -137,6 +151,7 @@ export function http<
             fn: (body: RpcRequest[]) =>
               rpcClient.request({
                 body,
+                fetchOptions,
               }),
             sort: (a, b) => a.id - b.id,
           })
@@ -147,6 +162,7 @@ export function http<
               : [
                   await rpcClient.request({
                     body,
+                    fetchOptions,
                   }),
                 ]
 

package/errors/utils.ts

@@ -1,9 +1,28 @@
 import type { Address } from 'abitype'
 
 export type ErrorType<name extends string = 'Error'> = Error & { name: name }
+export type AbortErrorType = ErrorType<'AbortError'>
 
 export const getContractAddress = (address: Address) => address
 
+export function getAbortError(signal?: AbortSignal | undefined) {
+  if (signal?.reason) return signal.reason
+  if (typeof DOMException === 'function')
+    return new DOMException('This operation was aborted', 'AbortError')
+  const error = new Error('This operation was aborted') as AbortErrorType
+  error.name = 'AbortError'
+  return error
+}
+
+export function isAbortError(error: unknown): error is AbortErrorType {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'name' in error &&
+    error.name === 'AbortError'
+  )
+}
+
 /**
  * Returns the URL with any embedded basic-auth credentials stripped, so
  * error messages and logs don't leak secrets when an RPC URL like

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.48.11'
+export const version = '2.49.2'

package/index.ts

@@ -1135,6 +1135,7 @@ export type {
   EIP1193Parameters,
   EIP1193Provider,
   EIP1193RequestFn,
+  EIP1193RequestOptions,
   EIP1474Methods,
   NetworkSync,
   PaymasterRpcSchema,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.48.11",
+  "version": "2.49.2",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/tempo/Formatters.ts

@@ -122,12 +122,15 @@ export function formatTransactionRequest(
   const [keyType, keyData] = (() => {
     const type =
       account && 'keyType' in account ? account.keyType : account?.source
-    if (!type) return [request.keyType, request.keyData]
+    if (!type) return [request.keyType, shimKeyData(request.keyData)]
     if (type === 'webAuthn')
-      // TODO: derive correct bytes size of key data based on webauthn create metadata.
-      return ['webAuthn', `0x${'ff'.repeat(1400)}`]
+      // Send a 2-byte big-endian length hint (1400 = 0x0578) instead of a
+      // 1400-byte dummy blob.  The node's gas estimator expects key_data to
+      // be 1, 2, or 4 bytes encoding the desired WebAuthn signature size;
+      // anything else falls back to the 800-byte default.
+      return ['webAuthn', '0x0578']
     if (['p256', 'secp256k1'].includes(type)) return [type, undefined]
-    return [request.keyType, request.keyData]
+    return [request.keyType, shimKeyData(request.keyData)]
   })()
 
   const keyId =
@@ -157,3 +160,16 @@ export function formatTransactionRequest(
       : {}),
   } as never
 }
+
+/**
+ * Auto-shim user-provided keyData that is longer than 4 bytes into a
+ * 2-byte big-endian length hint.  The node gas estimator only accepts
+ * 1, 2, or 4-byte key_data as a size hint; anything else silently falls
+ * back to the 800-byte default.
+ */
+function shimKeyData(data: Hex.Hex | undefined): Hex.Hex | undefined {
+  if (!data) return data
+  const byteLength = (data.length - 2) / 2 // subtract "0x" prefix
+  if (byteLength <= 4) return data
+  return Hex.fromNumber(byteLength, { size: 2 })
+}

package/tempo/actions/wallet.ts

@@ -3,11 +3,18 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { ErrorType as CoreErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
+import type { OneOf } from '../../types/utils.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import type { TransactionReceipt } from '../Transaction.js'
 
 /**
- * Opens the wallet send flow with optional pre-filled send fields.
+ * Transfers a TIP-20 token. Discriminated on `editable`:
+ *
+ * - omitted or `false` (default): read-only. Uses an access key when
+ *   one matches (signs without showing the wallet UI), otherwise falls
+ *   back to a confirm dialog the user has to approve.
+ * - `true`: editable. Opens the wallet send UI with the supplied fields
+ *   pre-filled for the user to confirm or edit before signing.
  *
  * @example
  * ```ts
@@ -18,53 +25,110 @@ import type { TransactionReceipt } from '../Transaction.js'
  *   transport: custom(window.ethereum),
  * })
  *
- * const { receipt } = await Actions.wallet.send(client, {
+ * // Read-only (no UI when an access key matches)
+ * const { receipt } = await Actions.wallet.transfer(client, {
+ *   amount: '1.5',
  *   to: '0x...',
  *   token: '0x...',
- *   value: '1.5',
+ * })
+ *
+ * // Editable (opens wallet UI)
+ * await Actions.wallet.transfer(client, {
+ *   editable: true,
+ *   token: 'pathUSD',
  * })
  * ```
  *
  * @param client - Client.
  * @param parameters - Parameters.
- * @returns The submitted send receipt and chain ID.
+ * @returns The submitted transfer receipt and chain ID.
  */
-export async function send<chain extends Chain | undefined>(
+export async function transfer<chain extends Chain | undefined>(
   client: Client<Transport, chain>,
-  parameters: send.Parameters = {},
-): Promise<send.ReturnValue> {
+  parameters: transfer.Parameters,
+): Promise<transfer.ReturnValue> {
   return client.request<{
-    Method: 'wallet_send'
-    Parameters: [send.Parameters]
-    ReturnType: send.ReturnValue
+    Method: 'wallet_transfer'
+    Parameters: [transfer.Parameters]
+    ReturnType: transfer.ReturnValue
   }>(
     {
-      method: 'wallet_send',
+      method: 'wallet_transfer',
       params: [parameters],
     },
     { retryCount: 0 },
   )
 }
 
-export declare namespace send {
+export declare namespace transfer {
+  /**
+   * Read-only variant — uses an access key when one matches, otherwise
+   * shows a confirm dialog.
+   */
+  type ReadOnly = {
+    /** Human-readable amount to transfer (for example, `"1.5"`). */
+    amount: string
+    /**
+     * Skip the editable wallet UI. The wallet still shows a confirm
+     * dialog when no matching access key is available.
+     * @default false
+     */
+    editable?: false | undefined
+    /**
+     * Address to transfer tokens from. Defaults to the active account. When
+     * set to a different address, the call uses `transferFrom` and requires
+     * the active account to have an allowance from `from`.
+     */
+    from?: Address | undefined
+    /**
+     * UTF-8 memo (max 32 bytes) to attach to the transfer.
+     */
+    memo?: string | undefined
+    /** Recipient address. */
+    to: Address
+    /**
+     * Token to transfer, accepted as either a contract address or a curated
+     * tokenlist symbol (case-insensitive, for example `"pathUsd"`). Symbols
+     * are resolved against the curated tokenlist on the active chain.
+     */
+    token: Address | string
+  }
+
+  /** Editable variant — opens the wallet send UI with optional pre-filled fields. */
+  type Editable = {
+    /** Human-readable amount to pre-fill (for example, `"1.5"`). */
+    amount?: string | undefined
+    /** Show the wallet UI for the user to confirm or edit. */
+    editable: true
+    /**
+     * UTF-8 memo (max 32 bytes) to attach to the transfer.
+     */
+    memo?: string | undefined
+    /** Recipient address to pre-fill. */
+    to?: Address | undefined
+    /**
+     * Token to pre-fill, accepted as either a contract address or a curated
+     * tokenlist symbol (case-insensitive, for example `"pathUsd"`). Symbols
+     * are resolved against the curated tokenlist on the active chain. Omit
+     * to let the user choose.
+     */
+    token?: Address | string | undefined
+  }
+
   export type Parameters = {
+    /** Chain id. Defaults to the active chain. */
+    chainId?: number | undefined
     /**
      * Fee payer override. `false` to disable the wallet's default fee payer,
      * a URL string to use a custom fee payer service.
      */
     feePayer?: boolean | string | undefined
-    /** Recipient address to pre-fill. */
-    to?: Address | undefined
-    /** Token contract address to pre-fill. Omit to let the user choose. */
-    token?: Address | undefined
-    /** Human-readable amount to pre-fill (for example, "1.5"). */
-    value?: string | undefined
-  }
+  } & OneOf<ReadOnly | Editable>
 
   export type ReturnValue = {
-    /** Chain ID the send was submitted to. */
+    /** Chain ID the transfer was submitted to. */
     chainId: number
-    /** Receipt of the submitted send. */
+    /** Receipt of the submitted transfer. */
     receipt: TransactionReceipt
   }
 

package/types/eip1193.ts

@@ -2140,6 +2140,8 @@ export type EIP1193RequestOptions = {
   retryDelay?: number | undefined
   /** The max number of times to retry. */
   retryCount?: number | undefined
+  /** Abort signal to cancel the request. */
+  signal?: AbortSignal | undefined
   /** Unique identifier for the request. */
   uid?: string | undefined
 }

package/utils/buildRequest.ts

@@ -66,7 +66,12 @@ import {
   WalletConnectSessionSettlementError,
   type WalletConnectSessionSettlementErrorType,
 } from '../errors/rpc.js'
-import type { ErrorType } from '../errors/utils.js'
+import {
+  type AbortErrorType,
+  type ErrorType,
+  getAbortError,
+  isAbortError,
+} from '../errors/utils.js'
 import type {
   EIP1193RequestFn,
   EIP1193RequestOptions,
@@ -113,18 +118,22 @@ export type RequestErrorType =
   | WalletConnectSessionSettlementErrorType
   | WebSocketRequestErrorType
   | WithRetryErrorType
+  | AbortErrorType
   | ErrorType
 
-export function buildRequest<request extends (args: any) => Promise<any>>(
-  request: request,
-  options: EIP1193RequestOptions = {},
-): EIP1193RequestFn {
+export function buildRequest<
+  request extends (
+    args: any,
+    options?: { signal?: AbortSignal | undefined } | undefined,
+  ) => Promise<any>,
+>(request: request, options: EIP1193RequestOptions = {}): EIP1193RequestFn {
   return async (args, overrideOptions = {}) => {
     const {
       dedupe = false,
       methods,
       retryDelay = 150,
       retryCount = 3,
+      signal,
       uid,
     } = {
       ...options,
@@ -141,6 +150,8 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
         method,
       })
 
+    if (signal?.aborted) throw getAbortError(signal)
+
     const requestId = dedupe
       ? hashString(`${uid}.${stringify(args)}`)
       : undefined
@@ -149,8 +160,11 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
         withRetry(
           async () => {
             try {
-              return await request(args)
+              return await request(args, signal ? { signal } : undefined)
             } catch (err_) {
+              if (signal?.aborted) throw getAbortError(signal)
+              if (isAbortError(err_)) throw err_
+
               const err = err_ as unknown as RpcError<
                 RpcErrorCode | ProviderRpcErrorCode
               >
@@ -264,6 +278,7 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
               return ~~(1 << count) * retryDelay
             },
             retryCount,
+            signal,
             shouldRetry: ({ error }) => shouldRetry(error),
           },
         ),
@@ -274,6 +289,7 @@ export function buildRequest<request extends (args: any) => Promise<any>>(
 
 /** @internal */
 export function shouldRetry(error: Error) {
+  if (isAbortError(error)) return false
   if ('code' in error && typeof error.code === 'number') {
     if (error.code === -1) return true // Unknown error
     if (error.code === LimitExceededRpcError.code) return true

package/utils/ccip.ts

@@ -15,8 +15,9 @@ import {
   HttpRequestError,
   type HttpRequestErrorType,
 } from '../errors/request.js'
-import type { ErrorType } from '../errors/utils.js'
+import { type ErrorType, getAbortError, isAbortError } from '../errors/utils.js'
 import type { Chain } from '../types/chain.js'
+import type { EIP1193RequestOptions } from '../types/eip1193.js'
 import type { Hex } from '../types/misc.js'
 import { decodeErrorResult } from './abi/decodeErrorResult.js'
 import { encodeAbiParameters } from './abi/encodeAbiParameters.js'
@@ -65,8 +66,9 @@ export async function offchainLookup<chain extends Chain | undefined>(
     blockNumber,
     blockTag,
     data,
+    requestOptions,
     to,
-  }: Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
+  }: Pick<CallParameters, 'blockNumber' | 'blockTag' | 'requestOptions'> & {
     data: Hex
     to: Address
   },
@@ -90,9 +92,10 @@ export async function offchainLookup<chain extends Chain | undefined>(
     const result = urls.includes(localBatchGatewayUrl)
       ? await localBatchGatewayRequest({
           data: callData,
-          ccipRequest: ccipRequest_,
+          ccipRequest: (parameters) =>
+            ccipRequest_({ ...parameters, requestOptions }),
         })
-      : await ccipRequest_({ data: callData, sender, urls })
+      : await ccipRequest_({ data: callData, requestOptions, sender, urls })
 
     const { data: data_ } = await call(client, {
       blockNumber,
@@ -104,11 +107,16 @@ export async function offchainLookup<chain extends Chain | undefined>(
           [result, extraData],
         ),
       ]),
+      requestOptions,
       to,
     } as CallParameters)
 
     return data_!
   } catch (err) {
+    if (requestOptions?.signal?.aborted)
+      throw getAbortError(requestOptions.signal)
+    if (isAbortError(err)) throw err
+
     throw new OffchainLookupError({
       callbackSelector,
       cause: err as BaseError,
@@ -122,6 +130,7 @@ export async function offchainLookup<chain extends Chain | undefined>(
 
 export type CcipRequestParameters = {
   data: Hex
+  requestOptions?: EIP1193RequestOptions | undefined
   sender: Address
   urls: readonly string[]
 }
@@ -135,12 +144,16 @@ export type CcipRequestErrorType =
 
 export async function ccipRequest({
   data,
+  requestOptions,
   sender,
   urls,
 }: CcipRequestParameters): Promise<CcipRequestReturnType> {
   let error = new Error('An unknown error occurred.')
 
   for (let i = 0; i < urls.length; i++) {
+    if (requestOptions?.signal?.aborted)
+      throw getAbortError(requestOptions.signal)
+
     const url = urls[i]
     const method = url.includes('{data}') ? 'GET' : 'POST'
     const body = method === 'POST' ? { data, sender } : undefined
@@ -154,6 +167,7 @@ export async function ccipRequest({
           body: JSON.stringify(body),
           headers,
           method,
+          ...(requestOptions?.signal ? { signal: requestOptions.signal } : {}),
         },
       )
 
@@ -189,6 +203,10 @@ export async function ccipRequest({
 
       return result
     } catch (err) {
+      if (requestOptions?.signal?.aborted)
+        throw getAbortError(requestOptions.signal)
+      if (isAbortError(err)) throw err
+
       error = new HttpRequestError({
         body,
         details: (err as Error).message,

package/utils/promise/withRetry.ts

@@ -1,4 +1,8 @@
-import type { ErrorType } from '../../errors/utils.js'
+import {
+  type ErrorType,
+  getAbortError,
+  isAbortError,
+} from '../../errors/utils.js'
 import { wait } from '../wait.js'
 
 export type WithRetryParameters = {
@@ -19,6 +23,8 @@ export type WithRetryParameters = {
         error: Error
       }) => Promise<boolean> | boolean)
     | undefined
+  // AbortSignal to cancel retries.
+  signal?: AbortSignal | undefined
 }
 
 export type WithRetryErrorType = ErrorType
@@ -29,14 +35,27 @@ export function withRetry<data>(
     delay: delay_ = 100,
     retryCount = 2,
     shouldRetry = () => true,
+    signal,
   }: WithRetryParameters = {},
 ) {
   return new Promise<data>((resolve, reject) => {
     const attemptRetry = async ({ count = 0 } = {}) => {
+      if (signal?.aborted) {
+        reject(getAbortError(signal))
+        return
+      }
+
       const retry = async ({ error }: { error: Error }) => {
         const delay =
           typeof delay_ === 'function' ? delay_({ count, error }) : delay_
-        if (delay) await wait(delay)
+        if (delay) {
+          try {
+            await wait(delay, { signal })
+          } catch (err) {
+            reject(err)
+            return
+          }
+        }
         attemptRetry({ count: count + 1 })
       }
 
@@ -44,6 +63,14 @@ export function withRetry<data>(
         const data = await fn()
         resolve(data)
       } catch (err) {
+        if (signal?.aborted) {
+          reject(getAbortError(signal))
+          return
+        }
+        if (isAbortError(err)) {
+          reject(err)
+          return
+        }
         if (
           count < retryCount &&
           (await shouldRetry({ count, error: err as Error }))

package/utils/promise/withTimeout.ts

@@ -1,4 +1,4 @@
-import type { ErrorType } from '../../errors/utils.js'
+import { type ErrorType, isAbortError } from '../../errors/utils.js'
 
 export type WithTimeoutErrorType = ErrorType
 
@@ -24,8 +24,8 @@ export function withTimeout<data>(
   return new Promise((resolve, reject) => {
     ;(async () => {
       let timeoutId!: NodeJS.Timeout
+      const controller = new AbortController()
       try {
-        const controller = new AbortController()
         if (timeout > 0) {
           timeoutId = setTimeout(() => {
             if (signal) {
@@ -37,7 +37,10 @@ export function withTimeout<data>(
         }
         resolve(await fn({ signal: controller?.signal || null }))
       } catch (err) {
-        if ((err as Error)?.name === 'AbortError') reject(errorInstance)
+        if (controller?.signal.aborted && isAbortError(err)) {
+          reject(errorInstance)
+          return
+        }
         reject(err)
       } finally {
         clearTimeout(timeoutId)

package/utils/rpc/http.ts

@@ -4,7 +4,11 @@ import {
   TimeoutError,
   type TimeoutErrorType,
 } from '../../errors/request.js'
-import type { ErrorType } from '../../errors/utils.js'
+import {
+  type ErrorType,
+  getAbortError,
+  isAbortError,
+} from '../../errors/utils.js'
 import type { RpcRequest, RpcResponse } from '../../types/rpc.js'
 import type { MaybePromise } from '../../types/utils.js'
 import {
@@ -174,6 +178,8 @@ export function getHttpRpcClient(
 
         return data
       } catch (err) {
+        if (signal_?.aborted) throw getAbortError(signal_)
+        if (isAbortError(err)) throw err
         if (err instanceof HttpRequestError) throw err
         if (err instanceof TimeoutError) throw err
         throw new HttpRequestError({

package/utils/wait.ts

@@ -1,3 +1,25 @@
-export async function wait(time: number) {
-  return new Promise((res) => setTimeout(res, time))
+import { getAbortError } from '../errors/utils.js'
+
+export async function wait(
+  time: number,
+  { signal }: { signal?: AbortSignal | undefined } = {},
+) {
+  return new Promise<void>((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(getAbortError(signal))
+      return
+    }
+
+    const cleanup = () => signal?.removeEventListener('abort', onAbort)
+    const timeout = setTimeout(() => {
+      cleanup()
+      resolve()
+    }, time)
+    const onAbort = () => {
+      clearTimeout(timeout)
+      cleanup()
+      reject(getAbortError(signal))
+    }
+    signal?.addEventListener('abort', onAbort, { once: true })
+  })
 }