viem 2.37.13 → 2.38.0

package/actions/wallet/sendCallsSync.ts

@@ -0,0 +1,85 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetCallsStatusReturnType } from './getCallsStatus.js'
+import {
+  type SendCallsErrorType,
+  type SendCallsParameters,
+  sendCalls,
+} from './sendCalls.js'
+import {
+  type WaitForCallsStatusParameters,
+  waitForCallsStatus,
+} from './waitForCallsStatus.js'
+
+export type SendCallsSyncParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  calls extends readonly unknown[] = readonly unknown[],
+> = SendCallsParameters<chain, account, chainOverride, calls> &
+  Pick<
+    WaitForCallsStatusParameters,
+    'pollingInterval' | 'status' | 'throwOnFailure'
+  > & {
+    /** Timeout (ms) to wait for calls to be included in a block. @default chain.blockTime * 3 */
+    timeout?: number | undefined
+  }
+
+export type SendCallsSyncReturnType = GetCallsStatusReturnType
+
+export type SendCallsSyncErrorType = SendCallsErrorType
+
+/**
+ * Requests the connected wallet to send a batch of calls, and waits for the calls to be included in a block.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendCallsSync
+ * - JSON-RPC Methods: [`wallet_sendCalls`](https://eips.ethereum.org/EIPS/eip-5792)
+ *
+ * @param client - Client to use
+ * @returns Calls status. {@link SendCallsSyncReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendCalls } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const status = await sendCallsSync(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   calls: [
+ *     {
+ *       data: '0xdeadbeef',
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *     },
+ *     {
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *       value: 69420n,
+ *     },
+ *   ],
+ * })
+ */
+export async function sendCallsSync<
+  const calls extends readonly unknown[],
+  chain extends Chain | undefined,
+  account extends Account | undefined = undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SendCallsSyncParameters<chain, account, chainOverride, calls>,
+): Promise<SendCallsSyncReturnType> {
+  const { chain = client.chain } = parameters
+  const timeout =
+    parameters.timeout ?? Math.max((chain?.blockTime ?? 0) * 3, 5_000)
+  const result = await sendCalls(client, parameters)
+  const status = await waitForCallsStatus(client, {
+    ...parameters,
+    id: result.id,
+    timeout,
+  })
+  return status
+}

package/actions/wallet/sendRawTransactionSync.ts

@@ -0,0 +1,68 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+import type { TransactionSerializedGeneric } from '../../types/transaction.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import { formatTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import {
+  type FormattedTransactionReceipt,
+  numberToHex,
+} from '../../utils/index.js'
+
+export type SendRawTransactionSyncParameters = {
+  /** The signed serialized transaction. */
+  serializedTransaction: TransactionSerializedGeneric
+  /** The timeout for the transaction. */
+  timeout?: number | undefined
+}
+
+export type SendRawTransactionSyncReturnType<
+  chain extends Chain | undefined = undefined,
+> = FormattedTransactionReceipt<chain>
+
+export type SendRawTransactionSyncErrorType = RequestErrorType | ErrorType
+
+/**
+ * Sends a **signed** transaction to the network synchronously,
+ * and waits for the transaction to be included in a block.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransactionSync
+ * - JSON-RPC Method: [`eth_sendRawTransactionSync`](https://eips.ethereum.org/EIPS/eip-7966)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendRawTransactionParameters}
+ * @returns The transaction receipt. {@link SendRawTransactionSyncReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendRawTransactionSync } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const receipt = await sendRawTransactionSync(client, {
+ *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+ * })
+ */
+export async function sendRawTransactionSync<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  { serializedTransaction, timeout }: SendRawTransactionSyncParameters,
+): Promise<SendRawTransactionSyncReturnType<chain>> {
+  const receipt = await client.request(
+    {
+      method: 'eth_sendRawTransactionSync',
+      params: timeout
+        ? [serializedTransaction, numberToHex(timeout)]
+        : [serializedTransaction],
+    },
+    { retryCount: 0 },
+  )
+  const format =
+    client.chain?.formatters?.transactionReceipt?.format ||
+    formatTransactionReceipt
+  return format(receipt) as SendRawTransactionSyncReturnType<chain>
+}

package/actions/wallet/sendTransactionSync.ts

