viem 2.37.12 → 2.38.0

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,
+      })
+    }
   }
 }

package/actions/wallet/writeContractSync.ts

@@ -0,0 +1,108 @@
+import type { Abi } from 'abitype'
+
+import type { Account } from '../../accounts/types.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type {
+  ContractFunctionArgs,
+  ContractFunctionName,
+} from '../../types/contract.js'
+import {
+  type SendTransactionSyncParameters,
+  type SendTransactionSyncReturnType,
+  sendTransactionSync,
+} from './sendTransactionSync.js'
+import { type WriteContractParameters, writeContract } from './writeContract.js'
+
+export type { WriteContractErrorType as WriteContractSyncErrorType } from './writeContract.js'
+
+export type WriteContractSyncParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'nonpayable' | 'payable'
+  > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+> = WriteContractParameters<
+  abi,
+  functionName,
+  args,
+  chain,
+  account,
+  chainOverride
+> &
+  Pick<SendTransactionSyncParameters<chain>, 'pollingInterval' | 'timeout'>
+
+export type WriteContractSyncReturnType<
+  chain extends Chain | undefined = Chain | undefined,
+> = SendTransactionSyncReturnType<chain>
+
+/**
+ * Executes a write function on a contract synchronously.
+ * Returns the transaction receipt.
+ *
+ * - Docs: https://viem.sh/docs/contract/writeContractSync
+ *
+ * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms) is needed to be broadcast in order to change the state.
+ *
+ * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+ *
+ * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract#usage) before you execute it.__
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WriteContractParameters}
+ * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms#hash). {@link WriteContractReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { writeContract } from 'viem/contract'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const receipt = await writeContractSync(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+ *   functionName: 'mint',
+ *   args: [69420],
+ * })
+ */
+export async function writeContractSync<
+  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>,
+  parameters: WriteContractSyncParameters<
+    abi,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride
+  >,
+): Promise<WriteContractSyncReturnType<chain>> {
+  return writeContract.internal(
+    client,
+    sendTransactionSync,
+    'sendTransactionSync',
+    parameters as never,
+  ) as never
+}

package/chains/definitions/domaTestnet.ts

@@ -0,0 +1,21 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const domaTestnet = /*#__PURE__*/ defineChain({
+  id: 97_476,
+  name: 'Doma Testnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Ether',
+    symbol: 'ETH',
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc-testnet.doma.xyz'] },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Doma Testnet Explorer',
+      url: 'https://explorer-testnet.doma.xyz',
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/nitrographTestnet.ts

@@ -0,0 +1,23 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const nitrographTestnet = /*#__PURE__*/ defineChain({
+  id: 200024,
+  name: 'Nitrograph Testnet',
+  testnet: true,
+  rpcUrls: {
+    default: {
+      http: ['https://rpc-testnet.nitrograph.foundation'],
+    },
+  },
+  nativeCurrency: {
+    name: 'Nitro',
+    symbol: 'NOS',
+    decimals: 18,
+  },
+  blockExplorers: {
+    default: {
+      url: 'https://explorer-testnet.nitrograph.foundation',
+      name: 'Nitrograph Explorer',
+    },
+  },
+})

package/chains/definitions/tronNile.ts

@@ -0,0 +1,19 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const tronNile = /*#__PURE__*/ defineChain({
+  id: 3448148188,
+  name: 'Tron Nile',
+  nativeCurrency: { name: 'TRON', symbol: 'TRX', decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ['https://nile.trongrid.io/jsonrpc'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Tronscan',
+      url: 'https://nile.tronscan.org',
+    },
+  },
+  testnet: true,
+})