viem 2.49.3 → 2.50.4

package/constants/solidity.ts

@@ -13,7 +13,7 @@ export const panicReasons = {
   81: 'Attempted to call a zero-initialized variable of internal function type.',
 } as const
 
-export const solidityError: AbiError = {
+export const solidityError = {
   inputs: [
     {
       name: 'message',
@@ -22,8 +22,8 @@ export const solidityError: AbiError = {
   ],
   name: 'Error',
   type: 'error',
-}
-export const solidityPanic: AbiError = {
+} as const satisfies AbiError
+export const solidityPanic = {
   inputs: [
     {
       name: 'reason',
@@ -32,4 +32,4 @@ export const solidityPanic: AbiError = {
   ],
   name: 'Panic',
   type: 'error',
-}
+} as const satisfies AbiError

package/errors/version.ts

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

package/index.ts

@@ -1465,6 +1465,10 @@ export {
   offchainLookupAbiItem,
   offchainLookupSignature,
 } from './utils/ccip.js'
+export {
+  type CcipReadTunnelParameters,
+  ccipReadTunnel,
+} from './utils/ccipTunnel.js'
 export {
   type AssertCurrentChainErrorType,
   type AssertCurrentChainParameters,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.49.3",
+  "version": "2.50.4",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -124,6 +124,11 @@
       "import": "./_esm/tempo/actions/index.js",
       "default": "./_cjs/tempo/actions/index.js"
     },
+    "./tempo/chains": {
+      "types": "./_types/tempo/chains/index.d.ts",
+      "import": "./_esm/tempo/chains/index.js",
+      "default": "./_cjs/tempo/chains/index.js"
+    },
     "./tempo/zones": {
       "types": "./_types/tempo/zones/index.d.ts",
       "import": "./_esm/tempo/zones/index.js",
@@ -196,6 +201,9 @@
       "tempo/actions": [
         "./_types/tempo/actions/index.d.ts"
       ],
+      "tempo/chains": [
+        "./_types/tempo/chains/index.d.ts"
+      ],
       "utils": [
         "./_types/utils/index.d.ts"
       ],
@@ -222,8 +230,8 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.20",
-    "ws": "8.18.3"
+    "ox": "0.14.22",
+    "ws": "8.20.1"
   },
   "license": "MIT",
   "homepage": "https://viem.sh",

package/tempo/Chain.ts

@@ -0,0 +1,20 @@
+// biome-ignore lint/performance/noBarrelFile: namespace module
+export {
+  tempo,
+  tempo as mainnet,
+  tempo as tempoMainnet,
+} from '../chains/definitions/tempo.js'
+export {
+  tempoDevnet,
+  tempoDevnet as devnet,
+} from '../chains/definitions/tempoDevnet.js'
+export {
+  tempoLocalnet,
+  tempoLocalnet as localnet,
+} from '../chains/definitions/tempoLocalnet.js'
+export {
+  tempoModerato,
+  tempoModerato as moderato,
+  tempoModerato as tempoTestnet,
+  tempoModerato as testnet,
+} from '../chains/definitions/tempoModerato.js'

package/tempo/Decorator.ts

@@ -1389,6 +1389,31 @@ export type Decorator<
     ) => () => void
   }
   fee: {
+    /**
+     * Validates that a token can be used as a Tempo fee token.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const { address } = await client.fee.validateToken({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The fee token address, ID, and metadata.
+     */
+    validateToken: (
+      parameters: feeActions.validateToken.Parameters,
+    ) => Promise<feeActions.validateToken.ReturnValue>
     /**
      * Gets the user's default fee token.
      *
@@ -4321,6 +4346,8 @@ export function decorator() {
           nonceActions.watchNonceIncremented(client, parameters),
       },
       fee: {
+        validateToken: (parameters) =>
+          feeActions.validateToken(client, parameters),
         // @ts-expect-error
         getUserToken: (parameters) =>
           // @ts-expect-error

package/tempo/actions/fee.ts

@@ -11,7 +11,7 @@ import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { zeroAddress } from '../../constants/address.js'
-import type { BaseErrorType } from '../../errors/base.js'
+import type { BaseError, BaseErrorType } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
 import type { Log, Log as viem_Log } from '../../types/log.js'
@@ -19,6 +19,12 @@ import type { Compute, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
+import {
+  FeeTokenNotTip20Error,
+  FeeTokenNotUsdError,
+  FeeTokenPausedError,
+  InvalidFeeTokenError,
+} from '../errors.js'
 import type {
   GetAccountParameter,
   ReadParameters,
@@ -26,6 +32,116 @@ import type {
 } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
+import * as tokenActions from './token.js'
+
+const tip20AddressPrefix = '0x20c0'
+
+/**
+ * Validates that a token can be used as a Tempo fee token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const { address, metadata } = await Actions.fee.validateToken(client, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The fee token address, ID, and metadata.
+ */
+export async function validateToken<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: validateToken.Parameters,
+): Promise<validateToken.ReturnValue> {
+  const { token, ...rest } = parameters
+  const token_ = String(token)
+  const address = (() => {
+    try {
+      return TokenId.toAddress(token)
+    } catch (cause) {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: token_,
+      })
+    }
+  })()
+
+  if (!address.toLowerCase().startsWith(tip20AddressPrefix))
+    throw new FeeTokenNotTip20Error({ token: address })
+
+  const isPathUsd = address.toLowerCase() === Addresses.pathUsd.toLowerCase()
+  if (!isPathUsd) {
+    const isTip20 = await readContract(client, {
+      ...rest,
+      address: Addresses.tip20Factory,
+      abi: Abis.tip20Factory,
+      functionName: 'isTIP20',
+      args: [address],
+    }).catch((cause) => {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: address,
+      })
+    })
+    if (!isTip20) throw new FeeTokenNotTip20Error({ token: address })
+  }
+
+  const metadata = await tokenActions
+    .getMetadata(client, {
+      ...rest,
+      token: address,
+    })
+    .catch((cause) => {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: address,
+      })
+    })
+
+  if (metadata.currency !== 'USD')
+    throw new FeeTokenNotUsdError({
+      currency: metadata.currency,
+      token: address,
+    })
+  if (metadata.paused === true)
+    throw new FeeTokenPausedError({ token: address })
+
+  return {
+    address,
+    id: TokenId.fromAddress(address),
+    metadata,
+  }
+}
+
+export declare namespace validateToken {
+  export type Parameters = ReadParameters & {
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = Compute<{
+    address: Address
+    id: bigint
+    metadata: tokenActions.getMetadata.ReturnValue
+  }>
+
+  export type ErrorType =
+    | FeeTokenNotTip20Error
+    | FeeTokenNotUsdError
+    | FeeTokenPausedError
+    | InvalidFeeTokenError
+    | BaseErrorType
+}
 
 /**
  * Gets the user's default fee token.

package/tempo/actions/wallet.ts

@@ -213,8 +213,8 @@ export declare namespace swap {
  * })
  *
  * const result = await Actions.wallet.deposit(client, {
- *   token: '0x...',
- *   value: '1.5',
+ *   amount: '1.5',
+ *   token: 'pathUsd',
  * })
  * ```
  *
@@ -243,14 +243,17 @@ export declare namespace deposit {
   export type Parameters = {
     /** Deposit address to pre-fill. */
     address?: Address | undefined
+    /** Human-readable amount to pre-fill (for example, "1.5"). */
+    amount?: string | 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
+    /**
+     * Token to pre-fill, accepted as either a contract address or a supported
+     * deposit token symbol. Omit to let the user choose.
+     */
+    token?: Address | string | undefined
   }
 
   export type ReturnValue =