@@ -0,0 +1,390 @@
+import type { Address } from 'abitype'
+
+import type { Account } from '../../accounts/types.js'
+import {
+  type ParseAccountErrorType,
+  parseAccount,
+} from '../../accounts/utils/parseAccount.js'
+import type { SignTransactionErrorType } from '../../accounts/utils/signTransaction.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import {
+  AccountNotFoundError,
+  type AccountNotFoundErrorType,
+  AccountTypeNotSupportedError,
+  type AccountTypeNotSupportedErrorType,
+} from '../../errors/account.js'
+import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../types/chain.js'
+import type { GetTransactionRequestKzgParameter } from '../../types/kzg.js'
+import type { Hash } from '../../types/misc.js'
+import type { TransactionRequest } from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import {
+  type RecoverAuthorizationAddressErrorType,
+  recoverAuthorizationAddress,
+} from '../../utils/authorization/recoverAuthorizationAddress.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+import {
+  type AssertCurrentChainErrorType,
+  assertCurrentChain,
+} from '../../utils/chain/assertCurrentChain.js'
+import {
+  type GetTransactionErrorReturnType,
+  getTransactionError,
+} from '../../utils/errors/getTransactionError.js'
+import { extract } from '../../utils/formatters/extract.js'
+import {
+  type FormattedTransactionRequest,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import { getAction } from '../../utils/getAction.js'
+import { LruMap } from '../../utils/lru.js'
+import {
+  type AssertRequestErrorType,
+  type AssertRequestParameters,
+  assertRequest,
+} from '../../utils/transaction/assertRequest.js'
+import { type GetChainIdErrorType, getChainId } from '../public/getChainId.js'
+import {
+  type WaitForTransactionReceiptErrorType,
+  waitForTransactionReceipt,
+} from '../public/waitForTransactionReceipt.js'
+import {
+  defaultParameters,
+  type PrepareTransactionRequestErrorType,
+  prepareTransactionRequest,
+} from './prepareTransactionRequest.js'
+import {
+  type SendRawTransactionSyncErrorType,
+  type SendRawTransactionSyncReturnType,
+  sendRawTransactionSync,
+} from './sendRawTransactionSync.js'
+
+const supportsWalletNamespace = new LruMap<boolean>(128)
+
+export type SendTransactionSyncRequest<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  ///
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = UnionOmit<FormattedTransactionRequest<_derivedChain>, 'from'> &
+  GetTransactionRequestKzgParameter
+
+export type SendTransactionSyncParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  request extends SendTransactionSyncRequest<
+    chain,
+    chainOverride
+  > = SendTransactionSyncRequest<chain, chainOverride>,
+> = request &
+  GetAccountParameter<account, Account | Address, true, true> &
+  GetChainParameter<chain, chainOverride> &
+  GetTransactionRequestKzgParameter<request> & {
+    /** Polling interval (ms) to poll for the transaction receipt. @default client.pollingInterval */
+    pollingInterval?: number | undefined
+    /** Timeout (ms) to wait for a response. @default Math.max(chain.blockTime * 3, 5_000) */
+    timeout?: number | undefined
+  }
+
+export type SendTransactionSyncReturnType<
+  chain extends Chain | undefined = Chain | undefined,
+> = SendRawTransactionSyncReturnType<chain>
+
+export type SendTransactionSyncErrorType =
+  | ParseAccountErrorType
+  | GetTransactionErrorReturnType<
+      | AccountNotFoundErrorType
+      | AccountTypeNotSupportedErrorType
+      | AssertCurrentChainErrorType
+      | AssertRequestErrorType
+      | GetChainIdErrorType
+      | PrepareTransactionRequestErrorType
+      | SendRawTransactionSyncErrorType
+      | RecoverAuthorizationAddressErrorType
+      | SignTransactionErrorType
+      | RequestErrorType
+    >
+  | WaitForTransactionReceiptErrorType
+  | ErrorType
+
+/**
+ * Creates, signs, and sends a new transaction to the network synchronously.
+ * Returns the transaction receipt.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionSyncParameters}
+ * @returns The transaction receipt. {@link SendTransactionSyncReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransactionSync } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const receipt = await sendTransactionSync(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransactionSync } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const receipt = await sendTransactionSync(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export async function sendTransactionSync<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  const request extends SendTransactionSyncRequest<chain, chainOverride>,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SendTransactionSyncParameters<
+    chain,
+    account,
+    chainOverride,
+    request
+  >,
+): Promise<SendTransactionSyncReturnType<chain>> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    accessList,
+    authorizationList,
+    blobs,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerBlobGas,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    pollingInterval,
+    type,
+    value,
+    ...rest
+  } = parameters
+  const timeout =
+    parameters.timeout ?? Math.max((chain?.blockTime ?? 0) * 3, 5_000)
+
+  if (typeof account_ === 'undefined')
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/sendTransactionSync',
+    })
+  const account = account_ ? parseAccount(account_) : null
+
+  try {
+    assertRequest(parameters as AssertRequestParameters)
+
+    const to = await (async () => {
+      // If `to` exists on the parameters, use that.
+      if (parameters.to) return parameters.to
+
+      // If `to` is null, we are sending a deployment transaction.
+      if (parameters.to === null) return undefined
+
+      // If no `to` exists, and we are sending a EIP-7702 transaction, use the
+      // address of the first authorization in the list.
+      if (authorizationList && authorizationList.length > 0)
+        return await recoverAuthorizationAddress({
+          authorization: authorizationList[0],
+        }).catch(() => {
+          throw new BaseError(
+            '`to` is required. Could not infer from `authorizationList`.',
+          )
+        })
+
+      // Otherwise, we are sending a deployment transaction.
+      return undefined
+    })()
+
+    if (account?.type === 'json-rpc' || account === null) {
+      let chainId: number | undefined
+      if (chain !== null) {
+        chainId = await getAction(client, getChainId, 'getChainId')({})
+        assertCurrentChain({
+          currentChainId: chainId,
+          chain,
+        })
+      }
+
+      const chainFormat = client.chain?.formatters?.transactionRequest?.format
+      const format = chainFormat || formatTransactionRequest
+
+      const request = format(
+        {
+          // Pick out extra data that might exist on the chain's transaction request type.
+          ...extract(rest, { format: chainFormat }),
+          accessList,
+          authorizationList,
+          blobs,
+          chainId,
+          data,
+          from: account?.address,
+          gas,
+          gasPrice,
+          maxFeePerBlobGas,
+          maxFeePerGas,
+          maxPriorityFeePerGas,
+          nonce,
+          to,
+          type,
+          value,
+        } as TransactionRequest,
+        'sendTransaction',
+      )
+
+      const isWalletNamespaceSupported = supportsWalletNamespace.get(client.uid)
+      const method = isWalletNamespaceSupported
+        ? 'wallet_sendTransaction'
+        : 'eth_sendTransaction'
+
+      const hash = await (async () => {
+        try {
+          return await client.request(
+            {
+              method,
+              params: [request],
+            },
+            { retryCount: 0 },
+          )
+        } catch (e) {
+          if (isWalletNamespaceSupported === false) throw e
+
+          const error = e as BaseError
+          // If the transport does not support the method or input, attempt to use the
+          // `wallet_sendTransaction` method.
+          if (
+            error.name === 'InvalidInputRpcError' ||
+            error.name === 'InvalidParamsRpcError' ||
+            error.name === 'MethodNotFoundRpcError' ||
+            error.name === 'MethodNotSupportedRpcError'
+          ) {
+            return (await client
+              .request(
+                {
+                  method: 'wallet_sendTransaction',
+                  params: [request],
+                },
+                { retryCount: 0 },
+              )
+              .then((hash) => {
+                supportsWalletNamespace.set(client.uid, true)
+                return hash
+              })
+              .catch((e) => {
+                const walletNamespaceError = e as BaseError
+                if (
+                  walletNamespaceError.name === 'MethodNotFoundRpcError' ||
+                  walletNamespaceError.name === 'MethodNotSupportedRpcError'
+                ) {
+                  supportsWalletNamespace.set(client.uid, false)
+                  throw error
+                }
+
+                throw walletNamespaceError
+              })) as never
+          }
+
+          throw error
+        }
+      })()
+
+      return getAction(
+        client,
+        waitForTransactionReceipt,
+        'waitForTransactionReceipt',
+      )({
+        checkReplacement: false,
+        hash,
+        pollingInterval,
+        timeout,
+      })
+    }
+
+    if (account?.type === 'local') {
+      // Prepare the request for signing (assign appropriate fees, etc.)
+      const request = await getAction(
+        client,
+        prepareTransactionRequest,
+        'prepareTransactionRequest',
+      )({
+        account,
+        accessList,
+        authorizationList,
+        blobs,
+        chain,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerBlobGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        nonceManager: account.nonceManager,
+        parameters: [...defaultParameters, 'sidecars'],
+        type,
+        value,
+        ...rest,
+        to,
+      } as any)
+
+      const serializer = chain?.serializers?.transaction
+      const serializedTransaction = (await account.signTransaction(request, {
+        serializer,
+      })) as Hash
+      return (await getAction(
+        client,
+        sendRawTransactionSync,
+        'sendRawTransactionSync',
+      )({
+        serializedTransaction,
+      })) as never
+    }
+
+    if (account?.type === 'smart')
+      throw new AccountTypeNotSupportedError({
+        metaMessages: [
+          'Consider using the `sendUserOperation` Action instead.',
+        ],
+        docsPath: '/docs/actions/bundler/sendUserOperation',
+        type: 'smart',
+      })
+
+    throw new AccountTypeNotSupportedError({
+      docsPath: '/docs/actions/wallet/sendTransactionSync',
+      type: (account as any)?.type,
+    })
+  } catch (err) {
+    if (err instanceof AccountTypeNotSupportedError) throw err
+    throw getTransactionError(err as BaseError, {
+      ...parameters,
+      account,
+      chain: parameters.chain || undefined,
+    })
+  }
+}

package/actions/wallet/writeContract.ts

@@ -43,6 +43,7 @@ import {
   type SendTransactionReturnType,
   sendTransaction,
 } from './sendTransaction.js'
+import type { sendTransactionSync } from './sendTransactionSync.js'
 
 export type WriteContractParameters<
   abi extends Abi | readonly unknown[] = Abi,
@@ -171,47 +172,81 @@ export async function writeContract<
     chainOverride
   >,
 ): Promise<WriteContractReturnType> {
-  const {
-    abi,
-    account: account_ = client.account,
-    address,
-    args,
-    dataSuffix,
-    functionName,
-    ...request
-  } = parameters as WriteContractParameters
-
-  if (typeof account_ === 'undefined')
-    throw new AccountNotFoundError({
-      docsPath: '/docs/contract/writeContract',
-    })
-  const account = account_ ? parseAccount(account_) : null
-
-  const data = encodeFunctionData({
-    abi,
-    args,
-    functionName,
-  } as EncodeFunctionDataParameters)
+  return writeContract.internal(
+    client,
+    sendTransaction,
+    'sendTransaction',
+    parameters,
+  ) as never
+}
 
-  try {
-    return await getAction(
-      client,
-      sendTransaction,
-      'sendTransaction',
-    )({
-      data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
-      to: address,
+export namespace writeContract {
+  export async function internal<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+    const abi extends Abi | readonly unknown[],
+    functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+    args extends ContractFunctionArgs<
+      abi,
+      'nonpayable' | 'payable',
+      functionName
+    >,
+    chainOverride extends Chain | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    actionFn: typeof sendTransaction | typeof sendTransactionSync,
+    name: 'sendTransaction' | 'sendTransactionSync',
+    parameters: WriteContractParameters<
+      abi,
+      functionName,
+      args,
+      chain,
       account,
-      ...request,
-    })
-  } catch (error) {
-    throw getContractError(error as BaseError, {
+      chainOverride
+    >,
+  ) {
+    const {
       abi,
+      account: account_ = client.account,
       address,
       args,
-      docsPath: '/docs/contract/writeContract',
+      dataSuffix,
+      functionName,
+      ...request
+    } = parameters as WriteContractParameters
+
+    if (typeof account_ === 'undefined')
+      throw new AccountNotFoundError({
+        docsPath: '/docs/contract/writeContract',
+      })
+    const account = account_ ? parseAccount(account_) : null
+
+    const data = encodeFunctionData({
+      abi,
+      args,
       functionName,
-      sender: account?.address,
-    })
+    } as EncodeFunctionDataParameters)
+
+    try {
+      return await getAction(
+        client,
+        actionFn as never,
+        name,
+      )({
+        data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
+        to: address,
+        account,
+        ...request,
+      })
+    } catch (error) {
+      throw getContractError(error as BaseError, {
+        abi,
+        address,
+        args,
+        docsPath: '/docs/contract/writeContract',
+        functionName,
+        sender: account?.address,
+      })
+    }
   }
 }