viem 0.0.1-cjs.10 → 0.0.1-sushi.26

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

@@ -0,0 +1,410 @@
+/**
+ * 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,
+  deployBAYC,
+  publicClient,
+  testClient,
+  wagmiContractConfig,
+  walletClient,
+} from '../../_test'
+import { baycContractConfig } from '../../_test/abis'
+import { encodeFunctionData } from '../../utils'
+import { mine } from '../test'
+import { sendTransaction } from '../wallet'
+
+import { simulateContract } from './simulateContract'
+import { deployErrorExample } from '../../_test/utils'
+import { errorsExampleABI } from '../../_test/generated'
+
+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('overloaded function', async () => {
+    expect(
+      (
+        await simulateContract(publicClient, {
+          ...wagmiContractConfig,
+          from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          functionName: 'mint',
+        })
+      ).result,
+    ).toEqual(undefined)
+  })
+
+  test('revert', async () => {
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'approve',
+        args: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC', 420n],
+        from: accounts[0].address,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "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
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2"
+    `)
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'mint',
+        args: [1n],
+        from: accounts[0].address,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "The contract function \\"mint\\" reverted with the following reason:
+      Token ID is taken
+
+      Contract:  0x0000000000000000000000000000000000000000
+      Function:  mint(uint256 tokenId)
+      Arguments:     (1)
+      Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      Version: viem@1.0.2"
+    `)
+    await expect(() =>
+      simulateContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'safeTransferFrom',
+        from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+        args: [
+          '0x1a1E021A302C237453D3D45c7B82B19cEEB7E2e6',
+          '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          1n,
+        ],
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`
+      "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
+
+      Docs: https://viem.sh/docs/contract/simulateContract
+      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(`
+        "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
+
+        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, {
+      abi: [
+        {
+          name: 'mint',
+          type: 'function',
+          stateMutability: 'nonpayable',
+          inputs: [],
+          outputs: [{ type: 'uint256' }],
+        },
+      ],
+      address: '0x0000000000000000000000000000000000000069',
+      functionName: 'mint',
+      from: accounts[0].address,
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "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()
+    Sender:    0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
+
+    Docs: https://viem.sh/docs/contract/simulateContract
+    Version: viem@1.0.2"
+  `)
+})

package/src/actions/public/simulateContract.ts

@@ -0,0 +1,91 @@
+import { Abi, Narrow } from 'abitype'
+
+import type { PublicClient } from '../../clients'
+import { BaseError } from '../../errors'
+import type {
+  Chain,
+  ContractConfig,
+  ExtractResultFromAbi,
+  GetValue,
+} from '../../types'
+import {
+  DecodeFunctionResultArgs,
+  EncodeFunctionDataArgs,
+  decodeFunctionResult,
+  encodeFunctionData,
+  getContractError,
+} from '../../utils'
+import { WriteContractArgs } from '../wallet'
+import { call, CallArgs } from './call'
+
+export type SimulateContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = 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,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+> = {
+  result: ExtractResultFromAbi<TAbi, TFunctionName>
+  request: WriteContractArgs<TChain, TAbi, TFunctionName> &
+    ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
+}
+
+export async function simulateContract<
+  TChain extends Chain,
+  TAbi extends Abi | readonly unknown[],
+  TFunctionName extends string,
+>(
+  client: PublicClient,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...callRequest
+  }: SimulateContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<SimulateContractResponse<TChain, TAbi, TFunctionName>> {
+  const calldata = encodeFunctionData({
+    abi,
+    args,
+    functionName,
+  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest,
+    } as unknown as CallArgs<TChain>)
+    const result = decodeFunctionResult({
+      abi,
+      args,
+      functionName,
+      data: data || '0x',
+    } as DecodeFunctionResultArgs)
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest,
+      },
+    } as unknown as SimulateContractResponse<TChain, TAbi, TFunctionName>
+  } catch (err) {
+    throw getContractError(err as BaseError, {
+      abi: abi as Abi,
+      address,
+      args,
+      docsPath: '/docs/contract/simulateContract',
+      functionName,
+      sender: callRequest.from,
+    })
+  }
+}

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

@@ -0,0 +1,13 @@
+import { bench, describe } from 'vitest'
+
+import { publicClient } from '../../_test'
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { uninstallFilter } from './uninstallFilter'
+
+const filter = await createPendingTransactionFilter(publicClient)
+
+describe('Get Filter Changes', () => {
+  bench('viem: `uninstallFilter`', async () => {
+    await uninstallFilter(publicClient, { filter })
+  })
+})

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

@@ -0,0 +1,65 @@
+import { assertType, expect, test } from 'vitest'
+
+import { accounts, publicClient, testClient, walletClient } from '../../_test'
+
+import { createPendingTransactionFilter } from './createPendingTransactionFilter'
+import { getFilterChanges } from './getFilterChanges'
+import { uninstallFilter } from './uninstallFilter'
+import { mine } from '../test'
+import { sendTransaction } from '../wallet'
+import { parseEther } from '../../utils'
+import type { Hash } from '../../types'
+
+test('default', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+})
+
+test('pending txns', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+
+  let hashes = await getFilterChanges(publicClient, { filter })
+  assertType<Hash[]>(hashes)
+  expect(hashes.length).toBe(2)
+
+  mine(testClient, { blocks: 1 })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(0)
+
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+
+  await sendTransaction(walletClient, {
+    from: accounts[0].address,
+    to: accounts[1].address,
+    value: parseEther('1'),
+  })
+
+  hashes = await getFilterChanges(publicClient, { filter })
+  expect(hashes.length).toBe(0)
+})
+
+test('filter does not exist', async () => {
+  expect(
+    await uninstallFilter(publicClient, {
+      filter: { id: '0x1', type: 'default' },
+    }),
+  ).toBeFalsy()
+})
+
+test('filter already uninstalled', async () => {
+  const filter = await createPendingTransactionFilter(publicClient)
+  expect(await uninstallFilter(publicClient, { filter })).toBeTruthy()
+  expect(await uninstallFilter(publicClient, { filter })).toBeFalsy()
+})

package/src/actions/public/uninstallFilter.ts

@@ -0,0 +1,17 @@
+import type { PublicClient } from '../../clients'
+import type { Filter } from '../../types'
+
+export type UninstallFilterArgs = {
+  filter: Filter<any>
+}
+export type UninstallFilterResponse = boolean
+
+export async function uninstallFilter(
+  client: PublicClient,
+  { filter }: UninstallFilterArgs,
+): Promise<UninstallFilterResponse> {
+  return client.request({
+    method: 'eth_uninstallFilter',
+    params: [filter.id],
+  })
+}