viem 0.0.1-alpha.16 → 0.0.1-alpha.18

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

@@ -0,0 +1,128 @@
+/**
+ * TODO:  Heaps more test cases :D
+ *        - Complex calldata types
+ *        - Complex return types (tuple/structs)
+ *        - Calls against blocks
+ */
+
+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 { readContract } from './readContract'
+
+describe('wagmi', () => {
+  test('default', async () => {
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'balanceOf',
+        args: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'],
+      }),
+    ).toEqual(3n)
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'getApproved',
+        args: [420n],
+      }),
+    ).toEqual('0x0000000000000000000000000000000000000000')
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'isApprovedForAll',
+        args: [
+          '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+          '0x0000000000000000000000000000000000000000',
+        ],
+      }),
+    ).toEqual(false)
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'name',
+      }),
+    ).toEqual('wagmi')
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'ownerOf',
+        args: [420n],
+      }),
+    ).toEqual('0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC')
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'supportsInterface',
+        args: ['0x1a452251'],
+      }),
+    ).toEqual(false)
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'symbol',
+      }),
+    ).toEqual('WAGMI')
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'tokenURI',
+        args: [420n],
+      }),
+    ).toMatchInlineSnapshot(
+      '"data:application/json;base64,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"',
+    )
+    expect(
+      await readContract(publicClient, {
+        ...wagmiContractConfig,
+        functionName: 'totalSupply',
+      }),
+    ).toEqual(558n)
+  })
+})
+
+test('fake contract address', async () => {
+  await expect(() =>
+    readContract(publicClient, {
+      abi: wagmiContractConfig.abi,
+      address: '0x0000000000000000000000000000000000000069',
+      functionName: 'totalSupply',
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "The contract method \\"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\\"
+
+    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 → readContract.ts}

@@ -7,7 +7,6 @@ import type {
   ExtractArgsFromAbi,
   ExtractResultFromAbi,
   ExtractFunctionNameFromAbi,
-  GetValue,
 } from '../../types'
 import {
   EncodeFunctionDataArgs,
@@ -17,29 +16,38 @@ import {
 } from '../../utils'
 import { call, CallArgs, FormattedCall } from './call'
 
-export type FormattedCallContract<
+export type FormattedReadContract<
   TFormatter extends Formatter | undefined = Formatter,
 > = FormattedCall<TFormatter>
 
-export type CallContractArgs<
-  TChain extends Chain = Chain,
+export type ReadContractArgs<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = any,
-> = Omit<CallArgs<TChain>, 'from' | 'to' | 'data' | 'value'> & {
+> = Omit<
+  CallArgs,
+  | 'accessList'
+  | 'chain'
+  | 'from'
+  | 'gas'
+  | 'gasPrice'
+  | 'maxFeePerGas'
+  | 'maxPriorityFeePerGas'
+  | 'nonce'
+  | 'to'
+  | 'data'
+  | 'value'
+> & {
   address: Address
   abi: TAbi
-  from?: Address
-  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
-  value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName, 'pure' | 'view'>
 } & ExtractArgsFromAbi<TAbi, TFunctionName>
 
-export type CallContractResponse<
+export type ReadContractResponse<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
 > = ExtractResultFromAbi<TAbi, TFunctionName>
 
-export async function callContract<
-  TChain extends Chain,
+export async function readContract<
   TAbi extends Abi = Abi,
   TFunctionName extends string = any,
 >(
@@ -50,8 +58,8 @@ export async function callContract<
     args,
     functionName,
     ...callRequest
-  }: CallContractArgs<TChain, TAbi, TFunctionName>,
-): Promise<CallContractResponse<TAbi, TFunctionName>> {
+  }: ReadContractArgs<TAbi, TFunctionName>,
+): Promise<ReadContractResponse<TAbi, TFunctionName>> {
   const calldata = encodeFunctionData({
     abi,
     args,
@@ -62,19 +70,18 @@ export async function callContract<
       data: calldata,
       to: address,
       ...callRequest,
-    } as unknown as CallArgs<TChain>)
+    } as unknown as CallArgs)
     return decodeFunctionResult({
       abi,
       functionName,
       data: data || '0x',
-    }) as CallContractResponse<TAbi, TFunctionName>
+    })
   } catch (err) {
     throw getContractError(err, {
       abi,
       address,
       args,
       functionName,
-      sender: callRequest.from,
     })
   }
 }

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

@@ -0,0 +1,31 @@
+import { Contract } from 'ethers'
+import { bench, describe } from 'vitest'
+
+import {
+  accounts,
+  ethersProvider,
+  publicClient,
+  wagmiContractConfig,
+} from '../../_test'
+
+import { simulateContract } from './simulateContract'
+
+describe('Simulate Contract', () => {
+  bench('viem: `simulateContract`', async () => {
+    await simulateContract(publicClient, {
+      ...wagmiContractConfig,
+      functionName: 'mint',
+      args: [1n],
+      from: accounts[0].address,
+    })
+  })
+
+  bench('ethers: `callStatic`', async () => {
+    const wagmi = new Contract(
+      wagmiContractConfig.address,
+      wagmiContractConfig.abi,
+      ethersProvider,
+    )
+    await wagmi.callStatic.mint(1)
+  })
+})

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/simulateContract.ts

@@ -0,0 +1,98 @@
+import { Abi } from 'abitype'
+
+import type { Chain, Formatter } from '../../chains'
+import type { PublicClient } from '../../clients'
+import type {
+  Address,
+  ExtractArgsFromAbi,
+  ExtractResultFromAbi,
+  ExtractFunctionNameFromAbi,
+  GetValue,
+} from '../../types'
+import {
+  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'> & {
+  address: Address
+  abi: TAbi
+  functionName: ExtractFunctionNameFromAbi<
+    TAbi,
+    TFunctionName,
+    'payable' | 'nonpayable'
+  >
+  value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
+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> & {
+    address: Address
+    abi: TAbi
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  } & ExtractArgsFromAbi<TAbi, TFunctionName>
+}
+
+export async function simulateContract<
+  TChain extends Chain,
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>(
+  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,
+      functionName,
+      data: data || '0x',
+    })
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest,
+      },
+    } as unknown as SimulateContractResponse<TChain, TAbi, TFunctionName>
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      functionName,
+      sender: callRequest.from,
+    })
+  }
+}

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"
+  `)
+})