viem 1.6.7 → 1.8.0

package/src/actions/wallet/signTransaction.ts

@@ -0,0 +1,137 @@
+import type { Account } from '../../accounts/types.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../errors/account.js'
+import type { GetAccountParameter } from '../../types/account.js'
+import type { Chain, GetChain } from '../../types/chain.js'
+import { type RpcTransactionRequest } from '../../types/rpc.js'
+import type {
+  TransactionRequest,
+  TransactionSerializable,
+  TransactionSerialized,
+} from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+import { assertCurrentChain } from '../../utils/chain.js'
+import {
+  type FormattedTransactionRequest,
+  formatTransactionRequest,
+} from '../../utils/formatters/transactionRequest.js'
+import { numberToHex } from '../../utils/index.js'
+import { assertRequest } from '../../utils/transaction/assertRequest.js'
+import { getChainId } from '../public/getChainId.js'
+
+export type SignTransactionParameters<
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+  TChainOverride extends Chain | undefined = Chain | undefined,
+> = UnionOmit<
+  FormattedTransactionRequest<
+    TChainOverride extends Chain ? TChainOverride : TChain
+  >,
+  'from'
+> &
+  GetAccountParameter<TAccount> &
+  GetChain<TChain, TChainOverride>
+
+export type SignTransactionReturnType = TransactionSerialized
+
+/**
+ * Signs a transaction.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * @param args - {@link SignTransactionParameters}
+ * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTransaction } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTransaction } from 'viem/actions'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export async function signTransaction<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+  TChainOverride extends Chain | undefined,
+>(
+  client: Client<Transport, TChain, TAccount>,
+  args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
+): Promise<SignTransactionReturnType> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...transaction
+  } = args
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/signTransaction',
+    })
+  const account = parseAccount(account_)
+
+  assertRequest({
+    account,
+    ...args,
+  })
+
+  const chainId = await getChainId(client)
+  if (chain !== null)
+    assertCurrentChain({
+      currentChainId: chainId,
+      chain,
+    })
+
+  const formatters = chain?.formatters || client.chain?.formatters
+  const format =
+    formatters?.transactionRequest?.format || formatTransactionRequest
+
+  if (account.type === 'local')
+    return account.signTransaction(
+      {
+        chainId,
+        ...transaction,
+      } as unknown as TransactionSerializable,
+      { serializer: client.chain?.serializers?.transaction },
+    ) as Promise<SignTransactionReturnType>
+
+  return await client.request({
+    method: 'eth_signTransaction',
+    params: [
+      {
+        ...format(transaction as unknown as TransactionRequest),
+        chainId: numberToHex(chainId),
+        from: account.address,
+      } as unknown as RpcTransactionRequest,
+    ],
+  })
+}

package/src/actions/wallet/writeContract.ts

@@ -4,7 +4,8 @@ import type { Account } from '../../accounts/types.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { GetAccountParameter } from '../../types/account.js'
-import type { Chain, GetChain } from '../../types/chain.js'
+import type { Chain } from '../../types/chain.js'
+import type { GetChain } from '../../types/chain.js'
 import type { ContractFunctionConfig, GetValue } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { UnionOmit } from '../../types/utils.js'

package/src/chains/celo/formatters.ts

@@ -1,5 +1,6 @@
 import { type ChainFormatters } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
+import type { RpcTransaction } from '../../types/rpc.js'
 import { hexToBigInt } from '../../utils/encoding/fromHex.js'
 import { numberToHex } from '../../utils/encoding/toHex.js'
 import { defineBlock } from '../../utils/formatters/block.js'
@@ -12,13 +13,11 @@ import { defineTransactionRequest } from '../../utils/formatters/transactionRequ
 import type {
   CeloBlockOverrides,
   CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
   CeloRpcTransactionReceiptOverrides,
-  CeloRpcTransactionRequestOverrides,
+  CeloRpcTransactionRequest,
   CeloTransaction,
-  CeloTransactionOverrides,
   CeloTransactionReceiptOverrides,
-  CeloTransactionRequestOverrides,
+  CeloTransactionRequest,
 } from './types.js'
 
 export const formattersCelo = {
@@ -34,7 +33,7 @@ export const formattersCelo = {
       const transactions = args.transactions?.map((transaction) => {
         if (typeof transaction === 'string') return transaction
         return {
-          ...formatTransaction(transaction),
+          ...formatTransaction(transaction as RpcTransaction),
           feeCurrency: transaction.feeCurrency,
           gatewayFee: transaction.gatewayFee
             ? hexToBigInt(transaction.gatewayFee)
@@ -49,12 +48,12 @@ export const formattersCelo = {
     },
   }),
   transaction: /*#__PURE__*/ defineTransaction({
-    format(args: CeloRpcTransactionOverrides): CeloTransactionOverrides {
+    format(args: CeloRpcTransaction): CeloTransaction {
       return {
         feeCurrency: args.feeCurrency,
         gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloTransaction
     },
   }),
   transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
@@ -69,17 +68,17 @@ export const formattersCelo = {
     },
   }),
   transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format(
-      args: CeloTransactionRequestOverrides,
-    ): CeloRpcTransactionRequestOverrides {
-      return {
+    format(args: CeloTransactionRequest): CeloRpcTransactionRequest {
+      const request = {
         feeCurrency: args.feeCurrency,
         gatewayFee:
           typeof args.gatewayFee !== 'undefined'
             ? numberToHex(args.gatewayFee)
             : undefined,
         gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
+      } as CeloRpcTransactionRequest
+      if (args.type === 'cip42') request.type = '0x7c'
+      return request
     },
   }),
 } as const satisfies ChainFormatters

