viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/actions/public/multicall.ts

@@ -1,26 +1,26 @@
-import type { Narrow } from 'abitype'
-import type { PublicClient, Transport } from '../../clients/index.js'
-import { multicall3Abi } from '../../constants/index.js'
-import type { BaseError } from '../../errors/index.js'
-import {
-  AbiDecodingZeroDataError,
-  RawContractError,
-} from '../../errors/index.js'
+import type { Address, Narrow } from 'abitype'
+
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { multicall3Abi } from '../../constants/abis.js'
+import { AbiDecodingZeroDataError } from '../../errors/abi.js'
+import type { BaseError } from '../../errors/base.js'
+import { RawContractError } from '../../errors/contract.js'
+import type { Chain } from '../../types/chain.js'
+import type { ContractFunctionConfig } from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
 import type {
-  Address,
-  Chain,
-  ContractFunctionConfig,
-  Hex,
   MulticallContracts,
-} from '../../types/index.js'
-import type { MulticallResults } from '../../types/multicall.js'
+  MulticallResults,
+} from '../../types/multicall.js'
+import { decodeFunctionResult } from '../../utils/abi/decodeFunctionResult.js'
 import {
-  decodeFunctionResult,
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
-  getChainContractAddress,
-  getContractError,
-} from '../../utils/index.js'
-import type { EncodeFunctionDataParameters } from '../../utils/index.js'
+} from '../../utils/abi/encodeFunctionData.js'
+import { getChainContractAddress } from '../../utils/chain.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+
 import type { CallParameters } from './call.js'
 import { readContract } from './readContract.js'
 
@@ -29,6 +29,8 @@ export type MulticallParameters<
   TAllowFailure extends boolean = true,
 > = Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
   allowFailure?: TAllowFailure
+  /** The maximum size (in bytes) for each calldata chunk. Set to `0` to disable the size limit. @default 1_024 */
+  batchSize?: number
   contracts: Narrow<readonly [...MulticallContracts<TContracts>]>
   multicallAddress?: Address
 }
@@ -38,22 +40,68 @@ export type MulticallReturnType<
   TAllowFailure extends boolean = true,
 > = MulticallResults<TContracts, TAllowFailure>
 
+/**
+ * Similar to [`readContract`](https://viem.sh/docs/contract/readContract.html), but batches up multiple functions on a contract in a single RPC call via the [`multicall3` contract](https://github.com/mds1/multicall).
+ *
+ * - Docs: https://viem.sh/docs/contract/multicall.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link MulticallParameters}
+ * @returns An array of results with accompanying status. {@link MulticallReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { multicall } from 'viem/contract'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const abi = parseAbi([
+ *   'function balanceOf(address) view returns (uint256)',
+ *   'function totalSupply() view returns (uint256)',
+ * ])
+ * const results = await multicall(client, {
+ *   contracts: [
+ *     {
+ *       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *       abi,
+ *       functionName: 'balanceOf',
+ *       args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
+ *     },
+ *     {
+ *       address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *       abi,
+ *       functionName: 'totalSupply',
+ *     },
+ *   ],
+ * })
+ * // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
+ */
 export async function multicall<
   TChain extends Chain | undefined,
   TContracts extends ContractFunctionConfig[],
   TAllowFailure extends boolean = true,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   args: MulticallParameters<TContracts, TAllowFailure>,
 ): Promise<MulticallReturnType<TContracts, TAllowFailure>> {
   const {
     allowFailure = true,
+    batchSize: batchSize_,
     blockNumber,
     blockTag,
     contracts: contracts_,
     multicallAddress: multicallAddress_,
   } = args
 
+  const batchSize =
+    batchSize_ ??
+    ((typeof client.batch?.multicall === 'object' &&
+      client.batch.multicall.batchSize) ||
+      1_024)
+
   // Fix type cast from `Narrow` in type definition.
   const contracts = contracts_ as readonly [...MulticallContracts<TContracts>]
 
@@ -71,18 +119,39 @@ export async function multicall<
     })
   }
 
