viem 2.49.3 → 2.50.3

package/actions/public/getTransactionCount.ts

@@ -6,15 +6,16 @@ import type { Transport } from '../../clients/transports/createTransport.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import {
+  type FormatBlockParameterErrorType,
+  formatBlockParameter,
+} from '../../utils/block/formatBlockParameter.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import {
   type HexToNumberErrorType,
   hexToNumber,
 } from '../../utils/encoding/fromHex.js'
-import {
-  type NumberToHexErrorType,
-  numberToHex,
-} from '../../utils/encoding/toHex.js'
 
 export type GetTransactionCountParameters = {
   /** The account address. */
@@ -24,18 +25,30 @@ export type GetTransactionCountParameters = {
       /** The block number. */
       blockNumber?: bigint | undefined
       blockTag?: undefined
+      blockHash?: undefined
+      requireCanonical?: undefined
     }
   | {
       blockNumber?: undefined
       /** The block tag. Defaults to 'latest'. */
       blockTag?: BlockTag | undefined
+      blockHash?: undefined
+      requireCanonical?: undefined
+    }
+  | {
+      blockNumber?: undefined
+      blockTag?: undefined
+      /** The transaction count at a block specified by block hash. */
+      blockHash: Hash
+      /** Whether or not to throw an error if the block is not in the canonical chain. Only allowed in conjunction with `blockHash`. */
+      requireCanonical?: boolean | undefined
     }
 )
 export type GetTransactionCountReturnType = number
 
 export type GetTransactionCountErrorType =
   | RequestErrorType
-  | NumberToHexErrorType
+  | FormatBlockParameterErrorType
   | HexToNumberErrorType
   | ErrorType
 
@@ -67,18 +80,27 @@ export async function getTransactionCount<
   account extends Account | undefined,
 >(
   client: Client<Transport, chain, account>,
-  { address, blockTag = 'latest', blockNumber }: GetTransactionCountParameters,
+  {
+    address,
+    blockHash,
+    blockNumber,
+    blockTag = 'latest',
+    requireCanonical,
+  }: GetTransactionCountParameters,
 ): Promise<GetTransactionCountReturnType> {
+  const block = formatBlockParameter({
+    blockHash,
+    blockNumber,
+    blockTag,
+    requireCanonical,
+  })
   const count = await client.request(
     {
       method: 'eth_getTransactionCount',
-      params: [
-        address,
-        typeof blockNumber === 'bigint' ? numberToHex(blockNumber) : blockTag,
-      ],
+      params: [address, block],
     },
     {
-      dedupe: Boolean(blockNumber),
+      dedupe: typeof blockNumber === 'bigint' || blockHash !== undefined,
     },
   )
   return hexToNumber(count)

package/actions/public/multicall.ts

@@ -45,9 +45,11 @@ export type MulticallParameters<
 > = Pick<
   CallParameters,
   | 'authorizationList'
+  | 'blockHash'
   | 'blockNumber'
   | 'blockOverrides'
   | 'blockTag'
+  | 'requireCanonical'
   | 'stateOverride'
 > & {
   /** The account to use for the multicall. */
@@ -138,9 +140,11 @@ export async function multicall<
     account,
     authorizationList,
     allowFailure = true,
+    blockHash,
     blockNumber,
     blockOverrides,
     blockTag,
+    requireCanonical,
     stateOverride,
   } = parameters
   const contracts = parameters.contracts as ContractFunctionParameters[]
@@ -237,10 +241,12 @@ export async function multicall<
         account,
         args: [calls],
         authorizationList,
+        blockHash,
         blockNumber,
         blockOverrides,
         blockTag,
         functionName: 'aggregate3',
+        requireCanonical,
         stateOverride,
       }),
     ),

package/actions/public/readContract.ts

@@ -44,11 +44,13 @@ export type ReadContractParameters<
     CallParameters,
     | 'account'
     | 'authorizationList'
+    | 'blockHash'
     | 'blockNumber'
     | 'blockOverrides'
     | 'blockTag'
     | 'factory'
     | 'factoryData'
+    | 'requireCanonical'
     | 'stateOverride'
   >
 > &

package/actions/wallet/prepareTransactionRequest.ts

@@ -38,15 +38,7 @@ import type {
   GetChainParameter,
 } from '../../types/chain.js'
 import type { GetTransactionRequestKzgParameter } from '../../types/kzg.js'