package/src/chains/celo/types.ts

@@ -4,17 +4,21 @@ import type { Block, BlockTag } from '../../types/block.js'
 import type { FeeValuesEIP1559 } from '../../types/fee.js'
 import type { Hex } from '../../types/misc.js'
 import type {
+  Index,
+  Quantity,
   RpcBlock,
-  RpcTransaction,
+  RpcTransaction as RpcTransaction_,
   RpcTransactionReceipt,
-  RpcTransactionRequest,
+  RpcTransactionRequest as RpcTransactionRequest_,
   TransactionType,
 } from '../../types/rpc.js'
 import type {
   AccessList,
-  Transaction,
+  Transaction as Transaction_,
+  TransactionBase,
   TransactionReceipt,
-  TransactionRequest,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
   TransactionSerializable,
   TransactionSerializableBase,
   TransactionSerialized,
@@ -68,13 +72,9 @@ export type CeloRpcBlock<
 > &
   CeloRpcBlockOverrides
 
-export type CeloRpcTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: Hex | null
-  gatewayFeeRecipient: Address | null
-}
 export type CeloRpcTransaction<TPending extends boolean = boolean> =
-  RpcTransaction<TPending> & CeloRpcTransactionOverrides
+  | RpcTransaction<TPending>
+  | RpcTransactionCIP42<TPending>
 
 export type CeloRpcTransactionReceiptOverrides = {
   feeCurrency: Address | null
@@ -84,21 +84,13 @@ export type CeloRpcTransactionReceiptOverrides = {
 export type CeloRpcTransactionReceipt = RpcTransactionReceipt &
   CeloRpcTransactionReceiptOverrides
 
-export type CeloRpcTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: Hex
-  gatewayFeeRecipient?: Address
-}
-export type CeloRpcTransactionRequest = RpcTransactionRequest &
-  CeloRpcTransactionRequestOverrides
+export type CeloRpcTransactionRequest =
+  | RpcTransactionRequest
+  | RpcTransactionRequestCIP42
 
-export type CeloTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: bigint | null
-  gatewayFeeRecipient: Address | null
-}
 export type CeloTransaction<TPending extends boolean = boolean> =
-  Transaction<TPending> & CeloTransactionOverrides
+  | Transaction<TPending>
+  | TransactionCIP42<TPending>
 
 export type CeloTransactionReceiptOverrides = {
   feeCurrency: Address | null
@@ -108,13 +100,9 @@ export type CeloTransactionReceiptOverrides = {
 export type CeloTransactionReceipt = TransactionReceipt &
   CeloTransactionReceiptOverrides
 
-export type CeloTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: bigint
-  gatewayFeeRecipient?: Address
-}
-export type CeloTransactionRequest = TransactionRequest &
-  CeloTransactionRequestOverrides
+export type CeloTransactionRequest =
+  | TransactionRequest
+  | TransactionRequestCIP42
 
 export type CeloTransactionSerializable =
   | TransactionSerializableCIP42
@@ -126,6 +114,74 @@ export type CeloTransactionSerialized<
 
 export type CeloTransactionType = TransactionType | 'cip42'
 
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+
+type RpcTransactionRequest = RpcTransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: Hex
+  gatewayFeeRecipient?: Address
+}
+
+export type RpcTransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    FeeValuesEIP1559<Quantity> & {
+      feeCurrency: Address | null
+      gatewayFee: Hex | null
+      gatewayFeeRecipient: Address | null
+      type: '0x7c'
+    }
+
+export type RpcTransactionRequestCIP42 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  Partial<FeeValuesEIP1559<Quantity>> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: Hex
+    gatewayFeeRecipient?: Address
+    type?: '0x7c'
+  }
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+
+export type TransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      feeCurrency: Address | null
+      gatewayFee: bigint | null
+      gatewayFeeRecipient: Address | null
+      type: 'cip42'
+    }
+
+type TransactionRequest = TransactionRequest_ & {
+  feeCurrency?: Address
+  gatewayFee?: bigint
+  gatewayFeeRecipient?: Address
+}
+
+export type TransactionRequestCIP42 = TransactionRequestBase &
+  Partial<FeeValuesEIP1559> & {
+    accessList?: AccessList
+    feeCurrency?: Address
+    gatewayFee?: bigint
+    gatewayFeeRecipient?: Address
+    type?: 'cip42'
+  }
+
 export type TransactionSerializableCIP42<
   TQuantity = bigint,
   TIndex = number,