package/tempo/chainConfig.ts

@@ -1,6 +1,4 @@
-import * as Address from 'ox/Address'
 import * as Hex from 'ox/Hex'
-import * as PublicKey from 'ox/PublicKey'
 import { SignatureEnvelope, type TokenId } from 'ox/tempo'
 import { getCode } from '../actions/public/getCode.js'
 import { verifyHash } from '../actions/public/verifyHash.js'
@@ -115,9 +113,24 @@ export const chainConfig = {
       // Access key (keychain) signature verification: check the key is
       // authorized, not expired, and not revoked on the AccountKeychain.
       if (envelope?.type === 'keychain' && mode === 'allowAccessKey') {
-        const accessKeyAddress = Address.fromPublicKey(
-          PublicKey.from(envelope.inner.publicKey as PublicKey.PublicKey),
-        )
+        // For v2 keychain envelopes, the inner signature signs
+        // keccak256(0x04 || hash || userAddress).
+        const innerPayload =
+          envelope.version === 'v2'
+            ? keccak256(Hex.concat('0x04', hash, address))
+            : hash
+
+        const accessKeyAddress = (() => {
+          try {
+            return SignatureEnvelope.extractAddress({
+              payload: innerPayload,
+              signature: envelope.inner,
+            })
+          } catch {
+            return undefined
+          }
+        })()
+        if (!accessKeyAddress) return false
 
         const keyInfo = await getMetadata(client, {
           account: address,
@@ -129,13 +142,6 @@ export const chainConfig = {
         if (keyInfo.isRevoked) return false
         if (keyInfo.expiry <= BigInt(Math.floor(Date.now() / 1000)))
           return false
-
-        // For v2 keychain envelopes, the inner signature signs
-        // keccak256(0x04 || hash || userAddress).
-        const innerPayload =
-          envelope.version === 'v2'
-            ? keccak256(Hex.concat('0x04', hash, address))
-            : hash
         return SignatureEnvelope.verify(envelope.inner, {
           address: accessKeyAddress,
           payload: innerPayload,

package/tempo/chains/index.ts

@@ -0,0 +1,9 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint module
+export {
+  tempo,
+  tempoDevnet,
+  tempoLocalnet,
+  tempoMainnet,
+  tempoModerato,
+  tempoTestnet,
+} from '../Chain.js'

package/tempo/chains/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/chains/index.d.ts",
+  "module": "../../_esm/tempo/chains/index.js",
+  "main": "../../_cjs/tempo/chains/index.js"
+}

package/tempo/errors.ts

@@ -0,0 +1,78 @@
+import { BaseError } from '../errors/base.js'
+
+export type InvalidFeeTokenErrorType = InvalidFeeTokenError & {
+  name: 'InvalidFeeTokenError'
+}
+export class InvalidFeeTokenError extends BaseError {
+  constructor({
+    cause,
+    token,
+  }: {
+    cause?: BaseError | Error | undefined
+    token: string
+  }) {
+    super(`Fee token "${token}" is invalid.`, {
+      cause,
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Fee tokens must be unpaused USD-denominated TIP-20 tokens.',
+        'Use `client.fee.validateToken({ token })` before sending transactions or setting fee preferences.',
+      ],
+      name: 'InvalidFeeTokenError',
+    })
+  }
+}
+
+export type FeeTokenNotTip20ErrorType = FeeTokenNotTip20Error & {
+  name: 'FeeTokenNotTip20Error'
+}
+export class FeeTokenNotTip20Error extends BaseError {
+  constructor({ token }: { token: string }) {
+    super(`Fee token "${token}" is not a TIP-20 token.`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Fee tokens must be TIP-20 token addresses or token IDs.',
+        'TIP-20 token addresses use the `0x20c0...` address prefix.',
+      ],
+      name: 'FeeTokenNotTip20Error',
+    })
+  }
+}
+
+export type FeeTokenNotUsdErrorType = FeeTokenNotUsdError & {
+  name: 'FeeTokenNotUsdError'
+}
+export class FeeTokenNotUsdError extends BaseError {
+  constructor({
+    currency,
+    token,
+  }: {
+    currency: string
+    token: string
+  }) {
+    super(`Fee token "${token}" is denominated in "${currency}", not "USD".`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Only USD-denominated TIP-20 tokens can be used as fee tokens.',
+      ],
+      name: 'FeeTokenNotUsdError',
+    })
+  }
+}
+
+export type FeeTokenPausedErrorType = FeeTokenPausedError & {
+  name: 'FeeTokenPausedError'
+}
+export class FeeTokenPausedError extends BaseError {
+  constructor({ token }: { token: string }) {
+    super(`Fee token "${token}" is paused.`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: ['Paused TIP-20 tokens cannot be used as fee tokens.'],
+      name: 'FeeTokenPausedError',
+    })
+  }
+}

