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

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

@@ -11,6 +11,7 @@
 import { describe, expect, test } from 'vitest'
 import {
   accounts,
+  deployBAYC,
   publicClient,
   testClient,
   wagmiContractConfig,
@@ -21,9 +22,9 @@ import { encodeFunctionData } from '../../utils'
 import { mine } from '../test'
 import { sendTransaction } from '../wallet'
 
-import { deployContract } from './deployContract'
-import { getTransactionReceipt } from './getTransactionReceipt'
 import { simulateContract } from './simulateContract'
+import { deployErrorExample } from '../../_test/utils'
+import { errorsExampleABI } from '../../_test/generated'
 
 describe('wagmi', () => {
   test('default', async () => {
@@ -53,6 +54,18 @@ describe('wagmi', () => {
     ).toEqual(undefined)
   })
 
+  test('overloaded function', async () => {
+    expect(
+      (
+        await simulateContract(publicClient, {
+          ...wagmiContractConfig,
+          from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          functionName: 'mint',
+        })
+      ).result,
+    ).toEqual(undefined)
+  })
+
   test('revert', async () => {
     await expect(() =>
       simulateContract(publicClient, {
@@ -62,14 +75,15 @@ describe('wagmi', () => {
         from: accounts[0].address,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "ERC721: approval to current owner
-       
-      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+      "The contract function \\"approve\\" reverted with the following reason:
+      ERC721: approval to current owner
+
       Contract:  0x0000000000000000000000000000000000000000
       Function:  approve(address to, uint256 tokenId)
       Arguments:        (0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC, 420)
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
 
-      Details: execution reverted: ERC721: approval to current owner
+      Docs: https://viem.sh/docs/contract/simulateContract
       Version: viem@1.0.2"
     `)
     await expect(() =>
@@ -80,14 +94,15 @@ describe('wagmi', () => {
         from: accounts[0].address,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "Token ID is taken
-       
-      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+      "The contract function \\"mint\\" reverted with the following reason:
+      Token ID is taken
+
       Contract:  0x0000000000000000000000000000000000000000
       Function:  mint(uint256 tokenId)
       Arguments:     (1)
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
 
-      Details: execution reverted: Token ID is taken
+      Docs: https://viem.sh/docs/contract/simulateContract
       Version: viem@1.0.2"
     `)
     await expect(() =>
@@ -102,14 +117,15 @@ describe('wagmi', () => {
         ],
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(`
-      "ERC721: transfer caller is not owner nor approved
-       
-      Sender:    0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC
+      "The contract function \\"safeTransferFrom\\" reverted with the following reason:
+      ERC721: transfer caller is not owner nor approved
+
       Contract:  0x0000000000000000000000000000000000000000
       Function:  safeTransferFrom(address from, address to, uint256 tokenId)
       Arguments:                 (0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6, 0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC, 1)
+      Sender:    0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC
 
-      Details: execution reverted: ERC721: transfer caller is not owner nor approved
+      Docs: https://viem.sh/docs/contract/simulateContract
       Version: viem@1.0.2"
     `)
   })
@@ -178,20 +194,188 @@ describe('BAYC', () => {
           args: [1n],
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(`
-        "Sale must be active to mint Ape
-         
-        Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+        "The contract function \\"mintApe\\" reverted with the following reason:
+        Sale must be active to mint Ape
+
         Contract:  0x0000000000000000000000000000000000000000
         Function:  mintApe(uint256 numberOfTokens)
         Arguments:        (1)
+        Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
 
-        Details: execution reverted: Sale must be active to mint Ape
+        Docs: https://viem.sh/docs/contract/simulateContract
         Version: viem@1.0.2"
       `)
     })
   })
 })
 
+describe('contract errors', () => {
+  test('revert', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'revertWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "revertWrite" reverted with the following reason:
+      This is a revert message
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  revertWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('assert', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'assertWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "assertWrite" reverted with the following reason:
+      An \`assert\` condition failed.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  assertWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('overflow', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'overflowWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "overflowWrite" reverted with the following reason:
+      Arithmic operation resulted in underflow or overflow.
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  overflowWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('divide by zero', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'divideByZeroWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "divideByZeroWrite" reverted with the following reason:
+      Division or modulo by zero (e.g. \`5 / 0\` or \`23 % 0\`).
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  divideByZeroWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('require', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'requireWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "requireWrite" reverted with the following reason:
+      execution reverted
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  requireWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('custom error: simple', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'simpleCustomWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "simpleCustomWrite" reverted.
+
+      Error:     SimpleError(string message)
+      Arguments:            (bugger)
+       
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  simpleCustomWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+
+  test('custom error: complex', async () => {
+    const { contractAddress } = await deployErrorExample()
+
+    await expect(() =>
+      simulateContract(publicClient, {
+        abi: errorsExampleABI,
+        address: contractAddress!,
+        functionName: 'complexCustomWrite',
+        from: accounts[0].address,
+      }),
+    ).rejects.toMatchInlineSnapshot(`
+      [ContractFunctionExecutionError: The contract function "complexCustomWrite" reverted.
+
+      Error:     ComplexError((address sender, uint256 bar), string message, uint256 number)
+      Arguments:             ({"sender":"0x0000000000000000000000000000000000000000","bar":"69"}, bugger, 69)
+       
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  complexCustomWrite()
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2]
+    `)
+  })
+})
+
 test('fake contract address', async () => {
   await expect(() =>
     simulateContract(publicClient, {
@@ -207,32 +391,20 @@ test('fake contract address', async () => {
       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 function \\"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\\"
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  mint()
+    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
 
+    Docs: https://viem.sh/docs/contract/simulateContract
     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/simulateContract.ts

@@ -1,9 +1,11 @@
-import { Abi } from 'abitype'
+import { Abi, Narrow } from 'abitype'
 
 import type { PublicClient } from '../../clients'
+import { BaseError } from '../../errors'
 import type {
   Address,
   Chain,
+  ContractConfig,
   ExtractArgsFromAbi,
   ExtractResultFromAbi,
   ExtractFunctionNameFromAbi,
@@ -14,6 +16,7 @@ import {
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
+  DecodeFunctionResultArgs,
 } from '../../utils'
 import { WriteContractArgs } from '../wallet'
 import { call, CallArgs } from './call'
@@ -22,16 +25,10 @@ export type SimulateContractArgs<
   TChain extends Chain = Chain,
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = any,
-> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> & {
-  address: Address
-  abi: TAbi
-  functionName: ExtractFunctionNameFromAbi<
-    TAbi,
-    TFunctionName,
-    'payable' | 'nonpayable'
-  >
-  value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
-} & ExtractArgsFromAbi<TAbi, TFunctionName>
+> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> &
+  ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> & {
+    value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
+  }
 
 export type SimulateContractResponse<
   TChain extends Chain = Chain,
@@ -39,17 +36,14 @@ export type SimulateContractResponse<
   TFunctionName extends string = string,
 > = {
   result: ExtractResultFromAbi<TAbi, TFunctionName>
-  request: WriteContractArgs<TChain, TAbi, TFunctionName> & {
-    address: Address
-    abi: TAbi
-    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  } & ExtractArgsFromAbi<TAbi, TFunctionName>
+  request: WriteContractArgs<TChain, TAbi, TFunctionName> &
+    ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
 }
 
 export async function simulateContract<
   TChain extends Chain,
-  TAbi extends Abi = Abi,
-  TFunctionName extends string = any,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
 >(
   client: PublicClient,
   {
@@ -73,9 +67,10 @@ export async function simulateContract<
     } as unknown as CallArgs<TChain>)
     const result = decodeFunctionResult({
       abi,
+      args,
       functionName,
       data: data || '0x',
-    })
+    } as DecodeFunctionResultArgs)
     return {
       result,
       request: {
@@ -87,10 +82,11 @@ export async function simulateContract<
       },
     } as unknown as SimulateContractResponse<TChain, TAbi, TFunctionName>
   } catch (err) {
-    throw getContractError(err, {
-      abi,
+    throw getContractError(err as BaseError, {
+      abi: abi as Abi,
       address,
       args,
+      docsPath: '/docs/contract/simulateContract',
       functionName,
       sender: callRequest.from,
     })

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

@@ -2,10 +2,10 @@ import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest'
 import { wait } from '../../utils/wait'
 import {
   accounts,
+  address,
   publicClient,
   testClient,
   usdcContractConfig,
-  vitalikAddress,
   walletClient,
 } from '../../_test'
 import { impersonateAccount, stopImpersonatingAccount } from '../test'
@@ -16,7 +16,7 @@ import { OnLogsResponse, watchContractEvent } from './watchContractEvent'
 
 beforeAll(async () => {
   await impersonateAccount(testClient, {
-    address: vitalikAddress,
+    address: address.vitalik,
   })
   await impersonateAccount(testClient, {
     address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
@@ -25,48 +25,52 @@ beforeAll(async () => {
 
 afterAll(async () => {
   await stopImpersonatingAccount(testClient, {
-    address: vitalikAddress,
+    address: address.vitalik,
   })
   await stopImpersonatingAccount(testClient, {
     address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
   })
 })
 
-test('default', async () => {
-  let logs: OnLogsResponse[] = []
+test(
+  'default',
+  async () => {
+    let logs: OnLogsResponse[] = []
 
-  const unwatch = watchContractEvent(publicClient, {
-    ...usdcContractConfig,
-    onLogs: (logs_) => logs.push(logs_),
-  })
+    const unwatch = watchContractEvent(publicClient, {
+      ...usdcContractConfig,
+      onLogs: (logs_) => logs.push(logs_),
+    })
 
-  await writeContract(walletClient, {
-    ...usdcContractConfig,
-    from: vitalikAddress,
-    functionName: 'transfer',
-    args: [vitalikAddress, 1n],
-  })
-  await writeContract(walletClient, {
-    ...usdcContractConfig,
-    from: vitalikAddress,
-    functionName: 'transfer',
-    args: [vitalikAddress, 1n],
-  })
-  await wait(1000)
-  await writeContract(walletClient, {
-    ...usdcContractConfig,
-    from: vitalikAddress,
-    functionName: 'approve',
-    args: [vitalikAddress, 1n],
-  })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [address.vitalik, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [address.vitalik, 1n],
+    })
+    await wait(1000)
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
 
-  await wait(2000)
-  unwatch()
+    await wait(2000)
+    unwatch()
 
-  expect(logs.length).toBe(2)
-  expect(logs[0].length).toBe(2)
-  expect(logs[1].length).toBe(1)
-})
+    expect(logs.length).toBe(2)
+    expect(logs[0].length).toBe(2)
+    expect(logs[1].length).toBe(1)
+  },
+  { retry: 3 },
+)
 
 test('args: batch', async () => {
   let logs: OnLogsResponse[] = []
@@ -79,22 +83,22 @@ test('args: batch', async () => {
 
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
   await wait(1000)
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'approve',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
 
   await wait(2000)
@@ -117,22 +121,22 @@ test('args: eventName', async () => {
 
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
   await wait(1000)
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'approve',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
 
   await wait(2000)
@@ -156,22 +160,22 @@ test('args: args', async () => {
 
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
     args: [accounts[0].address, 1n],
   })
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
     args: [accounts[1].address, 1n],
   })
   await wait(1000)
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'approve',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
 
   await wait(2000)
@@ -195,22 +199,22 @@ test('args: args', async () => {
 
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
     args: [accounts[0].address, 1n],
   })
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
     args: [accounts[1].address, 1n],
   })
   await wait(1000)
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'approve',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
 
   await wait(2000)
@@ -240,16 +244,16 @@ test('args: args', async () => {
   })
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'transfer',
     args: [accounts[1].address, 1n],
   })
   await wait(1000)
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: vitalikAddress,
+    from: address.vitalik,
     functionName: 'approve',
-    args: [vitalikAddress, 1n],
+    args: [address.vitalik, 1n],
   })
 
   await wait(2000)