viem 0.0.1-alpha.21 → 0.0.1-alpha.23

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

@@ -7,19 +7,15 @@
 
 import { describe, expect, test } from 'vitest'
 import {
-  accounts,
+  address,
+  initialBlockNumber,
   publicClient,
-  testClient,
   wagmiContractConfig,
-  walletClient,
 } from '../../_test'
 import { baycContractConfig } from '../../_test/abis'
-import { encodeFunctionData } from '../../utils'
-import { mine } from '../test'
-import { sendTransaction } from '../wallet'
+import { errorsExampleABI } from '../../_test/generated'
+import { deployErrorExample } from '../../_test/utils'
 
-import { deployContract } from './deployContract'
-import { getTransactionReceipt } from './getTransactionReceipt'
 import { readContract } from './readContract'
 
 describe('wagmi', () => {
@@ -86,10 +82,226 @@ describe('wagmi', () => {
     expect(
       await readContract(publicClient, {
         ...wagmiContractConfig,
+        blockNumber: initialBlockNumber,
         functionName: 'totalSupply',
       }),
     ).toEqual(558n)
   })
+
+  test('overloaded function', async () => {
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        abi: [
+          {
+            inputs: [{ type: 'uint256', name: 'x' }],
+            name: 'balanceOf',
+            outputs: [{ type: 'address', name: 'x' }],
+            stateMutability: 'pure',
+            type: 'function',
+          },
+          ...wagmiContractConfig.abi,
+        ],
+        functionName: 'balanceOf',
+        args: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'],
+      }),
+    ).toEqual(3n)
+  })
+})
+
+describe('bayc', () => {
+  test('revert', async () => {
+    await expect(() =>
+      readContract(publicClient, {
+        ...baycContractConfig,
+        functionName: 'tokenOfOwnerByIndex',
+        args: [address.vitalik, 5n],
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "The contract function \\"tokenOfOwnerByIndex\\" reverted with the following reason:
+      EnumerableSet: index out of bounds
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  tokenOfOwnerByIndex(address owner, uint256 index)
+      Arguments:                    (0xd8da6bf26964af9d7eed9e03e53415d37aa96045, 5)
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2"
+    `)
+  })
+
+  test('revert', async () => {
+    await expect(() =>
+      readContract(publicClient, {
+        ...baycContractConfig,
+        functionName: 'ownerOf',
+        args: [420213123123n],
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "The contract function \\"ownerOf\\" reverted with the following reason:
+      ERC721: owner query for nonexistent token
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  ownerOf(uint256 tokenId)
+      Arguments:        (420213123123)
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2"
+    `)
+  })
+})
+
+describe('contract errors', () => {
+  test('revert', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'revertRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "revertRead" reverted with the following reason:
+      This is a revert message
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  revertRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('assert', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'assertRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "assertRead" reverted with the following reason:
+      An \`assert\` condition failed.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  assertRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('overflow', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'overflowRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "overflowRead" reverted with the following reason:
+      Arithmic operation resulted in underflow or overflow.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  overflowRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('divide by zero', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'divideByZeroRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "divideByZeroRead" reverted with the following reason:
+      Division or modulo by zero (e.g. \`5 / 0\` or \`23 % 0\`).
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  divideByZeroRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('require', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'requireRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "requireRead" reverted with the following reason:
+      execution reverted
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  requireRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('custom error: simple', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'simpleCustomRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "simpleCustomRead" reverted.
+
+      Error:     SimpleError(string message)
+      Arguments:            (bugger)
+       
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  simpleCustomRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('custom error: complex', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      readContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'complexCustomRead',
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "complexCustomRead" reverted.
+
+      Error:     ComplexError((address sender, uint256 bar), string message, uint256 number)
+      Arguments:             ({"sender":"0x0000000000000000000000000000000000000000","bar":"69"}, bugger, 69)
+       
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  complexCustomRead()
+
+      Docs: https://viem.sh/docs/contract/readContract
+      Version: viem@1.0.2]
+    `)
+  })
 })
 
 test('fake contract address', async () => {
@@ -100,29 +312,17 @@ test('fake contract address', async () => {
       functionName: 'totalSupply',
     }),
   ).rejects.toThrowErrorMatchingInlineSnapshot(`
-    "The contract method \\"totalSupply\\" returned no data (\\"0x\\"). This could be due to any of the following:
+    "The contract function \\"totalSupply\\" returned no data (\\"0x\\").
+
+    This could be due to any of the following:
     - The contract does not have the function \\"totalSupply\\",
     - The parameters passed to the contract function may be invalid, or
     - The address is not a contract.
      
-    Contract: 0x0000000000000000000000000000000000000000
-    Function: totalSupply()
-            > \\"0x\\"
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  totalSupply()
 
+    Docs: https://viem.sh/docs/contract/readContract
     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/readContract.ts

@@ -1,11 +1,10 @@
 import { Abi } from 'abitype'
 
 import type { PublicClient } from '../../clients'
+import { BaseError } from '../../errors'
 import type {
-  Address,
-  ExtractArgsFromAbi,
+  ContractConfig,
   ExtractResultFromAbi,
-  ExtractFunctionNameFromAbi,
   Formatter,
 } from '../../types'
 import {
@@ -13,6 +12,7 @@ import {
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
+  DecodeFunctionResultArgs,
 } from '../../utils'
 import { call, CallArgs, FormattedCall } from './call'
 
@@ -22,25 +22,9 @@ export type FormattedReadContract<
 
 export type ReadContractArgs<
   TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = any,
-> = Omit<
-  CallArgs,
-  | 'accessList'
-  | 'chain'
-  | 'from'
-  | 'gas'
-  | 'gasPrice'
-  | 'maxFeePerGas'
-  | 'maxPriorityFeePerGas'
-  | 'nonce'
-  | 'to'
-  | 'data'
-  | 'value'
-> & {
-  address: Address
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName, 'pure' | 'view'>
-} & ExtractArgsFromAbi<TAbi, TFunctionName>
+  TFunctionName extends string = string,
+> = Pick<CallArgs, 'blockNumber' | 'blockTag'> &
+  ContractConfig<TAbi, TFunctionName, 'view' | 'pure'>
 
 export type ReadContractResponse<
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -48,8 +32,8 @@ export type ReadContractResponse<
 > = ExtractResultFromAbi<TAbi, TFunctionName>
 
 export async function readContract<
-  TAbi extends Abi = Abi,
-  TFunctionName extends string = any,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
 >(
   client: PublicClient,
   {
@@ -73,14 +57,16 @@ export async function readContract<
     } as unknown as CallArgs)
     return decodeFunctionResult({
       abi,
+      args,
       functionName,
       data: data || '0x',
-    })
+    } as DecodeFunctionResultArgs<TAbi, TFunctionName>)
   } catch (err) {
-    throw getContractError(err, {
-      abi,
+    throw getContractError(err as BaseError, {
+      abi: abi as Abi,
       address,
       args,
+      docsPath: '/docs/contract/readContract',
       functionName,
     })
   }

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

@@ -1,4 +1,5 @@
 import { Contract } from 'ethers'
+import { Contract as ContractV6 } from 'ethers@6'
 import { bench, describe } from 'vitest'
 
 import {
@@ -28,4 +29,13 @@ describe('Simulate Contract', () => {
     )
     await wagmi.callStatic.mint(1)
   })
+
+  bench('ethers@6: `callStatic`', async () => {
+    const wagmi = new ContractV6(
+      wagmiContractConfig.address,
+      wagmiContractConfig.abi,
+      ethersProvider,
+    )
+    await wagmi.mint.staticCall(1)
+  })
 })