viem 2.48.8 → 2.49.0

package/tempo/actions/index.ts

@@ -11,4 +11,5 @@ export * as simulate from './simulate.js'
 export * as token from './token.js'
 export * as validator from './validator.js'
 export * as virtualAddress from './virtualAddress.js'
+export * as wallet from './wallet.js'
 export * as zone from './zone.js'

package/tempo/actions/wallet.ts

@@ -0,0 +1,210 @@
+import type { Address } from 'abitype'
+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 { RequestErrorType } from '../../utils/buildRequest.js'
+import type { TransactionReceipt } from '../Transaction.js'
+
+/**
+ * Opens the wallet send flow with optional pre-filled send fields.
+ *
+ * @example
+ * ```ts
+ * import { createClient, custom } from 'viem'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const { receipt } = await Actions.wallet.send(client, {
+ *   amount: '1.5',
+ *   to: '0x...',
+ *   token: '0x...',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The submitted send receipt and chain ID.
+ */
+export async function send<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: send.Parameters = {},
+): Promise<send.ReturnValue> {
+  return client.request<{
+    Method: 'wallet_send'
+    Parameters: [send.Parameters]
+    ReturnType: send.ReturnValue
+  }>(
+    {
+      method: 'wallet_send',
+      params: [parameters],
+    },
+    { retryCount: 0 },
+  )
+}
+
+export declare namespace send {
+  export type Parameters = {
+    /** Human-readable amount to pre-fill (for example, "1.5"). */
+    amount?: string | 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
+    /**
+     * UTF-8 memo (max 32 bytes) to attach to the transfer. Wallet rejects
+     * the request if the selected token does not support memos (non-TIP-20).
+     */
+    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 ReturnValue = {
+    /** Chain ID the send was submitted to. */
+    chainId: number
+    /** Receipt of the submitted send. */
+    receipt: TransactionReceipt
+  }
+
+  export type ErrorType = RequestErrorType | CoreErrorType
+}
+
+/**
+ * Opens the wallet swap flow with optional pre-filled swap fields.
+ *
+ * @example
+ * ```ts
+ * import { createClient, custom } from 'viem'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const { receipt } = await Actions.wallet.swap(client, {
+ *   amount: '1.5',
+ *   token: '0x...',
+ *   type: 'sell',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The submitted swap receipt.
+ */
+export async function swap<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: swap.Parameters = {},
+): Promise<swap.ReturnValue> {
+  return client.request<{
+    Method: 'wallet_swap'
+    Parameters: [swap.Parameters]
+    ReturnType: swap.ReturnValue
+  }>(
+    {
+      method: 'wallet_swap',
+      params: [parameters],
+    },
+    { retryCount: 0 },
+  )
+}
+
+export declare namespace swap {
+  export type Parameters = {
+    /** Human-readable amount to pre-fill (for example, "1.5"). */
+    amount?: string | undefined
+    /**
+     * Other side of the swap pair. For buys, this is the token to sell.
+     * For sells, this is the token to buy.
+     */
+    pairToken?: Address | undefined
+    /** Maximum allowed slippage as a decimal fraction, for example `0.05`. */
+    slippage?: number | undefined
+    /** Token to buy or sell. Omit to let the user choose. */
+    token?: Address | undefined
+    /** Whether the amount is an exact buy or sell amount. */
+    type?: 'buy' | 'sell' | undefined
+  }
+
+  export type ReturnValue = {
+    /** Receipt of the submitted swap. */
+    receipt: TransactionReceipt
+  }
+
+  export type ErrorType = RequestErrorType | CoreErrorType
+}
+
+/**
+ * Opens the wallet deposit flow with optional pre-filled deposit fields.
+ *
+ * @example
+ * ```ts
+ * import { createClient, custom } from 'viem'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const result = await Actions.wallet.deposit(client, {
+ *   token: '0x...',
+ *   value: '1.5',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns Receipts for onchain deposit operations, when applicable.
+ */
+export async function deposit<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: deposit.Parameters = {},
+): Promise<deposit.ReturnValue> {
+  return client.request<{
+    Method: 'wallet_deposit'
+    Parameters: [deposit.Parameters]
+    ReturnType: deposit.ReturnValue
+  }>(
+    {
+      method: 'wallet_deposit',
+      params: [parameters],
+    },
+    { retryCount: 0 },
+  )
+}
+
+export declare namespace deposit {
+  export type Parameters = {
+    /** Deposit address to pre-fill. */
+    address?: Address | undefined
+    /** Source chain ID to pre-fill. */
+    chainId?: number | undefined
+    /** Human-readable account display name. */
+    displayName?: string | 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
+  }
+
+  export type ReturnValue =
+    | {
+        /** Receipts of any onchain operations performed during the deposit. */
+        receipts?: readonly TransactionReceipt[] | undefined
+      }
+    | undefined
+
+  export type ErrorType = RequestErrorType | CoreErrorType
+}