-import type {
-  TransactionRequest,
-  TransactionRequestEIP1559,
-  TransactionRequestEIP2930,
-  TransactionRequestEIP4844,
-  TransactionRequestEIP7702,
-  TransactionRequestLegacy,
-  TransactionSerializable,
-} from '../../types/transaction.js'
+import type { TransactionSerializable } from '../../types/transaction.js'
 import type {
   ExactPartial,
   IsNever,
@@ -106,6 +98,12 @@ type ParameterTypeToParameters<
 > = parameterType extends 'fees'
   ? 'maxFeePerGas' | 'maxPriorityFeePerGas' | 'gasPrice'
   : parameterType
+type ExtractTransactionRequest<transactionRequest, transactionType> =
+  transactionRequest extends { type?: infer type | undefined }
+    ? Extract<transactionType, type> extends never
+      ? never
+      : transactionRequest
+    : never
 
 export type PrepareTransactionRequestRequest<
   chain extends Chain | undefined = Chain | undefined,
@@ -166,12 +164,10 @@ export type PrepareTransactionRequestReturnType<
     : GetTransactionType<request> extends 'legacy'
       ? unknown
       : GetTransactionType<request>,
-  _transactionRequest extends TransactionRequest =
-    | (_transactionType extends 'legacy' ? TransactionRequestLegacy : never)
-    | (_transactionType extends 'eip1559' ? TransactionRequestEIP1559 : never)
-    | (_transactionType extends 'eip2930' ? TransactionRequestEIP2930 : never)
-    | (_transactionType extends 'eip4844' ? TransactionRequestEIP4844 : never)
-    | (_transactionType extends 'eip7702' ? TransactionRequestEIP7702 : never),
+  _transactionRequest = ExtractTransactionRequest<
+    UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'>,
+    _transactionType
+  >,
 > = Prettify<
   UnionRequiredBy<
     Extract<

package/actions/wallet/sendTransaction.ts

@@ -190,6 +190,7 @@ export async function sendTransaction<
       docsPath: '/docs/actions/wallet/sendTransaction',
     })
   const account = account_ ? parseAccount(account_) : null