-  const calls = contracts.map(({ abi, address, args, functionName }) => {
+  type Aggregate3Calls = {
+    allowFailure: boolean
+    callData: Hex
+    target: Address
+  }[]
+
+  const chunkedCalls: Aggregate3Calls[] = [[]]
+  let currentChunk = 0
+  let currentChunkSize = 0
+  for (let i = 0; i < contracts.length; i++) {
+    const { abi, address, args, functionName } = contracts[i]
     try {
       const callData = encodeFunctionData({
         abi,
         args,
         functionName,
       } as unknown as EncodeFunctionDataParameters)
-      return {
-        allowFailure: true,
-        callData,
-        target: address,
+
+      currentChunkSize += callData.length
+      if (batchSize > 0 && currentChunkSize > batchSize) {
+        currentChunk++
+        currentChunkSize = (callData.length - 2) / 2
+        chunkedCalls[currentChunk] = []
       }
+
+      chunkedCalls[currentChunk] = [
+        ...chunkedCalls[currentChunk],
+        {
+          allowFailure: true,
+          callData,
+          target: address,
+        },
+      ]
     } catch (err) {
       const error = getContractError(err as BaseError, {
         abi,
@@ -92,22 +161,32 @@ export async function multicall<
         functionName,
       })
       if (!allowFailure) throw error
-      return {
-        allowFailure: true,
-        callData: '0x' as Hex,
-        target: address,
-      }
+      chunkedCalls[currentChunk] = [
+        ...chunkedCalls[currentChunk],
+        {
+          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 results = await Promise.all(
+    chunkedCalls.map((calls) =>
+      readContract(client, {
+        abi: multicall3Abi,
+        address: multicallAddress!,
+        args: [calls],
+        blockNumber,
+        blockTag,
+        functionName: 'aggregate3',
+      }),
+    ),
+  )
+
+  return results.flat().map(({ returnData, success }, i) => {
+    const calls = chunkedCalls.flat()
     const { callData } = calls[i]
     const { abi, address, functionName, args } = contracts[i]
     try {
@@ -115,6 +194,7 @@ export async function multicall<
       if (!success) throw new RawContractError({ data: returnData })
       const result = decodeFunctionResult({
         abi,
+        args,
         data: returnData,
         functionName: functionName,
       })

package/src/actions/public/readContract.ts

@@ -1,28 +1,29 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { BaseError } from '../../errors/index.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseError } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
 import type {
-  Chain,
   ContractFunctionConfig,
   ContractFunctionResult,
-} from '../../types/index.js'
+} from '../../types/contract.js'
 import {
+  type DecodeFunctionResultParameters,
   decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
-  getContractError,
-} from '../../utils/index.js'
-import type {
-  DecodeFunctionResultParameters,
-  EncodeFunctionDataParameters,
-} from '../../utils/index.js'
-import { call } from './call.js'
-import type { CallParameters } from './call.js'
+} from '../../utils/abi/encodeFunctionData.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+
+import { type CallParameters, call } from './call.js'
 
 export type ReadContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
-> = Pick<CallParameters, 'blockNumber' | 'blockTag'> &
+> = Pick<CallParameters, 'account' | 'blockNumber' | 'blockTag'> &
   ContractFunctionConfig<TAbi, TFunctionName, 'view' | 'pure'>
 
 export type ReadContractReturnType<
@@ -30,12 +31,43 @@ export type ReadContractReturnType<
   TFunctionName extends string = string,
 > = ContractFunctionResult<TAbi, TFunctionName>
 
+/**
+ * Calls a read-only function on a contract, and returns the response.
+ *
+ * - Docs: https://viem.sh/docs/contract/readContract.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/reading-contracts
+ *
+ * A "read-only" function (constant function) on a Solidity contract is denoted by a `view` or `pure` keyword. They can only read the state of the contract, and cannot make any changes to it. Since read-only methods do not change the state of the contract, they do not require any gas to be executed, and can be called by any user without the need to pay for gas.
+ *
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+ *
+ * @param client - Client to use
+ * @param parameters - {@link ReadContractParameters}
+ * @returns The response from the contract. Type is inferred. {@link ReadContractReturnType}
+ *
+ * @example
+ * import { createPublicClient, http, parseAbi } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { readContract } from 'viem/contract'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const result = await readContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
+ *   functionName: 'balanceOf',
+ *   args: ['0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'],
+ * })
+ * // 424122n
+ */
 export async function readContract<
   TChain extends Chain | undefined,
   TAbi extends Abi | readonly unknown[],
   TFunctionName extends string,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     abi,
     address,
@@ -60,7 +92,10 @@ export async function readContract<
       args,
       functionName,
       data: data || '0x',
-    } as DecodeFunctionResultParameters<TAbi, TFunctionName>)
+    } as DecodeFunctionResultParameters<
+      TAbi,
+      TFunctionName
+    >) as ReadContractReturnType<TAbi, TFunctionName>
   } catch (err) {
     throw getContractError(err as BaseError, {
       abi: abi as Abi,

package/src/actions/public/simulateContract.ts

@@ -1,26 +1,29 @@
 import type { Abi } from 'abitype'
 
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { BaseError } from '../../errors/index.js'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { BaseError } from '../../errors/base.js'
+import type { Chain } from '../../types/chain.js'
 import type {
-  Chain,
   ContractFunctionConfig,
   ContractFunctionResult,
   GetValue,
-} from '../../types/index.js'
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import type { UnionOmit } from '../../types/utils.js'
 import {
+  type DecodeFunctionResultParameters,
   decodeFunctionResult,
+} from '../../utils/abi/decodeFunctionResult.js'
+import {
+  type EncodeFunctionDataParameters,
   encodeFunctionData,
-  getContractError,
-  parseAccount,
-} from '../../utils/index.js'
-import type {
-  DecodeFunctionResultParameters,
-  EncodeFunctionDataParameters,
-} from '../../utils/index.js'
-import type { WriteContractParameters } from '../wallet/index.js'
-import { call } from './call.js'
-import type { CallParameters } from './call.js'
+} from '../../utils/abi/encodeFunctionData.js'
+import { getContractError } from '../../utils/errors/getContractError.js'
+import type { WriteContractParameters } from '../wallet/writeContract.js'
+
+import { type CallParameters, call } from './call.js'
 
 export type SimulateContractParameters<
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -29,12 +32,20 @@ export type SimulateContractParameters<
   TChainOverride extends Chain | undefined = undefined,
 > = {
   chain?: TChainOverride
+  /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
+  dataSuffix?: Hex
 } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
-  Omit<
+  UnionOmit<
     CallParameters<TChainOverride extends Chain ? TChainOverride : TChain>,
-    'to' | 'data' | 'value'
+    'batch' | 'to' | 'data' | 'value'
   > &
-  GetValue<TAbi, TFunctionName, CallParameters<TChain>['value']>
+  GetValue<
+    TAbi,
+    TFunctionName,
+    CallParameters<TChain> extends CallParameters
+      ? CallParameters<TChain>['value']
+      : CallParameters['value']
+  >
 
 export type SimulateContractReturnType<
   TAbi extends Abi | readonly unknown[] = Abi,
@@ -43,7 +54,7 @@ export type SimulateContractReturnType<
   TChainOverride extends Chain | undefined = undefined,
 > = {
   result: ContractFunctionResult<TAbi, TFunctionName>
-  request: Omit<
+  request: UnionOmit<
     WriteContractParameters<
       TAbi,
       TFunctionName,
@@ -51,23 +62,56 @@ export type SimulateContractReturnType<
       undefined,
       TChainOverride
     >,
-    'chain'
+    'chain' | 'functionName'
   > & {
     chain: TChainOverride
+    functionName: TFunctionName
   } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
 }
 
+/**
+ * Simulates/validates a contract interaction. This is useful for retrieving **return data** and **revert reasons** of contract write functions.
+ *
+ * - Docs: https://viem.sh/docs/contract/simulateContract.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
+ *
+ * This function does not require gas to execute and _**does not**_ change the state of the blockchain. It is almost identical to [`readContract`](https://viem.sh/docs/contract/readContract.html), but also supports contract write functions.
+ *
+ * Internally, uses a [Public Client](https://viem.sh/docs/clients/public.html) to call the [`call` action](https://viem.sh/docs/actions/public/call.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SimulateContractParameters}
+ * @returns The simulation result and write request. {@link SimulateContractReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { simulateContract } from 'viem/contract'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const result = await simulateContract(client, {
+ *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+ *   abi: parseAbi(['function mint(uint32) view returns (uint32)']),
+ *   functionName: 'mint',
+ *   args: ['69420'],
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
 export async function simulateContract<
   TChain extends Chain | undefined,
   TAbi extends Abi | readonly unknown[],
   TFunctionName extends string,
   TChainOverride extends Chain | undefined,
 >(
-  client: PublicClient<Transport, TChain>,
+  client: Client<Transport, TChain>,
   {
     abi,
     address,
     args,
+    dataSuffix,
     functionName,
     ...callRequest
   }: SimulateContractParameters<TAbi, TFunctionName, TChain, TChainOverride>,
@@ -84,7 +128,8 @@ export async function simulateContract<
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   try {
     const { data } = await call(client, {
-      data: calldata,
+      batch: false,
+      data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
       to: address,
       ...callRequest,
     } as unknown as CallParameters<TChain>)
@@ -100,6 +145,7 @@ export async function simulateContract<
         abi,
         address,
         args,
+        dataSuffix,
         functionName,
         ...callRequest,
       },

package/src/actions/public/uninstallFilter.ts

@@ -1,19 +1,45 @@
-import type { PublicClient, Transport } from '../../clients/index.js'
-import type { Chain, Filter } from '../../types/index.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Chain } from '../../types/chain.js'
+import type { Filter } from '../../types/filter.js'
 
 export type UninstallFilterParameters = {
   filter: Filter<any>
 }
 export type UninstallFilterReturnType = boolean
 
+/**
+ * Destroys a [`Filter`](https://viem.sh/docs/glossary/types.html#filter).
+ *
+ * - Docs: https://viem.sh/docs/actions/public/uninstallFilter.html
+ * - JSON-RPC Methods: [`eth_uninstallFilter`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_uninstallFilter)
+ *
+ * Destroys a Filter that was created from one of the following Actions:
+ * - [`createBlockFilter`](https://viem.sh/docs/actions/public/createBlockFilter.html)
+ * - [`createEventFilter`](https://viem.sh/docs/actions/public/createEventFilter.html)
+ * - [`createPendingTransactionFilter`](https://viem.sh/docs/actions/public/createPendingTransactionFilter.html)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link UninstallFilterParameters}
+ * @returns A boolean indicating if the Filter was successfully uninstalled. {@link UninstallFilterReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { createPendingTransactionFilter, uninstallFilter } from 'viem/public'
+ *
+ * const filter = await createPendingTransactionFilter(client)
+ * const uninstalled = await uninstallFilter(client, { filter })
+ * // true
+ */
 export async function uninstallFilter<
   TTransport extends Transport,
   TChain extends Chain | undefined,
 >(
-  client: PublicClient<TTransport, TChain>,
+  _client: Client<TTransport, TChain>,
   { filter }: UninstallFilterParameters,
 ): Promise<UninstallFilterReturnType> {
-  return client.request({
+  return filter.request({
     method: 'eth_uninstallFilter',
     params: [filter.id],
   })

package/src/actions/public/verifyHash.ts

@@ -0,0 +1,62 @@
+import type { Address } from 'abitype'
+
+import type { Chain } from '../../chains/index.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { universalSignatureValidatorAbi } from '../../constants/abis.js'
+import { universalSignatureValidatorByteCode } from '../../constants/contracts.js'
+import { CallExecutionError } from '../../errors/contract.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { isBytesEqual } from '../../utils/data/isBytesEqual.js'
+import { encodeDeployData, isHex, toHex } from '../../utils/index.js'
+import { type CallParameters, call } from './call.js'
+
+export type VerifyHashParameters = Pick<
+  CallParameters,
+  'blockNumber' | 'blockTag'
+> & {
+  /** The address that signed the original message. */
+  address: Address
+  /** The hash to be verified. */
+  hash: Hex
+  /** The signature that was generated by signing the message with the address's private key. */
+  signature: Hex | ByteArray
+}
+
+export type VerifyHashReturnType = boolean
+
+/**
+ * Verifies a message hash on chain using ERC-6492.
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link VerifyHashParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyHashReturnType}
+ */
+export async function verifyHash<TChain extends Chain | undefined,>(
+  client: Client<Transport, TChain>,
+  { address, hash, signature, ...callRequest }: VerifyHashParameters,
+): Promise<VerifyHashReturnType> {
+  const signatureHex = isHex(signature) ? signature : toHex(signature)
+
+  try {
+    const { data } = await call(client, {
+      data: encodeDeployData({
+        abi: universalSignatureValidatorAbi,
+        args: [address, hash, signatureHex],
+        bytecode: universalSignatureValidatorByteCode,
+      }),
+      ...callRequest,
+    } as unknown as CallParameters)
+
+    return isBytesEqual(data ?? '0x0', '0x1')
+  } catch (error) {
+    if (error instanceof CallExecutionError) {
+      // if the execution fails, the signature was not valid and an internal method inside of the validator reverted
+      // this can happen for many reasons, for example if signer can not be recovered from the signature
+      // or if the signature has no valid format
+      return false
+    }
+
+    throw error
+  }
+}

package/src/actions/public/verifyMessage.ts

@@ -0,0 +1,42 @@
+import type { Chain } from '../../chains/index.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
+import { hashMessage } from '../../utils/index.js'
+import { type VerifyHashParameters, verifyHash } from './verifyHash.js'
+import type { Address } from 'abitype'
+
+export type VerifyMessageParameters = Omit<VerifyHashParameters, 'hash'> & {
+  /** The address that signed the original message. */
+  address: Address
+  /** The message to be verified. */
+  message: SignableMessage
+  /** The signature that was generated by signing the message with the address's private key. */
+  signature: Hex | ByteArray
+}
+
+export type VerifyMessageReturnType = boolean
+
+/**
+ * Verify that a message was signed by the provided address.
+ *
+ * Compatible with Smart Contract Accounts & Externally Owned Accounts via [ERC-6492](https://eips.ethereum.org/EIPS/eip-6492).
+ *
+ * - Docs {@link https://viem.sh/docs/actions/public/verifyMessage.html}
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link VerifyMessageParameters}
+ * @returns Whether or not the signature is valid. {@link VerifyMessageReturnType}
+ */
+export async function verifyMessage<TChain extends Chain | undefined,>(
+  client: Client<Transport, TChain>,
+  { address, message, signature, ...callRequest }: VerifyMessageParameters,
+): Promise<VerifyMessageReturnType> {
+  const hash = hashMessage(message)
+  return verifyHash(client, {
+    address,
+    hash,
+    signature,
+    ...callRequest,
+  })
+}