package/tempo/actions/zone.ts

@@ -18,7 +18,6 @@ import { zeroHash } from '../../constants/bytes.js'
 import type { BaseErrorType } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type { Compute } from '../../types/utils.js'
-import { encodeAbiParameters } from '../../utils/abi/encodeAbiParameters.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
@@ -295,6 +294,8 @@ export async function encryptedDeposit<
   const encrypted = await encryptDepositPayload(
     { x: publicKey[0], yParity: publicKey[1] },
     recipient,
+    portalAddress,
+    keyIndex - 1n,
     parameters.memo,
   )
 
@@ -454,6 +455,8 @@ export async function encryptedDepositSync<
   const encrypted = await encryptDepositPayload(
     { x: publicKey[0], yParity: publicKey[1] },
     recipient,
+    portalAddress,
+    keyIndex - 1n,
     parameters.memo,
   )
 
@@ -1251,6 +1254,8 @@ export namespace signAuthorizationToken {
 async function encryptDepositPayload(
   publicKey: { x: Hex.Hex; yParity: number },
   recipient: Address,
+  portalAddress: Address,
+  keyIndex: bigint,
   memo: Hex.Hex = zeroHash,
 ): Promise<EncryptedPayload> {
   const sequencerPublicKey = PublicKey.from({
@@ -1260,6 +1265,7 @@ async function encryptDepositPayload(
 
   const { privateKey: ephemeralPrivateKey, publicKey: ephemeralPublicKey } =
     Secp256k1.createKeyPair()
+  const compressedEphemeral = PublicKey.compress(ephemeralPublicKey)
 
   const sharedSecret = Secp256k1.getSharedSecret({
     privateKey: ephemeralPrivateKey,
@@ -1269,7 +1275,7 @@ async function encryptDepositPayload(
 
   const hkdfKey = await globalThis.crypto.subtle.importKey(
     'raw',
-    sharedSecret.buffer as ArrayBuffer,
+    sharedSecret.slice(1),
     'HKDF',
     false,
     ['deriveKey'],
@@ -1278,8 +1284,12 @@ async function encryptDepositPayload(
     {
       name: 'HKDF',
       hash: 'SHA-256',
-      salt: new Uint8Array(12),
-      info: new TextEncoder().encode('ecies-aes-key'),
+      salt: new TextEncoder().encode('ecies-aes-key'),
+      info: buildDepositHkdfInfo(
+        portalAddress,
+        keyIndex,
+        Hex.fromNumber(compressedEphemeral.x, { size: 32 }),
+      ) as BufferSource,
     },
     hkdfKey,
     { name: 'AES-GCM', length: 256 },
@@ -1288,11 +1298,7 @@ async function encryptDepositPayload(
   )
 
   const nonce = Bytes.random(12)
-
-  const plaintext = encodeAbiParameters(
-    [{ type: 'address' }, { type: 'bytes32' }],
-    [recipient, memo],
-  )
+  const plaintext = buildDepositPlaintext(recipient, memo)
 
   const ciphertextWithTag = new Uint8Array(
     await globalThis.crypto.subtle.encrypt(
@@ -1305,8 +1311,6 @@ async function encryptDepositPayload(
   const ciphertext = ciphertextWithTag.slice(0, -16)
   const tag = ciphertextWithTag.slice(-16)
 
-  const compressedEphemeral = PublicKey.compress(ephemeralPublicKey)
-
   return {
     ciphertext: Hex.fromBytes(ciphertext),
     ephemeralPubkeyX: Hex.fromNumber(compressedEphemeral.x, { size: 32 }),
@@ -1315,3 +1319,23 @@ async function encryptDepositPayload(
     tag: Hex.fromBytes(tag),
   }
 }
+
+function buildDepositPlaintext(recipient: Address, memo: Hex.Hex): Bytes.Bytes {
+  return Bytes.concat(
+    Bytes.from(recipient),
+    Bytes.from(memo),
+    new Uint8Array(12),
+  )
+}
+
+function buildDepositHkdfInfo(
+  portalAddress: Address,
+  keyIndex: bigint,
+  ephemeralPubkeyX: Hex.Hex,
+): Bytes.Bytes {
+  return Bytes.concat(
+    Bytes.from(portalAddress),
+    Bytes.fromNumber(keyIndex, { size: 32 }),
+    Bytes.from(ephemeralPubkeyX),
+  )
+}

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