package/tempo/index.ts

@@ -24,11 +24,13 @@ export * as Account from './Account.js'
 export * as Addresses from './Addresses.js'
 export * as Actions from './actions/index.js'
 export * as Capabilities from './Capabilities.js'
+export * as Chain from './Chain.js'
 export {
   type Decorator as TempoActions,
   decorator as tempoActions,
 } from './Decorator.js'
 export * as Expiry from './Expiry.js'
+export * from './errors.js'
 export * as Formatters from './Formatters.js'
 export * as Hardfork from './Hardfork.js'
 export * as P256 from './P256.js'

package/types/block.ts

@@ -69,10 +69,7 @@ export type Block<
   withdrawalsRoot?: Hex | undefined
 }
 
-export type BlockIdentifier<quantity = bigint> = {
-  /** Whether or not to throw an error if the block is not in the canonical chain as described below. Only allowed in conjunction with the blockHash tag. Defaults to false. */
-  requireCanonical?: boolean | undefined
-} & (
+export type BlockIdentifier<quantity = bigint> =
   | {
       /** The block in the canonical chain with this number */
       blockNumber: BlockNumber<quantity>
@@ -80,8 +77,9 @@ export type BlockIdentifier<quantity = bigint> = {
   | {
       /** The block uniquely identified by this hash. The `blockNumber` and `blockHash` properties are mutually exclusive; exactly one of them must be set. */
       blockHash: Hash
+      /** Whether or not to throw an error if the block is not in the canonical chain as described below. Only allowed in conjunction with the blockHash tag. Defaults to false. */
+      requireCanonical?: boolean | undefined
     }
-)
 
 /** Represents a block number in the blockchain. */
 export type BlockNumber<quantity = bigint> = quantity

package/types/eip1193.ts

@@ -974,7 +974,7 @@ export type PublicRpcSchema = [
       address: Address,
       /** An array of storage-keys that should be proofed and included. */
       storageKeys: Hash[],
-      block: BlockNumber | BlockTag,
+      block: BlockNumber | BlockTag | BlockIdentifier,
     ]
     ReturnType: Proof
   },

package/utils/abi/encodeEventTopics.ts

@@ -66,7 +66,22 @@ export type EncodeEventTopicsParameters<
 > &
   (hasEvents extends true ? unknown : never)
 
-export type EncodeEventTopicsReturnType = [Hex, ...(Hex | Hex[] | null)[]]
+export type EncodeEventTopicsReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = undefined,
+  ///
+  resolvedEvent = abi extends Abi
+    ? eventName extends string
+      ? Extract<ExtractAbiEvents<abi>, { name: eventName }>
+      : abi['length'] extends 1
+        ? abi[0]
+        : ExtractAbiEvents<abi>
+    : unknown,
+> = IsNarrowable<abi, Abi> extends true
+  ? [resolvedEvent] extends [{ anonymous: true }]
+    ? (Hex | Hex[] | null)[]
+    : [Hex, ...(Hex | Hex[] | null)[]]
+  : (Hex | Hex[] | null)[]
 
 export type EncodeEventTopicsErrorType =
   | AbiEventNotFoundErrorType
@@ -81,7 +96,7 @@ export function encodeEventTopics<
   eventName extends ContractEventName<abi> | undefined = undefined,
 >(
   parameters: EncodeEventTopicsParameters<abi, eventName>,
-): EncodeEventTopicsReturnType {
+): EncodeEventTopicsReturnType<abi, eventName> {
   const { abi, eventName, args } = parameters as EncodeEventTopicsParameters
 
   let abiItem = abi[0]
@@ -94,9 +109,6 @@ export function encodeEventTopics<
   if (abiItem.type !== 'event')
     throw new AbiEventNotFoundError(undefined, { docsPath })
 
-  const definition = formatAbiItem(abiItem)
-  const signature = toEventSelector(definition as EventDefinition)
-
   let topics: (Hex | Hex[] | null)[] = []
   if (args && 'inputs' in abiItem) {
     const indexedInputs = abiItem.inputs?.filter(
@@ -121,7 +133,14 @@ export function encodeEventTopics<
         }) ?? []
     }
   }
