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

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

@@ -1,8 +1,8 @@
 import { bench, describe } from 'vitest'
 
 import {
-  essentialProvider,
   ethersProvider,
+  ethersV6Provider,
   publicClient,
   web3Provider,
 } from '../../_test'
@@ -23,11 +23,11 @@ describe('Get Transaction', () => {
     await ethersProvider.getTransaction(hash)
   })
 
-  bench('web3.js: `getTransaction`', async () => {
-    await web3Provider.eth.getTransaction(hash)
+  bench('ethers@6: `getTransaction`', async () => {
+    await ethersV6Provider.getTransaction(hash)
   })
 
-  bench('essential-eth: `getTransaction`', async () => {
-    await essentialProvider.getTransaction(hash)
+  bench('web3.js: `getTransaction`', async () => {
+    await web3Provider.eth.getTransaction(hash)
   })
 })

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

@@ -1,8 +1,8 @@
 import { bench, describe } from 'vitest'
 
 import {
-  essentialProvider,
   ethersProvider,
+  ethersV6Provider,
   publicClient,
   web3Provider,
 } from '../../_test'
@@ -23,11 +23,11 @@ describe('Get Transaction Receipt', () => {
     await ethersProvider.getTransactionReceipt(hash)
   })
 
-  bench('web3.js: `getTransactionReceipt`', async () => {
-    await web3Provider.eth.getTransactionReceipt(hash)
+  bench('ethers@6: `getTransactionReceipt`', async () => {
+    await ethersV6Provider.getTransactionReceipt(hash)
   })
 
-  bench('essential-eth: `getTransactionReceipt`', async () => {
-    await essentialProvider.getTransactionReceipt(hash)
+  bench('web3.js: `getTransactionReceipt`', async () => {
+    await web3Provider.eth.getTransactionReceipt(hash)
   })
 })

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

@@ -29,6 +29,7 @@ test('exports actions', () => {
       "getTransactionConfirmations": [Function],
       "getTransactionCount": [Function],
       "getTransactionReceipt": [Function],
+      "multicall": [Function],
       "readContract": [Function],
       "simulateContract": [Function],
       "uninstallFilter": [Function],

package/src/actions/public/index.ts

@@ -105,6 +105,9 @@ export type {
   GetTransactionReceiptResponse,
 } from './getTransactionReceipt'
 
+export { multicall } from './multicall'
+export type { MulticallArgs } from './multicall'
+
 export { readContract } from './readContract'
 export type {
   ReadContractArgs,

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

@@ -0,0 +1,452 @@
+/**
+ * TODO:  Heaps more test cases :D
+ *        - Complex calldata types
+ *        - Complex return types (tuple/structs)
+ */
+
+import { describe, expect, test } from 'vitest'
+import {
+  accounts,
+  address,
+  initialBlockNumber,
+  publicClient,
+  usdcContractConfig,
+} from '../../_test'
+import { baycContractConfig, wagmiContractConfig } from '../../_test/abis'
+
+import { multicall } from './multicall'
+
+test('default', async () => {
+  expect(
+    await multicall(publicClient, {
+      blockNumber: initialBlockNumber,
+      contracts: [
+        {
+          ...usdcContractConfig,
+          functionName: 'totalSupply',
+        },
+        {
+          ...usdcContractConfig,
+          functionName: 'balanceOf',
+          args: [address.vitalik],
+        },
+        {
+          ...baycContractConfig,
+          functionName: 'totalSupply',
+        },
+      ],
+      multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+    }),
+  ).toMatchInlineSnapshot(`
+    [
+      {
+        "result": 41119586940119550n,
+        "status": "success",
+      },
+      {
+        "result": 231481998602n,
+        "status": "success",
+      },
+      {
+        "result": 10000n,
+        "status": "success",
+      },
+    ]
+  `)
+})
+
+describe('errors', async () => {
+  describe('allowFailure is truthy', async () => {
+    test('function not found', async () => {
+      expect(
+        await multicall(publicClient, {
+          blockNumber: initialBlockNumber,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              // @ts-expect-error
+              functionName: 'lol',
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ],
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).toMatchInlineSnapshot(`
+        [
+          {
+            "error": [ContractFunctionExecutionError: The contract function "lol" returned no data ("0x").
+
+        This could be due to any of the following:
+        - The contract does not have the function "lol",
+        - The parameters passed to the contract function may be invalid, or
+        - The address is not a contract.
+         
+        Contract:  0x0000000000000000000000000000000000000000
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2],
+            "result": undefined,
+            "status": "failure",
+          },
+          {
+            "result": 231481998602n,
+            "status": "success",
+          },
+          {
+            "result": 10000n,
+            "status": "success",
+          },
+        ]
+      `)
+    })
+
+    test('invalid params', async () => {
+      expect(
+        await multicall(publicClient, {
+          blockNumber: initialBlockNumber,
+          // @ts-expect-error
+          contracts: [
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik, 1n],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).toMatchInlineSnapshot(`
+        [
+          {
+            "error": [ContractFunctionExecutionError: The contract function "balanceOf" returned no data ("0x").
+
+        This could be due to any of the following:
+        - The contract does not have the function "balanceOf",
+        - The parameters passed to the contract function may be invalid, or
+        - The address is not a contract.
+         
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  balanceOf(address account)
+        Arguments:          (0xd8da6bf26964af9d7eed9e03e53415d37aa96045)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2],
+            "result": undefined,
+            "status": "failure",
+          },
+          {
+            "result": 231481998602n,
+            "status": "success",
+          },
+          {
+            "result": 10000n,
+            "status": "success",
+          },
+        ]
+      `)
+    })
+
+    test('invalid contract address', async () => {
+      expect(
+        await multicall(publicClient, {
+          blockNumber: initialBlockNumber,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              address: '0x0000000000000000000000000000000000000000',
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).toMatchInlineSnapshot(`
+        [
+          {
+            "error": [ContractFunctionExecutionError: The contract function "balanceOf" returned no data ("0x").
+
+        This could be due to any of the following:
+        - The contract does not have the function "balanceOf",
+        - The parameters passed to the contract function may be invalid, or
+        - The address is not a contract.
+         
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  balanceOf(address account)
+        Arguments:          (0xd8da6bf26964af9d7eed9e03e53415d37aa96045)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2],
+            "result": undefined,
+            "status": "failure",
+          },
+          {
+            "result": 231481998602n,
+            "status": "success",
+          },
+          {
+            "result": 10000n,
+            "status": "success",
+          },
+        ]
+      `)
+    })
+
+    test('contract revert', async () => {
+      expect(
+        await multicall(publicClient, {
+          blockNumber: initialBlockNumber,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...wagmiContractConfig,
+              functionName: 'transferFrom',
+              args: [address.vitalik, accounts[0].address, 1n],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'tokenOfOwnerByIndex',
+              args: [address.vitalik, 1n],
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).toMatchInlineSnapshot(`
+        [
+          {
+            "result": 231481998602n,
+            "status": "success",
+          },
+          {
+            "result": 231481998602n,
+            "status": "success",
+          },
+          {
+            "error": [ContractFunctionExecutionError: The contract function "transferFrom" reverted with the following reason:
+        ERC721: transfer caller is not owner nor approved
+
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  transferFrom(address from, address to, uint256 tokenId)
+        Arguments:             (0xd8da6bf26964af9d7eed9e03e53415d37aa96045, 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266, 1)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2],
+            "result": undefined,
+            "status": "failure",
+          },
+          {
+            "result": 10000n,
+            "status": "success",
+          },
+          {
+            "error": [ContractFunctionExecutionError: The contract function "tokenOfOwnerByIndex" reverted with the following reason:
+        EnumerableSet: index out of bounds
+
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  tokenOfOwnerByIndex(address owner, uint256 index)
+        Arguments:                    (0xd8da6bf26964af9d7eed9e03e53415d37aa96045, 1)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2],
+            "result": undefined,
+            "status": "failure",
+          },
+        ]
+      `)
+    })
+  })
+
+  describe('allowFailure is falsy', async () => {
+    test('function not found', async () => {
+      await expect(() =>
+        multicall(publicClient, {
+          allowFailure: false,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              // @ts-expect-error
+              functionName: 'lol',
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ],
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).rejects.toMatchInlineSnapshot(`
+        [ContractFunctionExecutionError: Function "lol" not found on ABI.
+        Make sure you are using the correct ABI and that the function exists on it.
+
+        Contract:  0x0000000000000000000000000000000000000000
+
+        Docs: https://viem.sh/docs/contract/encodeFunctionData
+        Version: viem@1.0.2]
+      `)
+    })
+
+    test('invalid params', async () => {
+      await expect(() =>
+        multicall(publicClient, {
+          allowFailure: false,
+          // @ts-expect-error
+          contracts: [
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik, 1n],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).rejects.toMatchInlineSnapshot(`
+        [ContractFunctionExecutionError: ABI encoding params/values length mismatch.
+        Expected length (params): 1
+        Given length (values): 2
+
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  balanceOf(address account)
+        Arguments:          (0xd8da6bf26964af9d7eed9e03e53415d37aa96045)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2]
+      `)
+    })
+
+    test('invalid contract address', async () => {
+      await expect(() =>
+        multicall(publicClient, {
+          allowFailure: false,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              address: '0x0000000000000000000000000000000000000000',
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).rejects.toMatchInlineSnapshot(`
+        [ContractFunctionExecutionError: The contract function "balanceOf" returned no data ("0x").
+
+        This could be due to any of the following:
+        - The contract does not have the function "balanceOf",
+        - The parameters passed to the contract function may be invalid, or
+        - The address is not a contract.
+         
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  balanceOf(address account)
+        Arguments:          (0xd8da6bf26964af9d7eed9e03e53415d37aa96045)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2]
+      `)
+    })
+
+    test('contract revert', async () => {
+      await expect(() =>
+        multicall(publicClient, {
+          allowFailure: false,
+          contracts: [
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...usdcContractConfig,
+              functionName: 'balanceOf',
+              args: [address.vitalik],
+            },
+            {
+              ...wagmiContractConfig,
+              functionName: 'transferFrom',
+              args: [address.vitalik, accounts[0].address, 1n],
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'totalSupply',
+            },
+            {
+              ...baycContractConfig,
+              functionName: 'tokenOfOwnerByIndex',
+              args: [address.vitalik, 1n],
+            },
+          ] as const,
+          multicallAddress: '0xca11bde05977b3631167028862be2a173976ca11',
+        }),
+      ).rejects.toMatchInlineSnapshot(`
+        [ContractFunctionExecutionError: The contract function "transferFrom" reverted with the following reason:
+        ERC721: transfer caller is not owner nor approved
+
+        Contract:  0x0000000000000000000000000000000000000000
+        Function:  transferFrom(address from, address to, uint256 tokenId)
+        Arguments:             (0xd8da6bf26964af9d7eed9e03e53415d37aa96045, 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266, 1)
+
+        Docs: https://viem.sh/docs/contract/multicall
+        Version: viem@1.0.2]
+      `)
+    })
+  })
+})

package/src/actions/public/multicall.ts

@@ -0,0 +1,103 @@
+import { PublicClient } from '../../clients'
+import { multicall3Abi } from '../../constants'
+import {
+  AbiDecodingZeroDataError,
+  BaseError,
+  RawContractError,
+} from '../../errors'
+import { Address, ContractConfig, Hex, MulticallContracts } from '../../types'
+import { MulticallResults } from '../../types/multicall'
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  EncodeFunctionDataArgs,
+  getContractError,
+} from '../../utils'
+import { CallArgs } from './call'
+import { readContract } from './readContract'
+
+export type MulticallArgs<
+  TContracts extends ContractConfig[],
+  TAllowFailure extends boolean = true,
+> = Pick<CallArgs, 'blockNumber' | 'blockTag'> & {
+  allowFailure?: TAllowFailure
+  contracts: readonly [...MulticallContracts<TContracts>]
+  multicallAddress: Address
+}
+
+export async function multicall<
+  TContracts extends ContractConfig[],
+  TAllowFailure extends boolean = true,
+>(
+  client: PublicClient,
+  args: MulticallArgs<TContracts, TAllowFailure>,
+): Promise<MulticallResults<TContracts, TAllowFailure>> {
+  const {
+    allowFailure = true,
+    blockNumber,
+    blockTag,
+    contracts,
+    multicallAddress,
+  } = args
+
+  const calls = contracts.map(({ abi, address, args, functionName }) => {
+    try {
+      const callData = encodeFunctionData({
+        abi,
+        args,
+        functionName,
+      } as unknown as EncodeFunctionDataArgs)
+      return {
+        allowFailure: true,
+        callData,
+        target: address,
+      }
+    } catch (err) {
+      const error = getContractError(err as BaseError, {
+        abi,
+        address,
+        args,
+        docsPath: '/docs/contract/multicall',
+        functionName,
+      })
+      if (!allowFailure) throw error
+      return {
+        allowFailure: true,
+        callData: '0x' as Hex,
+        target: address,
+      }
+    }
+  })
+  const results = await readContract(client, {
+    abi: multicall3Abi,
+    address: multicallAddress,
+    args: [calls],
+    blockNumber,
+    blockTag,
+    functionName: 'aggregate3',
+  })
+  return results.map(({ returnData, success }, i) => {
+    const { callData } = calls[i]
+    const { abi, address, functionName, args } = contracts[i]
+    try {
+      if (callData === '0x') throw new AbiDecodingZeroDataError()
+      if (!success) throw new RawContractError({ data: returnData })
+      const result = decodeFunctionResult({
+        abi,
+        data: returnData,
+        functionName: functionName,
+      })
+      return { result, status: 'success' }
+    } catch (err) {
+      const error = getContractError(err as BaseError, {
+        abi,
+        address,
+        args,
+        docsPath: '/docs/contract/multicall',
+        functionName,
+      })
+      if (!allowFailure) throw error
+      return { error, result: undefined, status: 'failure' }
+    }
+  }) as MulticallResults<TContracts, TAllowFailure>
+}