viem 2.49.3 → 2.50.3

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

package/utils/ccipTunnel.ts

@@ -0,0 +1,67 @@
+import { batchGatewayAbi } from '../constants/abis.js'
+import { solidityError } from '../constants/solidity.js'
+import { HttpRequestError } from '../errors/request.js'
+import { decodeErrorResult } from './abi/decodeErrorResult.js'
+import { decodeFunctionResult } from './abi/decodeFunctionResult.js'
+import { encodeFunctionData } from './abi/encodeFunctionData.js'
+import { ccipRequest as ccipRequest_ } from './ccip.js'
+import { localBatchGatewayUrl } from './ens/localBatchGatewayRequest.js'
+
+export type CcipReadTunnelParameters = {
+  batchGateways: string[]
+  ccipRequest?: typeof ccipRequest_
+}
+
+export function ccipReadTunnel({
+  batchGateways,
+  ccipRequest = ccipRequest_,
+}: CcipReadTunnelParameters): { request: typeof ccipRequest_ } {
+  return {
+    async request({ data, sender, urls }) {
+      if (urls.includes(localBatchGatewayUrl)) {
+        return ccipRequest({
+          data,
+          sender,
+          urls: batchGateways,
+        })
+      } else {
+        const [failures, responses] = decodeFunctionResult({
+          abi: batchGatewayAbi,
+          functionName: 'query',
+          data: await ccipRequest({
+            data: encodeFunctionData({
+              abi: batchGatewayAbi,
+              functionName: 'query',
+              args: [[{ sender, data, urls }]],
+            }),
+            sender,
+            urls: batchGateways,
+          }),
+        })
+        if (failures[0]) {
+          let error: Error | undefined
+          try {
+            const res = decodeErrorResult({
+              abi: [...batchGatewayAbi, solidityError],
+              data: responses[0],
+            })
+            if (res.errorName === 'HttpError') {
+              error = new HttpRequestError({
+                body: { message: res.args[1] },
+                status: res.args[0],
+                url: urls.join(' | '),
+              })
+            } else {
+              const message = res.args[0]
+              if (message) {
+                error = new Error(message)
+              }
+            }
+          } catch {}
+          throw error ?? new Error('An unknown error occurred.')
+        }
+        return responses[0]
+      }
+    },
+  }
+}

package/utils/index.ts

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

package/utils/nonceManager.ts

@@ -50,6 +50,10 @@ export function createNonceManager(
 
   const getKey = ({ address, chainId }: FunctionParameters) =>
     `${address}.${chainId}`
+  const resetCache = (key: string) => {
+    deltaMap.delete(key)
+    promiseMap.delete(key)
+  }
 
   return {
     async consume({ address, chainId, client }) {
@@ -83,7 +87,7 @@ export function createNonceManager(
             nonceMap.delete(key)
             return nonce
           } finally {
-            this.reset({ address, chainId })
+            resetCache(key)
           }
         })()
         promiseMap.set(key, promise)
@@ -94,8 +98,8 @@ export function createNonceManager(
     },
     reset({ address, chainId }) {
       const key = getKey({ address, chainId })
-      deltaMap.delete(key)
-      promiseMap.delete(key)
+      nonceMap.delete(key)
+      resetCache(key)
     },
   }
 }

package/utils/observe.ts

@@ -39,10 +39,13 @@ export function observe<callbacks extends Callbacks>(
 
   const unsubscribe = () => {
     const listeners = getListeners()
-    listenersCache.set(
-      observerId,
-      listeners.filter((cb: any) => cb.id !== callbackId),
-    )
+    const nextListeners = listeners.filter((cb: any) => cb.id !== callbackId)
+    if (nextListeners.length === 0) {
+      listenersCache.delete(observerId)
+      cleanupCache.delete(observerId)
+      return
+    }
+    listenersCache.set(observerId, nextListeners)
   }
 
   const unwatch = () => {

package/utils/rpc/socket.ts

@@ -131,11 +131,13 @@ export async function getSocketRpcClient<socket extends {}>(
       let error: Error | Event | undefined
       let socket: Socket<{}>
       let keepAliveTimer: ReturnType<typeof setInterval> | undefined
+      let reconnectTimer: ReturnType<typeof setTimeout> | undefined
 
       let reconnectInProgress = false
+      let intentionallyClosed = false
       function attemptReconnect() {
         // Attempt to reconnect.
-        if (reconnect && reconnectCount < attempts) {
+        if (reconnect && !intentionallyClosed && reconnectCount < attempts) {
           if (reconnectInProgress) return
           reconnectInProgress = true
           reconnectCount++
@@ -143,7 +145,13 @@ export async function getSocketRpcClient<socket extends {}>(
           // Make sure the previous socket is definitely closed.
           socket?.close()
 
-          setTimeout(async () => {
+          reconnectTimer = setTimeout(async () => {
+            reconnectTimer = undefined
+            // Bail if the client was intentionally closed during the delay.
+            if (intentionallyClosed) {
+              reconnectInProgress = false
+              return
+            }
             // biome-ignore lint/suspicious/noConsole: _
             await setup().catch(console.error)
             reconnectInProgress = false
@@ -192,6 +200,11 @@ export async function getSocketRpcClient<socket extends {}>(
           },
         })
 
+        if (intentionallyClosed) {
+          result.close()
+          return result
+        }
+
         socket = result
 
         if (keepAlive) {
@@ -220,7 +233,13 @@ export async function getSocketRpcClient<socket extends {}>(
       // Create a new socket instance.
       socketClient = {
         close() {
+          intentionallyClosed = true
           keepAliveTimer && clearInterval(keepAliveTimer)
+          if (reconnectTimer) {
+            clearTimeout(reconnectTimer)
+            reconnectTimer = undefined
+            reconnectInProgress = false
+          }
           socket.close()
           socketClientCache.delete(id)
         },