viem 0.0.1-alpha.16 → 0.0.1-alpha.17

package/src/actions/public/simulateContract.test.ts

@@ -0,0 +1,238 @@
+/**
+ * TODO:  Heaps more test cases :D
+ *        - Complex calldata types
+ *        - Complex return types (tuple/structs)
+ *        - EIP-1559
+ *        - Calls against blocks
+ *        - Custom chain types
+ *        - Custom nonce
+ */
+
+import { describe, expect, test } from 'vitest'
+import {
+  accounts,
+  publicClient,
+  testClient,
+  wagmiContractConfig,
+  walletClient,
+} from '../../_test'
+import { baycContractConfig } from '../../_test/abis'
+import { encodeFunctionData } from '../../utils'
+import { mine } from '../test'
+import { sendTransaction } from '../wallet'
+
+import { deployContract } from './deployContract'
+import { getTransactionReceipt } from './getTransactionReceipt'
+import { simulateContract } from './simulateContract'
+
+describe('wagmi', () => {
+  test('default', async () => {
+    expect(
+      (
+        await simulateContract(publicClient, {
+          ...wagmiContractConfig,
+          from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          functionName: 'mint',
+          args: [69420n],
+        })
+      ).result,
+    ).toEqual(undefined)
+    expect(
+      (
+        await simulateContract(publicClient, {
+          ...wagmiContractConfig,
+          functionName: 'safeTransferFrom',
+          from: '0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6',
+          args: [
+            '0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6',
+            '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+            1n,
+          ],
+        })
+      ).result,
+    ).toEqual(undefined)
+  })
+
+  test('revert', async () => {
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'approve',
+        args: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC', 420n],
+        from: accounts[0].address,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "ERC721: approval to current owner
+       
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  approve(address to, uint256 tokenId)
+      Arguments:        (0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC, 420)
+
+      Details: execution reverted: ERC721: approval to current owner
+      Version: viem@1.0.2"
+    `)
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'mint',
+        args: [1n],
+        from: accounts[0].address,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "Token ID is taken
+       
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  mint(uint256 tokenId)
+      Arguments:     (1)
+
+      Details: execution reverted: Token ID is taken
+      Version: viem@1.0.2"
+    `)
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'safeTransferFrom',
+        from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+        args: [
+          '0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6',
+          '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          1n,
+        ],
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "ERC721: transfer caller is not owner nor approved
+       
+      Sender:    0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  safeTransferFrom(address from, address to, uint256 tokenId)
+      Arguments:                 (0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6, 0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC, 1)
+
+      Details: execution reverted: ERC721: transfer caller is not owner nor approved
+      Version: viem@1.0.2"
+    `)
+  })
+})
+
+describe('BAYC', () => {
+  describe('default', () => {
+    test('mintApe', async () => {
+      const { contractAddress } = await deployBAYC()
+
+      // Set sale state to active
+      // TODO: replace w/ writeContract
+      await sendTransaction(walletClient, {
+        data: encodeFunctionData({
+          abi: baycContractConfig.abi,
+          functionName: 'flipSaleState',
+        }),
+        from: accounts[0].address,
+        to: contractAddress!,
+      })
+      await mine(testClient, { blocks: 1 })
+
+      // Mint an Ape!
+      expect(
+        (
+          await simulateContract(publicClient, {
+            abi: baycContractConfig.abi,
+            address: contractAddress!,
+            functionName: 'mintApe',
+            from: accounts[0].address,
+            args: [1n],
+            value: 1000000000000000000n,
+          })
+        ).result,
+      ).toBe(undefined)
+    })
+
+    test('get a free $100k', async () => {
+      const { contractAddress } = await deployBAYC()
+
+      // Reserve apes
+      expect(
+        (
+          await simulateContract(publicClient, {
+            abi: baycContractConfig.abi,
+            address: contractAddress!,
+            functionName: 'reserveApes',
+            from: accounts[0].address,
+          })
+        ).result,
+      ).toBe(undefined)
+    })
+  })
+
+  describe('revert', () => {
+    test('sale inactive', async () => {
+      const { contractAddress } = await deployBAYC()
+
+      // Expect mint to fail.
+      await expect(() =>
+        simulateContract(publicClient, {
+          abi: baycContractConfig.abi,
+          address: contractAddress!,
+          functionName: 'mintApe',
+          from: accounts[0].address,
+          args: [1n],
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`
+        "Sale must be active to mint Ape
+         
+        Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  mintApe(uint256 numberOfTokens)
+        Arguments:        (1)
+
+        Details: execution reverted: Sale must be active to mint Ape
+        Version: viem@1.0.2"
+      `)
+    })
+  })
+})
+
+test('fake contract address', async () => {
+  await expect(() =>
+    simulateContract(publicClient, {
+      abi: [
+        {
+          name: 'mint',
+          type: 'function',
+          stateMutability: 'nonpayable',
+          inputs: [],
+          outputs: [{ type: 'uint256' }],
+        },
+      ],
+      address: '0x0000000000000000000000000000000000000069',
+      functionName: 'mint',
+      from: accounts[0].address,
+      args: [],
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "The contract method \\"mint\\" returned no data (\\"0x\\"). This could be due to any of the following:
+    - The contract does not have the function \\"mint\\",
+    - The parameters passed to the contract function may be invalid, or
+    - The address is not a contract.
+     
+    Contract: 0x0000000000000000000000000000000000000000
+    Function: mint()
+            > \\"0x\\"
+
+    Version: viem@1.0.2"
+  `)
+})
+
+// Deploy BAYC Contract
+async function deployBAYC() {
+  const hash = await deployContract(walletClient, {
+    ...baycContractConfig,
+    args: ['Bored Ape Wagmi Club', 'BAYC', 69420n, 0n],
+    from: accounts[0].address,
+  })
+  await mine(testClient, { blocks: 1 })
+  const { contractAddress } = await getTransactionReceipt(publicClient, {
+    hash,
+  })
+  return { contractAddress }
+}