-  return [signature, ...topics]
+  // Anonymous events are not identified by a signature topic, so the event
+  // selector must not be prepended.
+  if (abiItem.anonymous)
+    return topics as EncodeEventTopicsReturnType<abi, eventName>
+
+  const definition = formatAbiItem(abiItem)
+  const signature = toEventSelector(definition as EventDefinition)
+  return [signature, ...topics] as EncodeEventTopicsReturnType<abi, eventName>
 }
 
 export type EncodeArgErrorType =

package/utils/block/formatBlockParameter.ts

@@ -0,0 +1,63 @@
+import { BaseError, type BaseErrorType } from '../../errors/base.js'
+import type { BlockTag } from '../../types/block.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import type { RpcBlockIdentifier } from '../../types/rpc.js'
+import type { NumberToHexErrorType } from '../encoding/toHex.js'
+import { numberToHex } from '../encoding/toHex.js'
+
+type FormatBlockParameterParameters = {
+  blockHash?: Hash | undefined
+  blockNumber?: bigint | undefined
+  blockTag?: BlockTag | undefined
+  requireCanonical?: boolean | undefined
+}
+
+type RpcBlockHashIdentifier = Extract<RpcBlockIdentifier, { blockHash: Hash }>
+
+type FormatBlockParameterReturnType = Hex | BlockTag | RpcBlockHashIdentifier
+
+export type FormatBlockParameterErrorType = BaseErrorType | NumberToHexErrorType
+
+/**
+ * Formats block parameters for RPC calls according to EIP-1898.
+ *
+ * @param parameters - Block parameters
+ * @returns Formatted block parameter for RPC call
+ *
+ * @example
+ * // Using block tag
+ * formatBlockParameter({ blockTag: 'latest' })
+ * // => 'latest'
+ *
+ * @example
+ * // Using block number
+ * formatBlockParameter({ blockNumber: 69420n })
+ * // => '0x10f2c'
+ *
+ * @example
+ * // Using block hash (EIP-1898)
+ * formatBlockParameter({ blockHash: '0x...' })
+ * // => { blockHash: '0x...' }
+ *
+ * @example
+ * // Using block hash with requireCanonical (EIP-1898)
+ * formatBlockParameter({ blockHash: '0x...', requireCanonical: true })
+ * // => { blockHash: '0x...', requireCanonical: true }
+ */
+export function formatBlockParameter(
+  parameters: FormatBlockParameterParameters,
+): FormatBlockParameterReturnType {
+  const { blockHash, blockNumber, blockTag, requireCanonical } = parameters
+
+  if (requireCanonical !== undefined && !blockHash)
+    throw new BaseError(
+      '`requireCanonical` can only be provided when `blockHash` is set.',
+    )
+
+  if (blockHash)
+    return requireCanonical ? { blockHash, requireCanonical } : { blockHash }
+
+  if (typeof blockNumber === 'bigint') return numberToHex(blockNumber)
+
+  return blockTag ?? 'latest'
+}