package/src/chains/utils.ts

@@ -10,20 +10,20 @@ export type {
   CeloRpcBlock,
   CeloRpcBlockOverrides,
   CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
   CeloRpcTransactionReceipt,
   CeloRpcTransactionReceiptOverrides,
   CeloRpcTransactionRequest,
-  CeloRpcTransactionRequestOverrides,
   CeloTransaction,
-  CeloTransactionOverrides,
   CeloTransactionReceipt,
   CeloTransactionReceiptOverrides,
   CeloTransactionRequest,
-  CeloTransactionRequestOverrides,
   CeloTransactionSerializable,
   CeloTransactionSerialized,
   CeloTransactionType,
+  RpcTransactionCIP42,
+  RpcTransactionRequestCIP42,
+  TransactionCIP42,
+  TransactionRequestCIP42,
   TransactionSerializableCIP42,
   TransactionSerializedCIP42,
 } from './celo/types.js'

package/src/clients/createTestClient.ts

@@ -1,3 +1,5 @@
+import type { Address } from 'abitype'
+
 import type { Account } from '../accounts/types.js'
 import type { ParseAccount } from '../types/account.js'
 import type { Chain } from '../types/chain.js'
@@ -6,7 +8,6 @@ import type { Prettify } from '../types/utils.js'
 import { type Client, type ClientConfig, createClient } from './createClient.js'
 import { type TestActions, testActions } from './decorators/test.js'
 import type { Transport } from './transports/createTransport.js'
-import type { Address } from 'abitype'
 
 export type TestClientMode = 'anvil' | 'hardhat' | 'ganache'
 

package/src/clients/decorators/public.ts

@@ -53,11 +53,21 @@ import {
   type EstimateContractGasReturnType,
   estimateContractGas,
 } from '../../actions/public/estimateContractGas.js'
+import {
+  type EstimateFeesPerGasParameters,
+  type EstimateFeesPerGasReturnType,
+  estimateFeesPerGas,
+} from '../../actions/public/estimateFeesPerGas.js'
 import {
   type EstimateGasParameters,
   type EstimateGasReturnType,
   estimateGas,
 } from '../../actions/public/estimateGas.js'