package/src/actions/public/{callContract.ts → simulateContract.ts}

@@ -15,30 +15,42 @@ import {
   encodeFunctionData,
   getContractError,
 } from '../../utils'
+import { WriteContractArgs } from '../wallet'
 import { call, CallArgs, FormattedCall } from './call'
 
-export type FormattedCallContract<
+export type FormattedSimulateContract<
   TFormatter extends Formatter | undefined = Formatter,
 > = FormattedCall<TFormatter>
 
-export type CallContractArgs<
+export type SimulateContractArgs<
   TChain extends Chain = Chain,
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = any,
-> = Omit<CallArgs<TChain>, 'from' | 'to' | 'data' | 'value'> & {
+> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> & {
   address: Address
   abi: TAbi
-  from?: Address
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  functionName: ExtractFunctionNameFromAbi<
+    TAbi,
+    TFunctionName,
+    'payable' | 'nonpayable'
+  >
   value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
 } & ExtractArgsFromAbi<TAbi, TFunctionName>
 
-export type CallContractResponse<
+export type SimulateContractResponse<
+  TChain extends Chain = Chain,
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
-> = ExtractResultFromAbi<TAbi, TFunctionName>
+> = {
+  result: ExtractResultFromAbi<TAbi, TFunctionName>
+  request: WriteContractArgs<TChain, TAbi, TFunctionName> & {
+    address: Address
+    abi: TAbi
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  } & ExtractArgsFromAbi<TAbi, TFunctionName>
+}
 
-export async function callContract<
+export async function simulateContract<
   TChain extends Chain,
   TAbi extends Abi = Abi,
   TFunctionName extends string = any,
@@ -50,8 +62,8 @@ export async function callContract<
     args,
     functionName,
     ...callRequest
-  }: CallContractArgs<TChain, TAbi, TFunctionName>,
-): Promise<CallContractResponse<TAbi, TFunctionName>> {
+  }: SimulateContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<SimulateContractResponse<TChain, TAbi, TFunctionName>> {
   const calldata = encodeFunctionData({
     abi,
     args,
@@ -63,11 +75,21 @@ export async function callContract<
       to: address,
       ...callRequest,
     } as unknown as CallArgs<TChain>)
-    return decodeFunctionResult({
+    const result = decodeFunctionResult({
       abi,
       functionName,
       data: data || '0x',
-    }) as CallContractResponse<TAbi, TFunctionName>
+    })
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest,
+      },
+    } as unknown as SimulateContractResponse<TChain, TAbi, TFunctionName>
   } catch (err) {
     throw getContractError(err, {
       abi,

package/src/actions/wallet/index.test.ts

@@ -14,6 +14,7 @@ test('exports actions', () => {
       "signMessage": [Function],
       "switchChain": [Function],
       "watchAsset": [Function],
+      "writeContract": [Function],
     }
   `)
 })

package/src/actions/wallet/index.ts

@@ -25,3 +25,6 @@ export type { SwitchChainArgs } from './switchChain'
 
 export { watchAsset } from './watchAsset'
 export type { WatchAssetArgs, WatchAssetResponse } from './watchAsset'
+
+export { writeContract } from './writeContract'
+export type { WriteContractArgs, WriteContractResponse } from './writeContract'

package/src/actions/wallet/writeContract.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from 'vitest'
+import {
+  accounts,
+  publicClient,
+  testClient,
+  wagmiContractConfig,
+  walletClient,
+} from '../../_test'
+import { simulateContract } from '../public'
+import { mine } from '../test'
+
+import { writeContract } from './writeContract'
+
+test('default', async () => {
+  expect(
+    await writeContract(walletClient, {
+      ...wagmiContractConfig,
+      from: accounts[0].address,
+      functionName: 'mint',
+      args: [69420n],
+    }),
+  ).toBeDefined()
+})
+
+test('w/ simulateContract', async () => {
+  const { request } = await simulateContract(publicClient, {
+    ...wagmiContractConfig,
+    from: accounts[0].address,
+    functionName: 'mint',
+    args: [69420n],
+  })
+  expect(await writeContract(walletClient, request)).toBeDefined()
+
+  await mine(testClient, { blocks: 1 })
+
+  await expect(() =>
+    simulateContract(publicClient, {
+      ...wagmiContractConfig,
+      from: accounts[0].address,
+      functionName: 'mint',
+      args: [69420n],
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Token ID is taken
+     
+    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  mint(uint256 tokenId)
+    Arguments:     (69420)
+
+    Details: execution reverted: Token ID is taken
+    Version: viem@1.0.2"
+  `)
+})

package/src/actions/wallet/writeContract.ts

@@ -0,0 +1,61 @@
+import { Abi } from 'abitype'
+
+import type { Chain, Formatter } from '../../chains'
+import type { WalletClient } from '../../clients'
+import type {
+  Address,
+  ExtractArgsFromAbi,
+  ExtractFunctionNameFromAbi,
+  GetValue,
+} from '../../types'
+import { EncodeFunctionDataArgs, encodeFunctionData } from '../../utils'
+import {
+  FormattedTransactionRequest,
+  sendTransaction,
+  SendTransactionArgs,
+  SendTransactionResponse,
+} from './sendTransaction'
+
+export type FormattedWriteContract<
+  TFormatter extends Formatter | undefined = Formatter,
+> = FormattedTransactionRequest<TFormatter>
+
+export type WriteContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {
+  address: Address
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
+export type WriteContractResponse = SendTransactionResponse
+
+export async function writeContract<
+  TChain extends Chain,
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>(
+  client: WalletClient,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...request
+  }: WriteContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<WriteContractResponse> {
+  const data = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)
+  const hash = await sendTransaction(client, {
+    data,
+    to: address,
+    ...request,
+  } as unknown as SendTransactionArgs<TChain>)
+  return hash
+}

package/src/index.test.ts

@@ -65,7 +65,6 @@ test('exports actions', () => {
       "bytesToNumber": [Function],
       "bytesToString": [Function],
       "call": [Function],
-      "callContract": [Function],
       "createBlockFilter": [Function],
       "createClient": [Function],
       "createPendingTransactionFilter": [Function],
@@ -122,6 +121,7 @@ test('exports actions', () => {
       "getFilterLogs": [Function],
       "getFunctionSignature": [Function],
       "getGasPrice": [Function],
+      "getLogs": [Function],
       "getPermissions": [Function],
       "getTransaction": [Function],
       "getTransactionConfirmations": [Function],
@@ -177,6 +177,7 @@ test('exports actions', () => {
       "setNonce": [Function],
       "setStorageAt": [Function],
       "signMessage": [Function],
+      "simulateContract": [Function],
       "size": [Function],
       "slice": [Function],
       "sliceBytes": [Function],
@@ -203,6 +204,7 @@ test('exports actions', () => {
         "ether": -18,
         "gwei": -9,
       },
+      "writeContract": [Function],
     }
   `)
 })

package/src/index.ts

@@ -1,7 +1,5 @@
 export type {
   CallArgs,
-  CallContractArgs,
-  CallContractResponse,
   CallResponse,
   CreateBlockFilterResponse,
   CreatePendingTransactionFilterResponse,
@@ -27,6 +25,8 @@ export type {
   GetFilterLogsArgs,
   GetFilterLogsResponse,
   GetGasPriceResponse,
+  GetLogsArgs,
+  GetLogsResponse,
   GetPermissionsResponse,
   GetTransactionArgs,
   GetTransactionConfirmationsArgs,
@@ -65,6 +65,8 @@ export type {
   SetStorageAtArgs,
   SignMessageArgs,
   SignMessageResponse,
+  SimulateContractArgs,
+  SimulateContractResponse,
   StopImpersonatingAccountArgs,
   SwitchChainArgs,
   UninstallFilterArgs,
@@ -76,11 +78,12 @@ export type {
   WatchBlockNumberArgs,
   WatchBlocksArgs,
   WatchPendingTransactionsArgs,
+  WriteContractArgs,
+  WriteContractResponse,
 } from './actions'
 export {
   addChain,
   call,
-  callContract,
   createBlockFilter,
   createPendingTransactionFilter,
   deployContract,
@@ -98,6 +101,7 @@ export {
   getFilterChanges,
   getFilterLogs,
   getGasPrice,
+  getLogs,
   getPermissions,
   getTransaction,
   getTransactionConfirmations,
@@ -130,6 +134,7 @@ export {
   setNonce,
   setStorageAt,
   signMessage,
+  simulateContract,
   snapshot,
   stopImpersonatingAccount,
   switchChain,
@@ -139,6 +144,7 @@ export {
   watchBlockNumber,
   watchBlocks,
   watchPendingTransactions,
+  writeContract,
 } from './actions'
 
 export type {

package/src/public.ts

@@ -1,6 +1,5 @@
 export {
   call,
-  callContract,
   createBlockFilter,
   createPendingTransactionFilter,
   deployContract,
@@ -20,6 +19,7 @@ export {
   getTransactionConfirmations,
   getTransactionCount,
   getTransactionReceipt,
+  simulateContract,
   uninstallFilter,
   waitForTransactionReceipt,
   watchBlockNumber,
@@ -28,8 +28,6 @@ export {
 } from './actions/public'
 export type {
   CallArgs,
-  CallContractArgs,
-  CallContractResponse,
   CallResponse,
   CreateBlockFilterResponse,
   CreatePendingTransactionFilterResponse,
@@ -70,6 +68,8 @@ export type {
   OnTransactionsResponse,
   ReplacementReason,
   ReplacementResponse,
+  SimulateContractArgs,
+  SimulateContractResponse,
   UninstallFilterArgs,
   UninstallFilterResponse,
   WaitForTransactionReceiptArgs,

package/src/types/eip1193.ts

@@ -1,5 +1,5 @@
 import type { BlockTag } from './block'
-import type { Address, Hash, Hex } from './misc'
+import type { Address, Hash, Hex, LogTopic } from './misc'
 import type {
   RpcBlock as Block,
   RpcBlockIdentifier as BlockIdentifier,
@@ -381,25 +381,28 @@ export type PublicRequests = {
      * @description Returns a list of all logs based on a filter object
      * @link https://eips.ethereum.org/EIPS/eip-1474
      * @example
-     * provider.request({ method: 'eth_getLogs', params: [{ ... }] })
+     * provider.request({ method: 'eth_getLogs', params: [{ fromBlock: '0x...', toBlock: '0x...', address: '0x...', topics: ['0x...'] }] })
      * // => [{ ... }, { ... }]
      * */
     method: 'eth_getLogs'
     params: [
-      filter: {
+      parameters: {
         address?: Address | Address[]
-        topics?: Hex[]
+        topics?: LogTopic[]
       } & (
         | {
             fromBlock?: BlockNumber | BlockTag
             toBlock?: BlockNumber | BlockTag
+            blockHash?: never
           }
         | {
+            fromBlock?: never
+            toBlock?: never
             blockHash?: Hash
           }
       ),
     ]
-  }): Promise<Log>
+  }): Promise<Log[]>
   request(args: {
     /**
      * @description Returns the value from a storage position at an address
@@ -539,7 +542,7 @@ export type PublicRequests = {
         fromBlock?: BlockNumber | BlockTag
         toBlock?: BlockNumber | BlockTag
         address?: Address | Address[]
-        topics?: (Hex | Hex[] | null)[]
+        topics?: LogTopic[]
       },
     ]
   }): Promise<Quantity>

package/src/types/index.ts

@@ -32,7 +32,7 @@ export type { Filter, FilterType } from './filter'
 
 export type { Log } from './log'
 
-export type { Address, ByteArray, Hex, Hash } from './misc'
+export type { Address, ByteArray, Hex, Hash, LogTopic } from './misc'
 
 export type {
   Index,

package/src/types/misc.ts

@@ -2,3 +2,4 @@ export type Address = `0x${string}`
 export type ByteArray = Uint8Array
 export type Hex = `0x${string}`
 export type Hash = `0x${string}`
+export type LogTopic = Hex | Hex[] | null

package/dist/chunk-4XREGFHD.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/actions/wallet/addChain.ts","../src/actions/wallet/getAccounts.ts","../src/actions/wallet/getPermissions.ts","../src/actions/wallet/requestAccounts.ts","../src/actions/wallet/requestPermissions.ts","../src/actions/wallet/sendTransaction.ts","../src/actions/wallet/signMessage.ts","../src/actions/wallet/switchChain.ts","../src/actions/wallet/watchAsset.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Chain } from '../../chains'\nimport type { WalletClient } from '../../clients'\nimport { numberToHex } from '../../utils'\n\nexport async function addChain(client: WalletClient, chain: Chain) {\n  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain\n  await client.request({\n    method: 'wallet_addEthereumChain',\n    params: [\n      {\n        chainId: numberToHex(id),\n        chainName: name,\n        nativeCurrency,\n        rpcUrls: rpcUrls.default.http,\n        blockExplorerUrls: blockExplorers\n          ? Object.values(blockExplorers).map(({ url }) => url)\n          : undefined,\n      },\n    ],\n  })\n}\n","import type { WalletClient } from '../../clients'\nimport { checksumAddress } from '../../utils/address'\n\nexport async function getAccounts(client: WalletClient) {\n  const addresses = await client.request({ method: 'eth_accounts' })\n  return addresses.map((address) => checksumAddress(address))\n}\n","import type { WalletClient } from '../../clients'\nimport type { WalletPermission } from '../../types/eip1193'\n\nexport type GetPermissionsResponse = WalletPermission[]\n\nexport async function getPermissions(client: WalletClient) {\n  const permissions = await client.request({ method: 'wallet_getPermissions' })\n  return permissions\n}\n","import type { WalletClient } from '../../clients'\nimport { getAddress } from '../../utils'\n\nexport async function requestAccounts(client: WalletClient) {\n  const addresses = await client.request({ method: 'eth_requestAccounts' })\n  return addresses.map((address) => getAddress(address))\n}\n","import type { WalletClient } from '../../clients'\nimport type { WalletPermission } from '../../types/eip1193'\n\nexport type RequestPermissionsArgs = {\n  eth_accounts: Record<string, any>\n} & {\n  [key: string]: Record<string, any>\n}\nexport type RequestPermissionsResponse = WalletPermission[]\n\nexport async function requestPermissions(\n  client: WalletClient,\n  permissions: RequestPermissionsArgs,\n) {\n  return client.request({\n    method: 'wallet_requestPermissions',\n    params: [permissions],\n  })\n}\n","import type { Chain, Formatter } from '../../chains'\nimport type { WalletClient } from '../../clients'\nimport { InvalidGasArgumentsError } from '../../errors'\nimport type {\n  Hash,\n  MergeIntersectionProperties,\n  TransactionRequest,\n} from '../../types'\nimport type { Formatted, TransactionRequestFormatter } from '../../utils'\nimport { extract, format, formatTransactionRequest } from '../../utils'\n\nexport type FormattedTransactionRequest<\n  TFormatter extends Formatter | undefined = Formatter,\n> = MergeIntersectionProperties<\n  Formatted<TFormatter, TransactionRequest, true>,\n  TransactionRequest\n>\n\nexport type SendTransactionArgs<TChain extends Chain = Chain> =\n  FormattedTransactionRequest<TransactionRequestFormatter<TChain>> & {\n    chain?: TChain\n  }\n\nexport type SendTransactionResponse = Hash\n\nexport async function sendTransaction<TChain extends Chain>(\n  client: WalletClient,\n  {\n    chain,\n    from,\n    accessList,\n    data,\n    gas,\n    gasPrice,\n    maxFeePerGas,\n    maxPriorityFeePerGas,\n    nonce,\n    to,\n    value,\n    ...rest\n  }: SendTransactionArgs<TChain>,\n): Promise<SendTransactionResponse> {\n  if (\n    maxFeePerGas !== undefined &&\n    maxPriorityFeePerGas !== undefined &&\n    maxFeePerGas < maxPriorityFeePerGas\n  )\n    throw new InvalidGasArgumentsError()\n\n  const formatter = chain?.formatters?.transactionRequest\n  const request_ = format(\n    {\n      from,\n      accessList,\n      data,\n      gas,\n      gasPrice,\n      maxFeePerGas,\n      maxPriorityFeePerGas,\n      nonce,\n      to,\n      value,\n      // Pick out extra data that might exist on the chain's transaction request type.\n      ...extract(rest, { formatter }),\n    } as TransactionRequest,\n    {\n      formatter: formatter || formatTransactionRequest,\n    },\n  )\n\n  const hash = await client.request({\n    method: 'eth_sendTransaction',\n    params: [request_],\n  })\n  return hash\n}\n","import type { WalletClient } from '../../clients'\nimport { BaseError } from '../../errors'\nimport type { Address, ByteArray, Hex } from '../../types'\nimport { encodeHex } from '../../utils'\n\nexport type SignMessageArgs = {\n  from: Address\n  data: Hex | ByteArray\n}\n\nexport type SignMessageResponse = Hex\n\nexport async function signMessage(\n  client: WalletClient,\n  { from, data: data_ }: SignMessageArgs,\n): Promise<SignMessageResponse> {\n  let data\n  if (typeof data_ === 'string') {\n    if (!data_.startsWith('0x'))\n      throw new BaseError(\n        `data (\"${data_}\") must be a hex value. Encode it first to a hex with the \\`encodeHex\\` util.`,\n        {\n          docsPath: '/TODO',\n        },\n      )\n    data = data_\n  } else {\n    data = encodeHex(data_)\n  }\n  const signed = await client.request({\n    method: 'personal_sign',\n    params: [data, from],\n  })\n  return signed\n}\n","import type { Chain } from '../../chains'\nimport type { WalletClient } from '../../clients'\nimport { numberToHex } from '../../utils'\n\nexport type SwitchChainArgs = { id: Chain['id'] }\n\nexport async function switchChain(\n  client: WalletClient,\n  { id }: SwitchChainArgs,\n) {\n  await client.request({\n    method: 'wallet_switchEthereumChain',\n    params: [\n      {\n        chainId: numberToHex(id),\n      },\n    ],\n  })\n}\n","import type { WalletClient } from '../../clients'\nimport type { WatchAssetParams } from '../../types/eip1193'\n\nexport type WatchAssetArgs = WatchAssetParams\nexport type WatchAssetResponse = boolean\n\nexport async function watchAsset(\n  client: WalletClient,\n  params: WatchAssetParams,\n): Promise<WatchAssetResponse> {\n  const added = await client.request({\n    method: 'wallet_watchAsset',\n    params: [params],\n  })\n  return added\n}\n"]}