viem 2.49.0 → 2.49.3

package/chains/definitions/arc.ts

@@ -0,0 +1,16 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const arc = /*#__PURE__*/ defineChain({
+  id: 5042,
+  name: 'Arc',
+  nativeCurrency: {
+    name: 'USDC',
+    symbol: 'USDC',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: [],
+    },
+  },
+})

package/chains/index.ts

@@ -33,6 +33,7 @@ export { arbitrum } from './definitions/arbitrum.js'
 export { arbitrumGoerli } from './definitions/arbitrumGoerli.js'
 export { arbitrumNova } from './definitions/arbitrumNova.js'
 export { arbitrumSepolia } from './definitions/arbitrumSepolia.js'
+export { arc } from './definitions/arc.js'
 export { arcTestnet } from './definitions/arcTestnet.js'
 export { arenaz } from './definitions/arenaz.js'
 export { areonNetwork } from './definitions/areonNetwork.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.49.0'
+export const version = '2.49.3'

package/package.json

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

package/tempo/Formatters.ts

@@ -72,6 +72,10 @@ export function formatTransactionRequest(
 ): TransactionRequestRpc {
   const request = r as TransactionRequest & {
     account?: viem_Account | Address | undefined
+    feePayerSignature?:
+      | { r: Hex.Hex; s: Hex.Hex; yParity: number; v?: number | undefined }
+      | null
+      | undefined
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
@@ -100,10 +104,17 @@ export function formatTransactionRequest(
       },
     ]
 
-  // If we have marked the transaction as intended to be paid
-  // by a fee payer (feePayer: true), we will not use the fee token
-  // as the fee payer will choose their fee token.
-  if (request.feePayer === true) delete request.feeToken
+  // If we have marked the transaction as intended to be paid by a fee
+  // payer (feePayer: true), we strip the fee token from the sender's
+  // sign payload — per TIP-76 the sender does not commit to it; the fee
+  // payer chooses and commits to the token via its own signature.
+  //
+  // Once the fee payer has signed (`feePayerSignature` is populated),
+  // the relay has chosen a token and signed over it. The broadcast
+  // envelope must therefore include `feeToken` so the chain can verify
+  // the fee payer's signature and identify which token to charge.
+  if (request.feePayer === true && !request.feePayerSignature)
+    delete request.feeToken
 
   const rpc = ox_TransactionRequest.toRpc({
     ...request,
@@ -122,12 +133,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 +171,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/Transaction.ts

@@ -325,10 +325,16 @@ async function serializeTempo(
     ...(nonce ? { nonce: BigInt(nonce) } : {}),
   } satisfies TxTempo.TxEnvelopeTempo
 
-  // If we have marked the transaction as intended to be paid
-  // by a fee payer (feePayer: true), we will not use the fee token
-  // as the fee payer will choose their fee token.
-  if (feePayer === true) delete transaction_ox.feeToken
+  // If we have marked the transaction as intended to be paid by a fee
+  // payer (feePayer: true), we strip the fee token from the sender's
+  // sign payload — per TIP-76 the sender does not commit to it; the fee
+  // payer chooses and commits to the token via its own signature.
+  //
+  // Once the fee payer has signed (`feePayerSignature` is populated),
+  // the relay has chosen a token and signed over it. The broadcast
+  // envelope must therefore include `feeToken` so the chain can verify
+  // the fee payer's signature and identify which token to charge.
+  if (feePayer === true && !feePayerSignature) delete transaction_ox.feeToken
 
   if (signature && typeof transaction.feePayer === 'object') {
     const tx = TxTempo.from(transaction_ox, {
@@ -372,8 +378,12 @@ async function serializeTempo(
 
   return TxTempo.serialize(
     // If we have specified a fee payer, the user will not be signing over the fee token.
-    // Defer the fee token signing to the fee payer.
-    { ...transaction_ox, ...(feePayer ? { feeToken: undefined } : {}) },
+    // Defer the fee token signing to the fee payer. Once the fee payer has signed,
+    // keep `feeToken` so the broadcast envelope carries the token the chain must charge.
+    {
+      ...transaction_ox,
+      ...(feePayer && !feePayerSignature ? { feeToken: undefined } : {}),
+    },
     {
       feePayerSignature: undefined,
       signature,

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,46 +25,83 @@ 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...',
  * })
+ *
+ * // 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 type Parameters = {
-    /** Human-readable amount to pre-fill (for example, "1.5"). */
-    amount?: string | undefined
+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
     /**
-     * Fee payer override. `false` to disable the wallet's default fee payer,
-     * a URL string to use a custom fee payer service.
+     * Skip the editable wallet UI. The wallet still shows a confirm
+     * dialog when no matching access key is available.
+     * @default false
      */
-    feePayer?: boolean | string | undefined
+    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
     /**
-     * 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).
+     * 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. */
@@ -71,10 +115,20 @@ export declare namespace send {
     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
+  } & 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
   }