viem 2.9.22 → 2.9.24

package/actions/public/watchBlocks.ts

@@ -3,7 +3,7 @@ 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 { GetTransportConfig } from '../../types/transport.js'
+import type { HasTransportType } from '../../types/transport.js'
 import { formatBlock } from '../../utils/formatters/block.js'
 import { getAction } from '../../utils/getAction.js'
 import { observe } from '../../utils/observe.js'
@@ -40,7 +40,7 @@ export type WatchBlocksParameters<
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: ((error: Error) => void) | undefined
 } & (
-  | (GetTransportConfig<TTransport>['type'] extends 'webSocket'
+  | (HasTransportType<TTransport, 'webSocket'> extends true
       ? {
           blockTag?: undefined
           emitMissed?: undefined
@@ -116,8 +116,16 @@ export function watchBlocks<
     pollingInterval = client.pollingInterval,
   }: WatchBlocksParameters<TTransport, TChain, TIncludeTransactions, TBlockTag>,
 ): WatchBlocksReturnType {
-  const enablePolling =
-    typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
+  const enablePolling = (() => {
+    if (typeof poll_ !== 'undefined') return poll_
+    if (client.transport.type === 'webSocket') return false
+    if (
+      client.transport.type === 'fallback' &&
+      client.transport.transports[0].config.type === 'webSocket'
+    )
+      return false
+    return true
+  })()
   const includeTransactions = includeTransactions_ ?? false
 
   let prevBlock:
@@ -199,7 +207,19 @@ export function watchBlocks<
     let unsubscribe = () => (active = false)
     ;(async () => {
       try {
-        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+        const transport = (() => {
+          if (client.transport.type === 'fallback') {
+            const transport = client.transport.transports.find(
+              (transport: ReturnType<Transport>) =>
+                transport.config.type === 'webSocket',
+            )
+            if (!transport) return client.transport
+            return transport.value
+          }
+          return client.transport
+        })()
+
+        const { unsubscribe: unsubscribe_ } = await transport.subscribe({
           params: ['newHeads'],
           onData(data: any) {
             if (!active) return

package/actions/public/watchContractEvent.ts

@@ -154,10 +154,17 @@ export function watchContractEvent<
     strict: strict_,
   } = parameters
 
-  const enablePolling =
-    typeof poll_ !== 'undefined'
-      ? poll_
-      : client.transport.type !== 'webSocket' || typeof fromBlock === 'number'
+  const enablePolling = (() => {
+    if (typeof poll_ !== 'undefined') return poll_
+    if (typeof fromBlock === 'bigint') return true
+    if (client.transport.type === 'webSocket') return false
+    if (
+      client.transport.type === 'fallback' &&
+      client.transport.transports[0].config.type === 'webSocket'
+    )
+      return false
+    return true
+  })()
 
   const pollContractEvent = () => {
     const strict = strict_ ?? false
@@ -289,6 +296,18 @@ export function watchContractEvent<
     return observe(observerId, { onLogs, onError }, (emit) => {
       ;(async () => {
         try {
+          const transport = (() => {
+            if (client.transport.type === 'fallback') {
+              const transport = client.transport.transports.find(
+                (transport: ReturnType<Transport>) =>
+                  transport.config.type === 'webSocket',
+              )
+              if (!transport) return client.transport
+              return transport.value
+            }
+            return client.transport
+          })()
+
           const topics: LogTopic[] = eventName
             ? encodeEventTopics({
                 abi: abi,
@@ -297,51 +316,50 @@ export function watchContractEvent<
               } as EncodeEventTopicsParameters)
             : []
 
-          const { unsubscribe: unsubscribe_ } =
-            await client.transport.subscribe({
-              params: ['logs', { address, topics }],
-              onData(data: any) {
-                if (!active) return
-                const log = data.result
-                try {
-                  const { eventName, args } = decodeEventLog({
-                    abi: abi,
-                    data: log.data,
-                    topics: log.topics as any,
-                    strict: strict_,
-                  })
-                  const formatted = formatLog(log, {
-                    args,
-                    eventName: eventName as string,
-                  })
-                  emit.onLogs([formatted] as any)
-                } catch (err) {
-                  let eventName: string | undefined
-                  let isUnnamed: boolean | undefined
-                  if (
-                    err instanceof DecodeLogDataMismatch ||
-                    err instanceof DecodeLogTopicsMismatch
-                  ) {
-                    // If strict mode is on, and log data/topics do not match event definition, skip.
-                    if (strict_) return
-                    eventName = err.abiItem.name
-                    isUnnamed = err.abiItem.inputs?.some(
-                      (x) => !('name' in x && x.name),
-                    )
-                  }
-
-                  // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
-                  const formatted = formatLog(log, {
-                    args: isUnnamed ? [] : {},
-                    eventName,
-                  })
-                  emit.onLogs([formatted] as any)
+          const { unsubscribe: unsubscribe_ } = await transport.subscribe({
+            params: ['logs', { address, topics }],
+            onData(data: any) {
+              if (!active) return
+              const log = data.result
+              try {
+                const { eventName, args } = decodeEventLog({
+                  abi: abi,
+                  data: log.data,
+                  topics: log.topics as any,
+                  strict: strict_,
+                })
+                const formatted = formatLog(log, {
+                  args,
+                  eventName: eventName as string,
+                })
+                emit.onLogs([formatted] as any)
+              } catch (err) {
+                let eventName: string | undefined
+                let isUnnamed: boolean | undefined
+                if (
+                  err instanceof DecodeLogDataMismatch ||
+                  err instanceof DecodeLogTopicsMismatch
+                ) {
+                  // If strict mode is on, and log data/topics do not match event definition, skip.
+                  if (strict_) return
+                  eventName = err.abiItem.name
+                  isUnnamed = err.abiItem.inputs?.some(
+                    (x) => !('name' in x && x.name),
+                  )
                 }
-              },
-              onError(error: Error) {
-                emit.onError?.(error)
-              },
-            })
+
+                // Set args to empty if there is an error decoding (e.g. indexed/non-indexed params mismatch).
+                const formatted = formatLog(log, {
+                  args: isUnnamed ? [] : {},
+                  eventName,
+                })
+                emit.onLogs([formatted] as any)
+              }
+            },
+            onError(error: Error) {
+              emit.onError?.(error)
+            },
+          })
           unsubscribe = unsubscribe_
           if (!active) unsubscribe()
         } catch (err) {

package/actions/public/watchEvent.ts

@@ -172,10 +172,17 @@ export function watchEvent<
     strict: strict_,
   }: WatchEventParameters<TAbiEvent, TAbiEvents, TStrict, TTransport>,
 ): WatchEventReturnType {
-  const enablePolling =
-    typeof poll_ !== 'undefined'
-      ? poll_
-      : client.transport.type !== 'webSocket' || typeof fromBlock === 'bigint'
+  const enablePolling = (() => {
+    if (typeof poll_ !== 'undefined') return poll_
+    if (typeof fromBlock === 'bigint') return true
+    if (client.transport.type === 'webSocket') return false
+    if (
+      client.transport.type === 'fallback' &&
+      client.transport.transports[0].config.type === 'webSocket'
+    )
+      return false
+    return true
+  })()
   const strict = strict_ ?? false
 
   const pollEvent = () => {
@@ -296,6 +303,18 @@ export function watchEvent<
     let unsubscribe = () => (active = false)
     ;(async () => {
       try {
+        const transport = (() => {
+          if (client.transport.type === 'fallback') {
+            const transport = client.transport.transports.find(
+              (transport: ReturnType<Transport>) =>
+                transport.config.type === 'webSocket',
+            )
+            if (!transport) return client.transport
+            return transport.value
+          }
+          return client.transport
+        })()
+
         const events_ = events ?? (event ? [event] : undefined)
         let topics: LogTopic[] = []
         if (events_) {
@@ -311,7 +330,7 @@ export function watchEvent<
           if (event) topics = topics[0] as LogTopic[]
         }
 
-        const { unsubscribe: unsubscribe_ } = await client.transport.subscribe({
+        const { unsubscribe: unsubscribe_ } = await transport.subscribe({
           params: ['logs', { address, topics }],
           onData(data: any) {
             if (!active) return

package/chains/definitions/cyberTestnet.ts

@@ -0,0 +1,26 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const cyberTestnet = /*#__PURE__*/ defineChain({
+  id: 111_557_560,
+  name: 'Cyber Testnet',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://cyber-testnet.alt.technology'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Blockscout',
+      url: 'https://cyber-testnet-explorer.alt.technology',
+      apiUrl: 'https://cyber-testnet-explorer.alt.technology/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xffc391F0018269d4758AEA1a144772E8FB99545E',
+      blockCreated: 304545,
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/dreyerxMainnet.ts

@@ -0,0 +1,22 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const dreyerxMainnet = /*#__PURE__*/ defineChain({
+  id: 23451,
+  name: 'DreyerX Mainnet',
+  nativeCurrency: {
+    name: 'DreyerX',
+    symbol: 'DRX',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.dreyerx.com'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'DreyerX Scan',
+      url: 'https://scan.dreyerx.com',
+    },
+  },
+})

package/chains/index.ts

@@ -52,12 +52,14 @@ export { coreDao } from './definitions/coreDao.js'
 export { cronos } from './definitions/cronos.js'
 export { cronosTestnet } from './definitions/cronosTestnet.js'
 export { crossbell } from './definitions/crossbell.js'
+export { cyberTestnet } from './definitions/cyberTestnet.js'
 export { darwinia } from './definitions/darwinia.js'
 export { defichainEvm } from './definitions/defichainEvm.js'
 export { defichainEvmTestnet } from './definitions/defichainEvmTestnet.js'
 export { degen } from './definitions/degen.js'
 export { dfk } from './definitions/dfk.js'
 export { dogechain } from './definitions/dogechain.js'
+export { dreyerxMainnet } from './definitions/dreyerxMainnet.js'
 export { edgeless } from './definitions/edgeless.js'
 export { edgelessTestnet } from './definitions/edgelessTestnet.js'
 export { edgeware } from './definitions/edgeware.js'

package/clients/transports/fallback.ts

@@ -80,20 +80,23 @@ export type FallbackTransportConfig = {
   retryDelay?: TransportConfig['retryDelay'] | undefined
 }
 
-export type FallbackTransport = Transport<
-  'fallback',
-  {
-    onResponse: (fn: OnResponseFn) => void
-    transports: ReturnType<Transport>[]
-  }
->
+export type FallbackTransport<transports extends Transport[] = Transport[]> =
+  Transport<
+    'fallback',
+    {
+      onResponse: (fn: OnResponseFn) => void
+      transports: {
+        [key in keyof transports]: ReturnType<transports[key]>
+      }
+    }
+  >
 
 export type FallbackTransportErrorType = CreateTransportErrorType | ErrorType
 
-export function fallback(
-  transports_: Transport[],
+export function fallback<const transports extends Transport[]>(
+  transports_: transports,
   config: FallbackTransportConfig = {},
-): FallbackTransport {
+): FallbackTransport<transports> {
   const {
     key = 'fallback',
     name = 'Fallback',
@@ -101,7 +104,7 @@ export function fallback(
     retryCount,
     retryDelay,
   } = config
-  return ({ chain, pollingInterval = 4_000, timeout, ...rest }) => {
+  return (({ chain, pollingInterval = 4_000, timeout, ...rest }) => {
     let transports = transports_
 
     let onResponse: OnResponseFn = () => {}
@@ -168,7 +171,7 @@ export function fallback(
       rankTransports({
         chain,
         interval: rankOptions.interval ?? pollingInterval,
-        onTransports: (transports_) => (transports = transports_),
+        onTransports: (transports_) => (transports = transports_ as transports),
         sampleCount: rankOptions.sampleCount,
         timeout: rankOptions.timeout,
         transports,
@@ -176,7 +179,7 @@ export function fallback(
       })
     }
     return transport
-  }
+  }) as FallbackTransport<transports>
 }
 
 function shouldThrow(error: Error) {

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.9.22'
+export const version = '2.9.24'

package/experimental/eip3074/actions/signAuthMessage.ts

@@ -0,0 +1,103 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../../errors/account.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account, PrivateKeyAccount } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import type { IsUndefined } from '../../../types/utils.js'
+import type { ToAuthMessageParameters } from '../utils/toAuthMessage.js'
+
+export type SignAuthMessageParameters<
+  account extends Account | undefined = Account | undefined,
+> = ToAuthMessageParameters &
+  // TODO: Use `GetAccountParameter` when JSON-RPC method for sign auth message exists.
+  (IsUndefined<account> extends true
+    ? { account: PrivateKeyAccount }
+    : account extends PrivateKeyAccount
+      ? { account?: PrivateKeyAccount | undefined }
+      : { account: PrivateKeyAccount })
+
+export type SignAuthMessageReturnType = Hex
+
+export type SignAuthMessageErrorType = ErrorType
+
+/**
+ * Calculates an [EIP-3074](https://eips.ethereum.org/EIPS/eip-3074) auth signature.
+ *
+ * With the calculated signature, you can:
+ *  - pass it to an EIP-3074 compatible invoker contract,
+ *  - use [`verifyAuthMessage`](/experimental/eip3074/verifyAuthMessage) to verify the signature,
+ *  - use [`recoverAuthMessageAddress`](/experimental/eip3074/recoverAuthMessageAddress) to recover the signing address from a signature.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignAuthMessageParameters}
+ * @returns The signed auth message. {@link SignAuthMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signAuthMessage } from 'viem/experimental'
+ *
+ * const account = privateKeyToAccount('0x...')
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const signature = await signAuthMessage(client, {
+ *   account,
+ *   chainId: 1,
+ *   commit: keccak256('0x1234'),
+ *   invokerAddress: '0x0000000000000000000000000000000000000000',
+ *   nonce: 69,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signAuthMessage } from 'viem/experimental'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const signature = await signAuthMessage(client, {
+ *   chainId: 1,
+ *   commit: keccak256('0x1234'),
+ *   invokerAddress: '0x0000000000000000000000000000000000000000',
+ *   nonce: 69,
+ * })
+ */
+export async function signAuthMessage<
+  chain extends Chain | undefined,
+  // TODO: Use `Account` when JSON-RPC method for sign auth message exists.
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  {
+    // @ts-expect-error – TODO: Remove when JSON-RPC method for sign auth message exists.
+    account = client.account,
+    chainId,
+    commit,
+    invokerAddress,
+    nonce,
+  }: SignAuthMessageParameters<account>,
+): Promise<SignAuthMessageReturnType> {
+  if (!account)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/eip5792/signAuthMessage',
+    })
+  return account.experimental_signAuthMessage({
+    chainId,
+    commit,
+    invokerAddress,
+    nonce,
+  })
+}

package/experimental/eip3074/decorators/eip3074.ts

@@ -0,0 +1,51 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { Account, PrivateKeyAccount } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import {
+  type SignAuthMessageParameters,
+  type SignAuthMessageReturnType,
+  signAuthMessage,
+} from '../actions/signAuthMessage.js'
+
+export type WalletActionsEip3074<
+  account extends Account | undefined = Account | undefined,
+> = {
+  signAuthMessage: (
+    parameters: SignAuthMessageParameters<
+      account extends PrivateKeyAccount ? account : undefined
+    >,
+  ) => Promise<SignAuthMessageReturnType>
+}
+
+/**
+ * A suite of EIP-3074 Wallet Actions.
+ *
+ * - Docs: https://viem.sh/experimental
+ *
+ * @example
+ * import { createPublicClient, createWalletClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { walletActionsEip3074 } from 'viem/experimental'
+ *
+ * const walletClient = createWalletClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(walletActionsEip3074())
+ *
+ * const signature = await walletClient.signAuthMessage({...})
+ */
+export function walletActionsEip3074() {
+  return <
+    transport extends Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): WalletActionsEip3074<account> => {
+    return {
+      signAuthMessage: (parameters) =>
+        signAuthMessage(client as any, parameters),
+    }
+  }
+}

package/experimental/eip3074/utils/recoverAuthMessageAddress.ts

@@ -0,0 +1,29 @@
+import type { Address } from 'abitype'
+
+import type { ByteArray, Hex } from '../../../types/misc.js'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import { keccak256 } from '../../../utils/hash/keccak256.js'
+import {
+  type RecoverAddressErrorType,
+  recoverAddress,
+} from '../../../utils/signature/recoverAddress.js'
+import { type ToAuthMessageParameters, toAuthMessage } from './toAuthMessage.js'
+
+export type RecoverAuthMessageAddressParameters = ToAuthMessageParameters & {
+  signature: Hex | ByteArray
+}
+
+export type RecoverAuthMessageAddressReturnType = Address
+
+export type RecoverAuthMessageAddressErrorType =
+  | RecoverAddressErrorType
+  | ErrorType
+
+export async function recoverAuthMessageAddress({
+  signature,
+  ...parameters
+}: RecoverAuthMessageAddressParameters): Promise<RecoverAuthMessageAddressReturnType> {
+  const hash = keccak256(toAuthMessage(parameters))
+  return recoverAddress({ hash, signature })
+}

package/experimental/eip3074/utils/signAuthMessage.ts

@@ -0,0 +1,40 @@
+import { type SignErrorType, sign } from '../../../accounts/utils/sign.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex } from '../../../types/misc.js'
+import { keccak256 } from '../../../utils/hash/keccak256.js'
+import {
+  type SignatureToHexErrorType,
+  signatureToHex,
+} from '../../../utils/signature/signatureToHex.js'
+import {
+  type ToAuthMessageErrorType,
+  type ToAuthMessageParameters,
+  toAuthMessage,
+} from './toAuthMessage.js'
+
+export type SignAuthMessageParameters = ToAuthMessageParameters & {
+  /** The private key to sign with. */
+  privateKey: Hex
+}
+
+export type SignAuthMessageReturnType = Hex
+
+export type SignAuthMessageErrorType =
+  | SignErrorType
+  | ToAuthMessageErrorType
+  | SignatureToHexErrorType
+  | ErrorType
+
+/**
+ * Computes a EIP-3074 authorization signature in format: `keccak256(MAGIC || chainId || nonce || invokerAddress || commit))`.
+ */
+export async function signAuthMessage(
+  parameters: SignAuthMessageParameters,
+): Promise<SignAuthMessageReturnType> {
+  const { privateKey } = parameters
+  const signature = await sign({
+    hash: keccak256(toAuthMessage(parameters)),
+    privateKey,
+  })
+  return signatureToHex(signature)
+}

package/experimental/eip3074/utils/toAuthMessage.ts

@@ -0,0 +1,50 @@
+import type { Address } from 'abitype'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hash } from '../../../types/misc.js'
+import {
+  type EncodePackedErrorType,
+  encodePacked,
+} from '../../../utils/abi/encodePacked.js'
+import { type PadHexErrorType, padHex } from '../../../utils/data/pad.js'
+import {
+  type NumberToHexErrorType,
+  numberToHex,
+} from '../../../utils/encoding/toHex.js'
+import { type Keccak256ErrorType } from '../../../utils/hash/keccak256.js'
+
+export type ToAuthMessageParameters = {
+  chainId: number
+  commit: Hash
+  invokerAddress: Address
+  nonce: number
+}
+
+export type ToAuthMessageReturnType = Hash
+
+export type ToAuthMessageErrorType =
+  | Keccak256ErrorType
+  | EncodePackedErrorType
+  | NumberToHexErrorType
+  | PadHexErrorType
+  | ErrorType
+
+/**
+ * Returns the message to be signed for EIP-3074 authorization.
+ */
+export function toAuthMessage({
+  chainId,
+  commit,
+  invokerAddress,
+  nonce,
+}: ToAuthMessageParameters): ToAuthMessageReturnType {
+  return encodePacked(
+    ['uint8', 'bytes32', 'uint256', 'bytes32', 'bytes32'],
+    [
+      0x04, // MAGIC
+      numberToHex(chainId, { size: 32 }),
+      BigInt(nonce),
+      padHex(invokerAddress, { size: 32 }),
+      commit,
+    ],
+  )
+}