feat: initial callContract implementation

.changeset/moody-gorillas-wait.md

@@ -0,0 +1,5 @@
+---
+"viem": patch
+---
+
+Added initial `callContract` implementation

src/actions/index.test.ts

@@ -7,6 +7,7 @@ test('exports actions', () => {
     {
       "addChain": [Function],
       "call": [Function],
+      "callContract": [Function],
       "createBlockFilter": [Function],
       "createPendingTransactionFilter": [Function],
       "dropTransaction": [Function],

src/actions/index.ts

@@ -1,5 +1,6 @@
 export {
   call,
+  callContract,
   createBlockFilter,
   createPendingTransactionFilter,
   estimateGas,
@@ -25,6 +26,8 @@ export {
 } from './public'
 export type {
   CallArgs,
+  CallContractArgs,
+  CallContractResponse,
   CallResponse,
   CreateBlockFilterResponse,
   CreatePendingTransactionFilterResponse,

src/actions/public/call.ts

@@ -2,6 +2,7 @@ import type { Chain, Formatter } from '../../chains'
 import type { PublicClient } from '../../clients'
 import { InvalidGasArgumentsError } from '../../errors'
 import type {
+  Address,
   BlockTag,
   Hex,
   MergeIntersectionProperties,
@@ -21,6 +22,7 @@ export type CallArgs<TChain extends Chain = Chain> = FormattedCall<
   TransactionRequestFormatter<TChain>
 > & {
   chain?: TChain
+  from?: Address
 } & (
     | {
         /** The balance of the account at a block number. */

src/actions/public/callContract.bench.ts

@@ -0,0 +1,28 @@
+import { Contract } from 'ethers'
+import { bench, describe } from 'vitest'
+
+import {
+  ethersProvider,
+  publicClient,
+  wagmiContractConfig,
+} from '../../../test'
+
+import { callContract } from './callContract'
+
+describe('Call Contract', () => {
+  bench('viem: `callContract`', async () => {
+    await callContract(publicClient, {
+      ...wagmiContractConfig,
+      functionName: 'totalSupply',
+    })
+  })
+
+  bench('ethers: `callStatic`', async () => {
+    const wagmi = new Contract(
+      wagmiContractConfig.address,
+      wagmiContractConfig.abi,
+      ethersProvider,
+    )
+    await wagmi.callStatic.mint(1)
+  })
+})

src/actions/public/callContract.ts

@@ -0,0 +1,80 @@
+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 { call, CallArgs, FormattedCall } from './call'
+
+export type FormattedCallContract<
+  TFormatter extends Formatter | undefined = Formatter,
+> = FormattedCall<TFormatter>
+
+export type CallContractArgs<
+  TChain extends Chain = Chain,
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = any,
+> = Omit<CallArgs<TChain>, 'from' | 'to' | 'data' | 'value'> & {
+  address: Address
+  abi: TAbi
+  from?: Address
+  functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>
+  value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>
+} & ExtractArgsFromAbi<TAbi, TFunctionName>
+
+export type CallContractResponse<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TFunctionName extends string = string,
+> = ExtractResultFromAbi<TAbi, TFunctionName>
+
+export async function callContract<
+  TChain extends Chain,
+  TAbi extends Abi = Abi,
+  TFunctionName extends string = any,
+>(
+  client: PublicClient,
+  {
+    abi,
+    address,
+    args,
+    functionName,
+    ...callRequest
+  }: CallContractArgs<TChain, TAbi, TFunctionName>,
+): Promise<CallContractResponse<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>)
+    return decodeFunctionResult({
+      abi,
+      functionName,
+      data: data || '0x',
+    }) as CallContractResponse<TAbi, TFunctionName>
+  } catch (err) {
+    throw getContractError(err, {
+      abi,
+      address,
+      args,
+      functionName,
+      sender: callRequest.from,
+    })
+  }
+}

src/actions/public/index.test.ts

@@ -6,6 +6,7 @@ test('exports actions', () => {
   expect(actions).toMatchInlineSnapshot(`
     {
       "call": [Function],
+      "callContract": [Function],
       "createBlockFilter": [Function],
       "createPendingTransactionFilter": [Function],
       "estimateGas": [Function],

src/actions/public/index.ts

@@ -1,6 +1,13 @@
 export { call } from './call'
 export type { CallArgs, CallResponse, FormattedCall } from './call'
 
+export { callContract } from './callContract'
+export type {
+  CallContractArgs,
+  CallContractResponse,
+  FormattedCallContract,
+} from './callContract'
+
 export { createPendingTransactionFilter } from './createPendingTransactionFilter'
 export type { CreatePendingTransactionFilterResponse } from './createPendingTransactionFilter'
 

src/errors/abi.ts

@@ -43,6 +43,13 @@ export class AbiDecodingDataSizeInvalidError extends BaseError {
   }
 }
 
+export class AbiDecodingZeroDataError extends BaseError {
+  name = 'AbiDecodingZeroDataError'
+  constructor() {
+    super('Cannot decode zero data ("0x") with ABI parameters.')
+  }
+}
+
 export class AbiEncodingArrayLengthMismatchError extends BaseError {
   name = 'AbiEncodingArrayLengthMismatchError'
   constructor({
@@ -220,15 +227,12 @@ export class InvalidArrayError extends BaseError {
 
 export class InvalidDefinitionTypeError extends BaseError {
   name = 'InvalidDefinitionTypeError'
-  constructor(type: string, { docsPath }: { docsPath: string }) {
+  constructor(type: string) {
     super(
       [
         `"${type}" is not a valid definition type.`,
         'Valid types: "function", "event", "error"',
       ].join('\n'),
-      {
-        docsPath,
-      },
     )
   }
 }

src/errors/base.ts

@@ -1,5 +1,6 @@
 // @ts-ignore
 import pkg from '../../package.json'
+import { stringify } from '../utils/stringify'
 
 /* c8 ignore next */
 const version = process.env.TEST ? '1.0.2' : pkg.version
@@ -42,7 +43,7 @@ export class BaseError extends Error {
       ...(args.cause &&
       !(args.cause instanceof BaseError) &&
       Object.keys(args.cause).length > 0
-        ? [`Internal Error: ${JSON.stringify(args.cause)}`]
+        ? [`Internal Error: ${stringify(args.cause)}`]
         : []),
     ].join('\n')
 

src/errors/contract.ts

@@ -0,0 +1,125 @@
+import { Abi } from 'abitype'
+import { Address } from '../types'
+import { BaseError } from './base'
+
+export class ContractMethodExecutionError extends BaseError {
+  abi?: Abi
+  args?: unknown[]
+  contractAddress?: Address
+  formattedArgs?: string
+  functionName?: string
+  reason?: string
+  sender?: Address
+
+  name = 'ContractMethodExecutionError'
+
+  constructor(
+    message?: string,
+    {
+      abi,
+      args,
+      cause,
+      contractAddress,
+      formattedArgs,
+      functionName,
+      functionWithParams,
+      sender,
+    }: {
+      abi?: Abi
+      args?: any
+      cause?: Error
+      contractAddress?: Address
+      formattedArgs?: string
+      functionName?: string
+      functionWithParams?: string
+      sender?: Address
+    } = {},
+  ) {
+    super(
+      [
+        message,
+        ' ',
+        sender && `Sender:    ${sender}`,
+        contractAddress &&
+          `Contract:  ${
+            /* c8 ignore start */
+            process.env.TEST
+              ? '0x0000000000000000000000000000000000000000'
+              : contractAddress
+            /* c8 ignore end */
+          }`,
+        functionWithParams && `Function:  ${functionWithParams}`,
+        formattedArgs &&
+          `Arguments: ${[...Array(functionName?.length ?? 0).keys()]
+            .map(() => ' ')
+            .join('')}${formattedArgs}`,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+      {
+        cause,
+      },
+    )
+    if (message) this.reason = message
+    this.abi = abi
+    this.args = args
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+    this.sender = sender
+  }
+}
+
+export class ContractMethodZeroDataError extends BaseError {
+  abi?: Abi
+  args?: unknown[]
+  contractAddress?: Address
+  functionName?: string
+  functionWithParams?: string
+
+  name = 'ContractMethodZeroDataError'
+
+  constructor({
+    abi,
+    args,
+    cause,
+    contractAddress,
+    functionName,
+    functionWithParams,
+  }: {
+    abi?: Abi
+    args?: any
+    cause?: Error
+    contractAddress?: Address
+    functionName?: string
+    functionWithParams?: string
+  } = {}) {
+    super(
+      [
+        `The contract method "${functionName}" returned no data ("0x"). This could be due to any of the following:`,
+        `- The contract does not have the function "${functionName}",`,
+        '- The parameters passed to the contract function may be invalid, or',
+        '- The address is not a contract.',
+        ' ',
+        contractAddress &&
+          `Contract: ${
+            /* c8 ignore start */
+            process.env.TEST
+              ? '0x0000000000000000000000000000000000000000'
+              : contractAddress
+            /* c8 ignore end */
+          }`,
+        functionWithParams && `Function: ${functionWithParams}`,
+        functionWithParams && `        > "0x"`,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+      {
+        cause,
+      },
+    )
+    this.abi = abi
+    this.args = args
+    this.contractAddress = contractAddress
+    this.functionName = functionName
+  }
+}

src/errors/index.ts

@@ -2,6 +2,7 @@ export {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
   AbiDecodingDataSizeInvalidError,
+  AbiDecodingZeroDataError,
   AbiEncodingArrayLengthMismatchError,
   AbiEncodingLengthMismatchError,
   AbiErrorInputsNotFoundError,
@@ -23,6 +24,11 @@ export { BaseError } from './base'
 
 export { BlockNotFoundError } from './block'
 
+export {
+  ContractMethodExecutionError,
+  ContractMethodZeroDataError,
+} from './contract'
+
 export { SizeExceedsPaddingSizeError } from './data'
 
 export {