+import {
+  type EstimateMaxPriorityFeePerGasParameters,
+  type EstimateMaxPriorityFeePerGasReturnType,
+  estimateMaxPriorityFeePerGas,
+} from '../../actions/public/estimateMaxPriorityFeePerGas.js'
 import {
   type GetBalanceParameters,
   type GetBalanceReturnType,
@@ -196,6 +206,16 @@ import {
   type WatchPendingTransactionsReturnType,
   watchPendingTransactions,
 } from '../../actions/public/watchPendingTransactions.js'
+import {
+  type PrepareTransactionRequestParameters,
+  type PrepareTransactionRequestReturnType,
+  prepareTransactionRequest,
+} from '../../actions/wallet/prepareTransactionRequest.js'
+import {
+  type SendRawTransactionParameters,
+  type SendRawTransactionReturnType,
+  sendRawTransaction,
+} from '../../actions/wallet/sendRawTransaction.js'
 import type { Account } from '../../types/account.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
@@ -204,6 +224,7 @@ import type {
   MaybeAbiEventName,
   MaybeExtractEventArgsFromAbi,
 } from '../../types/contract.js'
+import type { FeeValuesType } from '../../types/fee.js'
 import type { FilterType } from '../../types/filter.js'
 import type { Client } from '../createClient.js'
 import type { Transport } from '../transports/createTransport.js'
@@ -764,6 +785,33 @@ export type PublicActions<
   getFeeHistory: (
     args: GetFeeHistoryParameters,
   ) => Promise<GetFeeHistoryReturnType>
+  /**
+   * Returns an estimate for the fees per gas for a transaction to be included
+   * in the next block.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/estimateFeesPerGas.html
+   *
+   * @param client - Client to use
+   * @param parameters - {@link EstimateFeesPerGasParameters}
+   * @returns An estimate (in wei) for the fees per gas. {@link EstimateFeesPerGasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   * const maxPriorityFeePerGas = await client.estimateFeesPerGas()
+   * // { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
+   */
+  estimateFeesPerGas: <
+    TChainOverride extends Chain | undefined,
+    TType extends FeeValuesType = 'eip1559',
+  >(
+    args?: EstimateFeesPerGasParameters<TChain, TChainOverride, TType>,
+  ) => Promise<EstimateFeesPerGasReturnType>
   /**
    * Returns a list of logs or hashes based on a [Filter](/docs/glossary/terms#filter) since the last time it was called.
    *
@@ -970,6 +1018,29 @@ export type PublicActions<
   ) => Promise<
     GetLogsReturnType<TAbiEvent, TAbiEvents, TStrict, TFromBlock, TToBlock>
   >
+  /**
+   * Returns an estimate for the max priority fee per gas (in wei) for a transaction
+   * to be included in the next block.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/estimateMaxPriorityFeePerGas.html
+   *
+   * @param client - Client to use
+   * @returns An estimate (in wei) for the max priority fee per gas. {@link EstimateMaxPriorityFeePerGasReturnType}
+   *
+   * @example
+   * import { createPublicClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   * const maxPriorityFeePerGas = await client.estimateMaxPriorityFeePerGas()
+   * // 10000000n
+   */
+  estimateMaxPriorityFeePerGas: <TChainOverride extends Chain | undefined,>(
+    args?: EstimateMaxPriorityFeePerGasParameters<TChain, TChainOverride>,
+  ) => Promise<EstimateMaxPriorityFeePerGasReturnType>
   /**
    * Returns the value from a storage slot at a given address.
    *
@@ -1138,6 +1209,47 @@ export type PublicActions<
   >(
     args: MulticallParameters<TContracts, TAllowFailure>,
   ) => Promise<MulticallReturnType<TContracts, TAllowFailure>>
+  /**
+   * Prepares a transaction request for signing.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html
+   *
+   * @param args - {@link PrepareTransactionRequestParameters}
+   * @returns The transaction request. {@link PrepareTransactionRequestReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   */
+  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+    args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<PrepareTransactionRequestReturnType>
   /**
    * Calls a read-only function on a contract, and returns the response.
    *
@@ -1175,6 +1287,33 @@ export type PublicActions<
   >(
     args: ReadContractParameters<TAbi, TFunctionName>,
   ) => Promise<ReadContractReturnType<TAbi, TFunctionName>>
+  /**
+   * Sends a **signed** transaction to the network
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
+   * - JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SendRawTransactionParameters}
+   * @returns The transaction hash. {@link SendRawTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { sendRawTransaction } from 'viem/wallet'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   *
+   * const hash = await client.sendRawTransaction({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransaction: (
+    args: SendRawTransactionParameters,
+  ) => Promise<SendRawTransactionReturnType>
   /**
    * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
    *
@@ -1492,10 +1631,13 @@ export function publicActions<
     getEnsResolver: (args) => getEnsResolver(client, args),
     getEnsText: (args) => getEnsText(client, args),
     getFeeHistory: (args) => getFeeHistory(client, args),
+    estimateFeesPerGas: (args) => estimateFeesPerGas(client, args),
     getFilterChanges: (args) => getFilterChanges(client, args),
     getFilterLogs: (args) => getFilterLogs(client, args),
     getGasPrice: () => getGasPrice(client),
     getLogs: (args) => getLogs(client, args as any),
+    estimateMaxPriorityFeePerGas: (args) =>
+      estimateMaxPriorityFeePerGas(client, args),
     getStorageAt: (args) => getStorageAt(client, args),
     getTransaction: (args) => getTransaction(client, args),
     getTransactionConfirmations: (args) =>
@@ -1503,7 +1645,10 @@ export function publicActions<
     getTransactionCount: (args) => getTransactionCount(client, args),
     getTransactionReceipt: (args) => getTransactionReceipt(client, args),
     multicall: (args) => multicall(client, args as any) as any,
+    prepareTransactionRequest: (args) =>
+      prepareTransactionRequest(client as any, args as any),
     readContract: (args) => readContract(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
     simulateContract: (args) => simulateContract(client, args),
     verifyMessage: (args) => verifyMessage(client, args),
     verifyTypedData: (args) => verifyTypedData(client, args),