viem 0.0.0-w-20230816185709 → 0.0.0-w-20230818182440

package/src/actions/public/multicall.ts

@@ -7,20 +7,14 @@ 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,
-  ContractParameters,
-} from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type {
+  MulticallContract,
   MulticallContracts,
   MulticallResults,
 } from '../../types/multicall.js'
 import { decodeFunctionResult } from '../../utils/abi/decodeFunctionResult.js'
-import {
-  type EncodeFunctionDataParameters,
-  encodeFunctionData,
-} from '../../utils/abi/encodeFunctionData.js'
+import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
 import { getChainContractAddress } from '../../utils/chain.js'
 import { getContractError } from '../../utils/errors/getContractError.js'
 
@@ -28,23 +22,33 @@ import type { CallParameters } from './call.js'
 import { readContract } from './readContract.js'
 
 export type MulticallParameters<
-  contracts extends readonly ContractParameters[] = readonly ContractParameters[],
+  contracts extends readonly unknown[] = readonly MulticallContract[],
   allowFailure extends boolean = true,
+  options extends {
+    optional?: boolean
+    properties?: Record<string, any>
+  } = {},
 > = Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
   allowFailure?: allowFailure | undefined
-  /**
-   * The maximum size (in bytes) for each calldata chunk. Set to `0` to disable the size limit.
-   * @default 1_024
-   */
   batchSize?: number | undefined
-  contracts: readonly [...MulticallContracts<Narrow<contracts>>]
+  contracts: MulticallContracts<
+    Narrow<contracts>,
+    { mutability: 'pure' | 'view' } & options
+  >
   multicallAddress?: Address | undefined
 }
 
 export type MulticallReturnType<
-  contracts extends readonly ContractParameters[] = readonly ContractParameters[],
+  contracts extends readonly unknown[] = readonly MulticallContract[],
   allowFailure extends boolean = true,
-> = MulticallResults<contracts, allowFailure>
+  options extends {
+    error?: Error
+  } = { error: Error },
+> = MulticallResults<
+  contracts,
+  allowFailure,
+  { mutability: 'pure' | 'view' } & options
+>
 
 /**
  * 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).
@@ -86,7 +90,7 @@ export type MulticallReturnType<
  * // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
  */
 export async function multicall<
-  const contracts extends readonly ContractParameters[],
+  const contracts extends readonly unknown[],
   chain extends Chain | undefined,
   allowFailure extends boolean = true,
 >(
@@ -98,9 +102,9 @@ export async function multicall<
     batchSize: batchSize_,
     blockNumber,
     blockTag,
-    contracts,
     multicallAddress: multicallAddress_,
   } = parameters
+  const contracts = parameters.contracts as MulticallContract[]
 
   const batchSize =
     batchSize_ ??