+  let nonceManagerParameters: { address: Address; chainId: number } | undefined
 
   try {
     assertRequest(parameters as AssertRequestParameters)
@@ -309,6 +310,16 @@ export async function sendTransaction<
     }
 
     if (account?.type === 'local') {
+      if (account.nonceManager && typeof nonce === 'undefined') {
+        const requestChainId = (rest as unknown as { chainId?: number }).chainId
+        const chainId = await (async () => {
+          if (typeof requestChainId === 'number') return requestChainId
+          if (chain) return chain.id
+          return getAction(client, getChainId, 'getChainId')({})
+        })()
+        nonceManagerParameters = { address: account.address, chainId }
+      }
+
       // Prepare the request for signing (assign appropriate fees, etc.)
       const request = await getAction(
         client,
@@ -366,6 +377,8 @@ export async function sendTransaction<
     })
   } catch (err) {
     if (err instanceof AccountTypeNotSupportedError) throw err
+    if (nonceManagerParameters)
+      account?.nonceManager?.reset(nonceManagerParameters)
     throw getTransactionError(err as BaseError, {
       ...parameters,
       account,

package/actions/wallet/sendTransactionSync.ts

@@ -213,6 +213,7 @@ export async function sendTransactionSync<
       docsPath: '/docs/actions/wallet/sendTransactionSync',
     })
   const account = account_ ? parseAccount(account_) : null
+  let nonceManagerParameters: { address: Address; chainId: number } | undefined
 
   try {
     assertRequest(parameters as AssertRequestParameters)
@@ -348,6 +349,16 @@ export async function sendTransactionSync<
     }
 
     if (account?.type === 'local') {
+      if (account.nonceManager && typeof nonce === 'undefined') {
+        const requestChainId = (rest as unknown as { chainId?: number }).chainId
+        const chainId = await (async () => {
+          if (typeof requestChainId === 'number') return requestChainId
+          if (chain) return chain.id
+          return getAction(client, getChainId, 'getChainId')({})
+        })()
+        nonceManagerParameters = { address: account.address, chainId }
+      }
+
       // Prepare the request for signing (assign appropriate fees, etc.)
       const request = await getAction(
         client,
@@ -407,6 +418,11 @@ export async function sendTransactionSync<
     })
   } catch (err) {
     if (err instanceof AccountTypeNotSupportedError) throw err
+    if (
+      nonceManagerParameters &&
+      !(err instanceof TransactionReceiptRevertedError)
+    )
+      account?.nonceManager?.reset(nonceManagerParameters)
     throw getTransactionError(err as BaseError, {
       ...parameters,
       account,

package/chains/definitions/mizuhikiTestnetAwaji.ts

@@ -0,0 +1,26 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const mizuhikiTestnetAwaji = /*#__PURE__*/ defineChain({
+  id: 6497,
+  name: 'MIZUHIKI Testnet Awaji',
+  nativeCurrency: { name: 'MIZU', symbol: 'MIZU', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.awaji.mizuhiki.io'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Blockscout',
+      url: 'https://awaji.blockscout.com',
+      apiUrl: 'https://awaji.blockscout.com/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 0,
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/morphHolesky.ts

@@ -14,7 +14,7 @@ export const morphHolesky = /*#__PURE__*/ defineChain({
     default: {
       name: 'Morph Holesky Explorer',
       url: 'https://explorer-holesky.morphl2.io',
-      apiUrl: 'https://explorer-api-holesky.morphl2.io/api?',
+      apiUrl: 'https://explorer-api-holesky.morphl2.io/api',
     },
   },
   testnet: true,

package/chains/definitions/sentrix.ts

@@ -0,0 +1,26 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const sentrix = /*#__PURE__*/ defineChain({
+  id: 7119,
+  name: 'Sentrix Chain',
+  nativeCurrency: { name: 'Sentrix', symbol: 'SRX', decimals: 18 },
+  blockTime: 1_000,
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.sentrixchain.com'],
+      webSocket: ['wss://rpc.sentrixchain.com/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'SentrixScan',
+      url: 'https://scan.sentrixchain.com',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xFd4b34b5763f54a580a0d9f7997A2A993ef9ceE9',
+      blockCreated: 717_078,
+    },
+  },
+})

package/chains/definitions/sentrixTestnet.ts

@@ -0,0 +1,27 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const sentrixTestnet = /*#__PURE__*/ defineChain({
+  id: 7120,
+  name: 'Sentrix Testnet',
+  nativeCurrency: { name: 'Sentrix', symbol: 'SRX', decimals: 18 },
+  blockTime: 1_000,
+  rpcUrls: {
+    default: {
+      http: ['https://testnet-rpc.sentrixchain.com'],
+      webSocket: ['wss://testnet-rpc.sentrixchain.com/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'SentrixScan Testnet',
+      url: 'https://scan-testnet.sentrixchain.com',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0x7900826De548425c6BE56caEbD4760AB0155Cd54',
+      blockCreated: 723_191,
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/sova.ts

@@ -16,7 +16,7 @@ export const sova = /*#__PURE__*/ defineChain({
   blockExplorers: {
     default: {
       name: 'Sova Block Explorer',
-      url: 'hhttps://explorer.sova.io',
+      url: 'https://explorer.sova.io',
     },
   },
   testnet: false,

package/chains/index.ts

@@ -415,6 +415,7 @@ export { mezoTestnet } from './definitions/mezoTestnet.js'
 export { mint } from './definitions/mint.js'
 export { mintSepoliaTestnet } from './definitions/mintSepoliaTestnet.js'
 export { mitosisTestnet } from './definitions/mitosisTestnet.js'
+export { mizuhikiTestnetAwaji } from './definitions/mizuhikiTestnetAwaji.js'
 export { mode } from './definitions/mode.js'
 export { modeTestnet } from './definitions/modeTestnet.js'
 export { monad } from './definitions/monad.js'
@@ -539,6 +540,8 @@ export { scrollSepolia } from './definitions/scrollSepolia.js'
 export { sei } from './definitions/sei.js'
 export { seismicDevnet } from './definitions/seismicDevnet.js'
 export { seiTestnet } from './definitions/seiTestnet.js'
+export { sentrix } from './definitions/sentrix.js'
+export { sentrixTestnet } from './definitions/sentrixTestnet.js'
 export { sepolia } from './definitions/sepolia.js'
 export { shape } from './definitions/shape.js'
 export { shapeSepolia } from './definitions/shapeSepolia.js'

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.3'

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.3",
   "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.