@@ -132,16 +136,9 @@ export async function multicall<
   let currentChunk = 0
   let currentChunkSize = 0
   for (let i = 0; i < contracts.length; i++) {
-    const { abi, address, args, functionName } = contracts[
-      i
-    ] as ContractFunctionConfig
+    const { abi, address, args, functionName } = contracts[i]
     try {
-      const callData = encodeFunctionData({
-        abi,
-        args,
-        functionName,
-      } as unknown as EncodeFunctionDataParameters)
-
+      const callData = encodeFunctionData({ abi, args, functionName })
       currentChunkSize += callData.length
       if (batchSize > 0 && currentChunkSize > batchSize) {
         currentChunk++
@@ -193,9 +190,7 @@ export async function multicall<
   return results.flat().map(({ returnData, success }, i) => {
     const calls = chunkedCalls.flat()
     const { callData } = calls[i]
-    const { abi, address, functionName, args } = contracts[
-      i
-    ] as ContractFunctionConfig
+    const { abi, address, functionName, args } = contracts[i]
     try {
       if (callData === '0x') throw new AbiDecodingZeroDataError()
       if (!success) throw new RawContractError({ data: returnData })

package/src/clients/decorators/public.ts

@@ -200,7 +200,6 @@ import type { Account } from '../../types/account.js'
 import type { BlockNumber, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
 import type {
-  ContractFunctionConfig,
   MaybeAbiEventName,
   MaybeExtractEventArgsFromAbi,
 } from '../../types/contract.js'
@@ -1133,11 +1132,11 @@ export type PublicActions<
    * // [{ result: 424122n, status: 'success' }, { result: 1000000n, status: 'success' }]
    */
   multicall: <
-    const TContracts extends readonly ContractFunctionConfig[],
-    TAllowFailure extends boolean = true,
+    const contracts extends readonly unknown[],
+    allowFailure extends boolean = true,
   >(
-    args: MulticallParameters<TContracts, TAllowFailure>,
-  ) => Promise<MulticallReturnType<TContracts, TAllowFailure>>
+    args: MulticallParameters<contracts, allowFailure>,
+  ) => Promise<MulticallReturnType<contracts, allowFailure>>
   /**
    * Calls a read-only function on a contract, and returns the response.
    *

package/src/constants/number.ts

@@ -1,98 +1,98 @@
-export const maxInt8 = 2n ** (8n - 1n)
-export const maxInt16 = 2n ** (16n - 1n)
-export const maxInt24 = 2n ** (24n - 1n)
-export const maxInt32 = 2n ** (32n - 1n)
-export const maxInt40 = 2n ** (40n - 1n)
-export const maxInt48 = 2n ** (48n - 1n)
-export const maxInt56 = 2n ** (56n - 1n)
-export const maxInt64 = 2n ** (64n - 1n)
-export const maxInt72 = 2n ** (72n - 1n)
-export const maxInt80 = 2n ** (80n - 1n)
-export const maxInt88 = 2n ** (88n - 1n)
-export const maxInt96 = 2n ** (96n - 1n)
-export const maxInt104 = 2n ** (104n - 1n)
-export const maxInt112 = 2n ** (112n - 1n)
-export const maxInt120 = 2n ** (120n - 1n)
-export const maxInt128 = 2n ** (128n - 1n)
-export const maxInt136 = 2n ** (136n - 1n)
-export const maxInt144 = 2n ** (144n - 1n)
-export const maxInt152 = 2n ** (152n - 1n)
-export const maxInt160 = 2n ** (160n - 1n)
-export const maxInt168 = 2n ** (168n - 1n)
-export const maxInt176 = 2n ** (176n - 1n)
-export const maxInt184 = 2n ** (184n - 1n)
-export const maxInt192 = 2n ** (192n - 1n)
-export const maxInt200 = 2n ** (200n - 1n)
-export const maxInt208 = 2n ** (208n - 1n)
-export const maxInt216 = 2n ** (216n - 1n)
-export const maxInt224 = 2n ** (224n - 1n)
-export const maxInt232 = 2n ** (232n - 1n)
-export const maxInt240 = 2n ** (240n - 1n)
-export const maxInt248 = 2n ** (248n - 1n)
-export const maxInt256 = 2n ** (256n - 1n)
+export const maxInt8 = 2n ** (8n - 1n) - 1n
+export const maxInt16 = 2n ** (16n - 1n) - 1n
+export const maxInt24 = 2n ** (24n - 1n) - 1n
+export const maxInt32 = 2n ** (32n - 1n) - 1n
+export const maxInt40 = 2n ** (40n - 1n) - 1n
+export const maxInt48 = 2n ** (48n - 1n) - 1n
+export const maxInt56 = 2n ** (56n - 1n) - 1n
+export const maxInt64 = 2n ** (64n - 1n) - 1n
+export const maxInt72 = 2n ** (72n - 1n) - 1n
+export const maxInt80 = 2n ** (80n - 1n) - 1n
+export const maxInt88 = 2n ** (88n - 1n) - 1n
+export const maxInt96 = 2n ** (96n - 1n) - 1n
+export const maxInt104 = 2n ** (104n - 1n) - 1n
+export const maxInt112 = 2n ** (112n - 1n) - 1n
+export const maxInt120 = 2n ** (120n - 1n) - 1n
+export const maxInt128 = 2n ** (128n - 1n) - 1n
+export const maxInt136 = 2n ** (136n - 1n) - 1n
+export const maxInt144 = 2n ** (144n - 1n) - 1n
+export const maxInt152 = 2n ** (152n - 1n) - 1n
+export const maxInt160 = 2n ** (160n - 1n) - 1n
+export const maxInt168 = 2n ** (168n - 1n) - 1n
+export const maxInt176 = 2n ** (176n - 1n) - 1n
+export const maxInt184 = 2n ** (184n - 1n) - 1n
+export const maxInt192 = 2n ** (192n - 1n) - 1n
+export const maxInt200 = 2n ** (200n - 1n) - 1n
+export const maxInt208 = 2n ** (208n - 1n) - 1n
+export const maxInt216 = 2n ** (216n - 1n) - 1n
+export const maxInt224 = 2n ** (224n - 1n) - 1n
+export const maxInt232 = 2n ** (232n - 1n) - 1n
+export const maxInt240 = 2n ** (240n - 1n) - 1n
+export const maxInt248 = 2n ** (248n - 1n) - 1n
+export const maxInt256 = 2n ** (256n - 1n) - 1n
 
-export const minInt8 = -(2n ** 8n)
-export const minInt16 = -(2n ** 16n)
-export const minInt24 = -(2n ** 24n)
-export const minInt32 = -(2n ** 32n)
-export const minInt40 = -(2n ** 40n)
-export const minInt48 = -(2n ** 48n)
-export const minInt56 = -(2n ** 56n)
-export const minInt64 = -(2n ** 64n)
-export const minInt72 = -(2n ** 72n)
-export const minInt80 = -(2n ** 80n)
-export const minInt88 = -(2n ** 88n)
-export const minInt96 = -(2n ** 96n)
-export const minInt104 = -(2n ** 104n)
-export const minInt112 = -(2n ** 112n)
-export const minInt120 = -(2n ** 120n)
-export const minInt128 = -(2n ** 128n)
-export const minInt136 = -(2n ** 136n)
-export const minInt144 = -(2n ** 144n)
-export const minInt152 = -(2n ** 152n)
-export const minInt160 = -(2n ** 160n)
-export const minInt168 = -(2n ** 168n)
-export const minInt176 = -(2n ** 176n)
-export const minInt184 = -(2n ** 184n)
-export const minInt192 = -(2n ** 192n)
-export const minInt200 = -(2n ** 200n)
-export const minInt208 = -(2n ** 208n)
-export const minInt216 = -(2n ** 216n)
-export const minInt224 = -(2n ** 224n)
-export const minInt232 = -(2n ** 232n)
-export const minInt240 = -(2n ** 240n)
-export const minInt248 = -(2n ** 248n)
-export const minInt256 = -(2n ** 256n)
+export const minInt8 = -(2n ** (8n - 1n))
+export const minInt16 = -(2n ** (16n - 1n))
+export const minInt24 = -(2n ** (24n - 1n))
+export const minInt32 = -(2n ** (32n - 1n))
+export const minInt40 = -(2n ** (40n - 1n))
+export const minInt48 = -(2n ** (48n - 1n))
+export const minInt56 = -(2n ** (56n - 1n))
+export const minInt64 = -(2n ** (64n - 1n))
+export const minInt72 = -(2n ** (72n - 1n))
+export const minInt80 = -(2n ** (80n - 1n))
+export const minInt88 = -(2n ** (88n - 1n))
+export const minInt96 = -(2n ** (96n - 1n))
+export const minInt104 = -(2n ** (104n - 1n))
+export const minInt112 = -(2n ** (112n - 1n))
+export const minInt120 = -(2n ** (120n - 1n))
+export const minInt128 = -(2n ** (128n - 1n))
+export const minInt136 = -(2n ** (136n - 1n))
+export const minInt144 = -(2n ** (144n - 1n))
+export const minInt152 = -(2n ** (152n - 1n))
+export const minInt160 = -(2n ** (160n - 1n))
+export const minInt168 = -(2n ** (168n - 1n))
+export const minInt176 = -(2n ** (176n - 1n))
+export const minInt184 = -(2n ** (184n - 1n))
+export const minInt192 = -(2n ** (192n - 1n))
+export const minInt200 = -(2n ** (200n - 1n))
+export const minInt208 = -(2n ** (208n - 1n))
+export const minInt216 = -(2n ** (216n - 1n))
+export const minInt224 = -(2n ** (224n - 1n))
+export const minInt232 = -(2n ** (232n - 1n))
+export const minInt240 = -(2n ** (240n - 1n))
+export const minInt248 = -(2n ** (248n - 1n))
+export const minInt256 = -(2n ** (256n - 1n))
 
-export const maxUint8 = 2n ** 8n
-export const maxUint16 = 2n ** 16n
-export const maxUint24 = 2n ** 24n
-export const maxUint32 = 2n ** 32n
-export const maxUint40 = 2n ** 40n
-export const maxUint48 = 2n ** 48n
-export const maxUint56 = 2n ** 56n
-export const maxUint64 = 2n ** 64n
-export const maxUint72 = 2n ** 72n
-export const maxUint80 = 2n ** 80n
-export const maxUint88 = 2n ** 88n
-export const maxUint96 = 2n ** 96n
-export const maxUint104 = 2n ** 104n
-export const maxUint112 = 2n ** 112n
-export const maxUint120 = 2n ** 120n
-export const maxUint128 = 2n ** 128n
-export const maxUint136 = 2n ** 136n
-export const maxUint144 = 2n ** 144n
-export const maxUint152 = 2n ** 152n
-export const maxUint160 = 2n ** 160n
-export const maxUint168 = 2n ** 168n
-export const maxUint176 = 2n ** 176n
-export const maxUint184 = 2n ** 184n
-export const maxUint192 = 2n ** 192n
-export const maxUint200 = 2n ** 200n
-export const maxUint208 = 2n ** 208n
-export const maxUint216 = 2n ** 216n
-export const maxUint224 = 2n ** 224n
-export const maxUint232 = 2n ** 232n
-export const maxUint240 = 2n ** 240n
-export const maxUint248 = 2n ** 248n
-export const maxUint256 = 2n ** 256n
+export const maxUint8 = 2n ** 8n - 1n
+export const maxUint16 = 2n ** 16n - 1n
+export const maxUint24 = 2n ** 24n - 1n
+export const maxUint32 = 2n ** 32n - 1n
+export const maxUint40 = 2n ** 40n - 1n
+export const maxUint48 = 2n ** 48n - 1n
+export const maxUint56 = 2n ** 56n - 1n
+export const maxUint64 = 2n ** 64n - 1n
+export const maxUint72 = 2n ** 72n - 1n
+export const maxUint80 = 2n ** 80n - 1n
+export const maxUint88 = 2n ** 88n - 1n
+export const maxUint96 = 2n ** 96n - 1n
+export const maxUint104 = 2n ** 104n - 1n
+export const maxUint112 = 2n ** 112n - 1n
+export const maxUint120 = 2n ** 120n - 1n
+export const maxUint128 = 2n ** 128n - 1n
+export const maxUint136 = 2n ** 136n - 1n
+export const maxUint144 = 2n ** 144n - 1n
+export const maxUint152 = 2n ** 152n - 1n
+export const maxUint160 = 2n ** 160n - 1n
+export const maxUint168 = 2n ** 168n - 1n
+export const maxUint176 = 2n ** 176n - 1n
+export const maxUint184 = 2n ** 184n - 1n
+export const maxUint192 = 2n ** 192n - 1n
+export const maxUint200 = 2n ** 200n - 1n
+export const maxUint208 = 2n ** 208n - 1n
+export const maxUint216 = 2n ** 216n - 1n
+export const maxUint224 = 2n ** 224n - 1n
+export const maxUint232 = 2n ** 232n - 1n
+export const maxUint240 = 2n ** 240n - 1n
+export const maxUint248 = 2n ** 248n - 1n
+export const maxUint256 = 2n ** 256n - 1n

package/src/index.ts

@@ -638,7 +638,7 @@ export type { Log } from './types/log.js'
 export type {
   MulticallContract,
   MulticallContracts,
-  MulticallResult,
+  MulticallResponse,
   MulticallResults,
 } from './types/multicall.js'
 export type { ParseAccount } from './types/account.js'

package/src/types/contract.ts

@@ -15,6 +15,7 @@ import type {
   ExtractAbiEventNames,
   ExtractAbiFunction,
   ExtractAbiFunctionNames,
+  ResolvedConfig,
 } from 'abitype'
 
 import type { Hex, LogTopic } from './misc.js'
@@ -22,11 +23,112 @@ import type { TransactionRequest } from './transaction.js'
 import type {
   Filter,
   IsNarrowable,
+  IsUnion,
   MaybeRequired,
   NoUndefined,
   Prettify,
+  UnionToTuple,
 } from './utils.js'
 
+export type FunctionName<
+  abi extends Abi = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+> = ExtractAbiFunctionNames<abi, mutability>
+
+export type Args<
+  abi extends Abi = Abi,
+  mutability extends AbiStateMutability = AbiStateMutability,
+  functionName extends ExtractAbiFunctionNames<
+    abi,
+    mutability
+  > = ExtractAbiFunctionNames<abi, mutability>,
+> = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<abi, functionName, mutability>['inputs'],
+  'inputs'
+>
+
+export type Widen<type> =
+  | ([unknown] extends [type] ? unknown : never)
+  | (type extends Function ? type : never)
+  | (type extends ResolvedConfig['BigIntType'] ? bigint : never)
+  | (type extends boolean ? boolean : never)
+  | (type extends ResolvedConfig['IntType'] ? number : never)
+  | (type extends string
+      ? type extends ResolvedConfig['AddressType']
+        ? ResolvedConfig['AddressType']
+        : type extends ResolvedConfig['BytesType']['inputs']
+        ? ResolvedConfig['BytesType']
+        : string
+      : never)
+  | (type extends readonly [] ? readonly [] : never)
+  | (type extends Record<string, unknown>
+      ? { [K in keyof type]: Widen<type[K]> }
+      : never)
+  | (type extends { length: number }
+      ? {
+          [K in keyof type]: Widen<type[K]>
+        } extends infer Val extends readonly unknown[]
+        ? readonly [...Val]
+        : never
+      : never)
+
+export type ExtractAbiFunctionForArgs<
+  abi extends Abi,
+  mutability extends AbiStateMutability,
+  functionName extends FunctionName<abi, mutability>,
+  args extends Args<abi, mutability, functionName>,
+> = ExtractAbiFunction<
+  abi,
+  functionName,
+  mutability
+> extends infer abiFunction extends AbiFunction
+  ? IsUnion<abiFunction> extends true // narrow overloads using `args` by converting to tuple and filtering out overloads that don't match
+    ? UnionToTuple<abiFunction> extends infer abiFunctions extends readonly AbiFunction[]
+      ? {
+          [k in keyof abiFunctions]: args extends AbiParametersToPrimitiveTypes<
+            abiFunctions[k]['inputs'],
+            'inputs'
+          >
+            ? abiFunctions[k]
+            : never
+        }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+      : never
+    : abiFunction
+  : never
+
+export type ContractFunctionReturnType<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends {
+  abi: infer abi extends Abi
+  functionName?: infer functionName extends string
+  args?: infer args
+}
+  ? Abi extends abi
+    ? unknown
+    : AbiParametersToPrimitiveTypes<
+        ExtractAbiFunctionForArgs<
+          abi,
+          mutability,
+          functionName,
+          // fallback to `readonly []` if `args` is not defined (e.g. not required `"inputs": []`)
+          (
+            readonly [] extends args
+              ? readonly []
+              : args
+          ) extends infer args2 extends Args<abi, mutability, functionName>
+            ? args2
+            : never
+        >['outputs']
+      > extends infer types
+    ? types extends readonly []
+      ? void
+      : types extends readonly [infer type]
+      ? type
+      : types
+    : never
+  : unknown
+
 export type AbiItem = Abi[number]
 
 export type EventDefinition = `${string}(${string})`