viem 0.0.0-main.20240101T200530 → 0.0.0-main.20240103T193934

package/types/multicall.ts

@@ -1,116 +1,180 @@
-import type { Abi, ExtractAbiFunctionNames } from 'abitype'
+import type { Abi, AbiStateMutability } from 'abitype'
 
 import type {
-  ContractFunctionConfig,
-  ContractFunctionResult,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
 } from './contract.js'
-
-type MAXIMUM_DEPTH = 20
-
-export type MulticallContract<
-  TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
-  TFunctionName extends ExtractAbiFunctionNames<
-    TAbi extends Abi ? TAbi : Abi,
-    'pure' | 'view'
-  > = string,
-> = { abi: TAbi; functionName: TFunctionName }
+import type { MaybePartial, Prettify } from './utils.js'
 
 export type MulticallContracts<
-  TContracts extends readonly MulticallContract[],
-  TProperties extends Record<string, any> = object,
-  Result extends any[] = [],
-  Depth extends readonly number[] = [],
-> = Depth['length'] extends MAXIMUM_DEPTH
-  ? (ContractFunctionConfig & TProperties)[]
-  : TContracts extends []
-    ? []
-    : TContracts extends [infer Head extends MulticallContract]
-      ? [
-          ...Result,
-          ContractFunctionConfig<Head['abi'], Head['functionName']> &
-            TProperties,
-        ]
-      : TContracts extends [
-            infer Head extends MulticallContract,
-            ...infer Tail extends readonly MulticallContract[],
+  contracts extends readonly unknown[],
+  options extends {
+    mutability: AbiStateMutability
+    optional?: boolean
+    properties?: Record<string, any>
+  } = { mutability: AbiStateMutability },
+  ///
+  result extends readonly any[] = [],
+> = contracts extends readonly [] // no contracts, return empty
+  ? readonly []
+  : contracts extends readonly [infer contract] // one contract left before returning `result`
+    ? readonly [
+        ...result,
+        MaybePartial<
+          Prettify<
+            GetMulticallContractParameters<contract, options['mutability']> &
+              options['properties']
+          >,
+          options['optional']
+        >,
+      ]
+    : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
+      ? MulticallContracts<
+          [...rest],
+          options,
+          [
+            ...result,
+            MaybePartial<
+              Prettify<
+                GetMulticallContractParameters<
+                  contract,
+                  options['mutability']
+                > &
+                  options['properties']
+              >,
+              options['optional']
+            >,
+          ]
+        >
+      : readonly unknown[] extends contracts
+        ? contracts
+        : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+          // use this to infer the param types in the case of Array.map() argument
+          contracts extends readonly (infer contract extends
+              ContractFunctionParameters)[]
+          ? readonly MaybePartial<
+              Prettify<contract & options['properties']>,
+              options['optional']
+            >[]
+          : // Fallback
+            readonly MaybePartial<
+              Prettify<ContractFunctionParameters & options['properties']>,
+              options['optional']
+            >[]
+
+export type MulticallResults<
+  contracts extends readonly unknown[] = readonly ContractFunctionParameters[],
+  allowFailure extends boolean = true,
+  options extends {
+    error?: Error
+    mutability: AbiStateMutability
+  } = { error: Error; mutability: AbiStateMutability },
+  ///
+  result extends any[] = [],
+> = contracts extends readonly [] // no contracts, return empty
+  ? readonly []
+  : contracts extends readonly [infer contract] // one contract left before returning `result`
+    ? [
+        ...result,
+        MulticallResponse<
+          GetMulticallContractReturnType<contract, options['mutability']>,
+          options['error'],
+          allowFailure
+        >,
+      ]
+    : contracts extends readonly [infer contract, ...infer rest] // grab first contract and recurse through `rest`
+      ? MulticallResults<
+          [...rest],
+          allowFailure,
+          options,
+          [
+            ...result,
+            MulticallResponse<
+              GetMulticallContractReturnType<contract, options['mutability']>,
+              options['error'],
+              allowFailure
+            >,
           ]
-        ? MulticallContracts<
-            [...Tail],
-            TProperties,
-            [
-              ...Result,
-              ContractFunctionConfig<Head['abi'], Head['functionName']> &
-                TProperties,
-            ],
-            [...Depth, 1]
-          >
-        : unknown[] extends TContracts
-          ? TContracts
-          : // If `TContracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
-            // use this to infer the param types in the case of Array.map() argument
-            TContracts extends ContractFunctionConfig<
-                infer TAbi,
-                infer TFunctionName
-              >[]
-            ? (ContractFunctionConfig<TAbi, TFunctionName> & TProperties)[]
-            : (ContractFunctionConfig & TProperties)[]
+        >
+      : readonly unknown[] extends contracts
+        ? MulticallResponse<unknown, options['error'], allowFailure>[]
+        : // If `contracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+          // use this to infer the param types in the case of Array.map() argument
+          contracts extends readonly (infer contract extends
+              ContractFunctionParameters)[]
+          ? MulticallResponse<
+              GetMulticallContractReturnType<contract, options['mutability']>,
+              options['error'],
+              allowFailure
+            >[]
+          : // Fallback
+            MulticallResponse<unknown, options['error'], allowFailure>[]
 
-export type MulticallResult<
-  Result,
-  TAllowFailure extends boolean = true,
-> = TAllowFailure extends true
+export type MulticallResponse<
+  result = unknown,
+  error = unknown,
+  allowFailure extends boolean = true,
+> = allowFailure extends true
   ?
+      | { error?: undefined; result: result; status: 'success' }
       | {
-          error?: undefined
-          result: Result
-          status: 'success'
-        }
-      | {
-          error: Error
+          error: unknown extends error ? Error : error
           result?: undefined
           status: 'failure'
         }
-  : Result
+  : result
 
-export type MulticallResults<
-  TContracts extends readonly MulticallContract[],
-  TAllowFailure extends boolean = true,
-  Result extends any[] = [],
-  Depth extends readonly number[] = [],
-> = Depth['length'] extends MAXIMUM_DEPTH
-  ? MulticallResult<ContractFunctionResult, TAllowFailure>[]
-  : TContracts extends []
-    ? []
-    : TContracts extends [infer Head extends MulticallContract]
-      ? [
-          ...Result,
-          MulticallResult<
-            ContractFunctionResult<Head['abi'], Head['functionName']>,
-            TAllowFailure
-          >,
-        ]
-      : TContracts extends [
-            infer Head extends MulticallContract,
-            ...infer Tail extends readonly MulticallContract[],
-          ]
-        ? MulticallResults<
-            [...Tail],
-            TAllowFailure,
-            [
-              ...Result,
-              MulticallResult<
-                ContractFunctionResult<Head['abi'], Head['functionName']>,
-                TAllowFailure
-              >,
-            ],
-            [...Depth, 1]
-          >
-        : TContracts extends ContractFunctionConfig<
-              infer TAbi,
-              infer TFunctionName
-            >[]
-          ? MulticallResult<
-              ContractFunctionResult<TAbi, TFunctionName>,
-              TAllowFailure
-            >[]
-          : MulticallResult<ContractFunctionResult, TAllowFailure>[]
+// infer contract parameters from `unknown`
+type GetMulticallContractParameters<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
+  ? // 1a. Check if `functionName` is valid for `abi`
+    contract extends {
+      functionName: infer functionName extends ContractFunctionName<
+        abi,
+        mutability
+      >
+    }
+    ? // 1aa. Check if `args` is valid for `abi` and `functionName`
+      contract extends {
+        args: infer args extends ContractFunctionArgs<
+          abi,
+          mutability,
+          functionName
+        >
+      }
+      ? ContractFunctionParameters<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionParameters<abi, mutability, functionName> // invalid `args`
+    : // 1b. `functionName` is invalid, check if `abi` is declared as `Abi`
+      Abi extends abi
+      ? ContractFunctionParameters // `abi` declared as `Abi`, unable to infer types further
+      : // `abi` is const-asserted or defined inline, infer types for `functionName` and `args`
+        ContractFunctionParameters<abi, mutability>
+  : ContractFunctionParameters<readonly unknown[]> // invalid `contract['abi']`, set to `readonly unknown[]`
+
+type GetMulticallContractReturnType<
+  contract,
+  mutability extends AbiStateMutability,
+> = contract extends { abi: infer abi extends Abi } // 1. Check if `abi` is const-asserted or defined inline
+  ? // Check if `functionName` is valid for `abi`
+    contract extends {
+      functionName: infer functionName extends ContractFunctionName<
+        abi,
+        mutability
+      >
+    }
+    ? // Check if `args` is valid for `abi` and `functionName`
+      contract extends {
+        args: infer args extends ContractFunctionArgs<
+          abi,
+          mutability,
+          functionName
+        >
+      }
+      ? ContractFunctionReturnType<abi, mutability, functionName, args> // `args` valid, pass through
+      : ContractFunctionReturnType<abi, mutability, functionName> // invalid `args`
+    : ContractFunctionReturnType<abi, mutability> // Invalid `functionName`
+  : ContractFunctionReturnType // invalid `contract['abi']` (not const-asserted or declared as `Abi`)

package/types/rpc.ts

@@ -46,18 +46,14 @@ export type RpcTransactionRequest =
   | TransactionRequestLegacy<Quantity, Index, '0x0'>
   | TransactionRequestEIP2930<Quantity, Index, '0x1'>
   | TransactionRequestEIP1559<Quantity, Index, '0x2'>
-export type RpcTransaction<
-  TPending extends boolean = boolean,
-  // `yParity` is optional on the RPC type as some nodes do not return it
-  // for 1559 & 2930 transactions (they should!).
-  _optionalProperties extends 'yParity' = 'yParity',
-  _excludedProperties extends string = 'typeHex',
-> = UnionOmit<
+export type RpcTransaction<TPending extends boolean = boolean> = UnionOmit<
   UnionPartialBy<
     | TransactionLegacy<Quantity, Index, TPending, '0x0'>
     | TransactionEIP2930<Quantity, Index, TPending, '0x1'>
     | TransactionEIP1559<Quantity, Index, TPending, '0x2'>,
-    _optionalProperties
+    // `yParity` is optional on the RPC type as some nodes do not return it
+    // for 1559 & 2930 transactions (they should!).
+    'yParity'
   >,
-  _excludedProperties
+  'typeHex'
 >

package/types/transport.ts

@@ -2,3 +2,29 @@ import type { Transport } from '../clients/transports/createTransport.js'
 
 export type GetTransportConfig<TTransport extends Transport> =
   ReturnType<TTransport>['config']
+
+export type GetPollOptions<transport extends Transport> =
+  | (GetTransportConfig<transport>['type'] extends 'webSocket'
+      ? {
+          batch?: undefined
+          /**
+           * Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`.
+           * @default false
+           */
+          poll?: false | undefined
+          pollingInterval?: undefined
+        }
+      : never)
+  | {
+      poll?: true | undefined
+      /**
+       * Whether or not the transaction hashes should be batched on each invocation.
+       * @default true
+       */
+      batch?: boolean | undefined
+      /**
+       * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+       * @default client.pollingInterval
+       */
+      pollingInterval?: number | undefined
+    }

package/types/typedData.ts

@@ -4,77 +4,57 @@ import type {
   TypedDataToPrimitiveTypes,
 } from 'abitype'
 
-export type TypedDataDefinition<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = {
-  primaryType: GetTypedDataPrimaryType<TTypedData, TPrimaryType>
-} & GetTypedDataMessage<TTypedData, TPrimaryType> &
-  GetTypedDataTypes<TTypedData, TPrimaryType> &
-  GetTypedDataDomain<TTypedData, TPrimaryType>
-
-export type GetTypedDataDomain<
-  TTypedData extends TypedData | { [key_1: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
-    ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key_2: string]: any },
-  TDomain = TSchema extends { EIP712Domain: infer Domain }
-    ? Domain
-    : TypedDataDomain,
-> = TPrimaryType extends 'EIP712Domain'
-  ? {
-      domain: TDomain
-    }
-  : {
-      domain?: TDomain
-    }
+import type { Prettify } from './utils.js'
 
-export type GetTypedDataMessage<
-  TTypedData extends TypedData | { [key_1: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-  TSchema = TTypedData extends TypedData
-    ? TypedDataToPrimitiveTypes<TTypedData>
-    : { [key_2: string]: any },
-  TMessage = TSchema[TPrimaryType extends keyof TSchema
-    ? TPrimaryType
-    : keyof TSchema],
-> = TPrimaryType extends 'EIP712Domain'
-  ? {}
-  : { [key_3: string]: any } extends TMessage // Check if we were able to infer the shape of typed data
-    ? {
-        /**
-         * Data to sign
-         *
-         * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link types} for type inference.
-         */
-        message: { [key_4: string]: unknown }
-      }
-    : {
-        /** Data to sign */
-        message: TMessage
-      }
+export type TypedDataDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = primaryType extends 'EIP712Domain'
+  ? EIP712DomainDefinition<typedData, primaryType>
+  : MessageDefinition<typedData, primaryType, primaryTypes>
 
-export type GetTypedDataPrimaryType<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TTypedData extends TypedData
-  ? keyof TTypedData extends infer AbiFunctionNames
-    ?
-        | AbiFunctionNames
-        | (TPrimaryType extends AbiFunctionNames ? TPrimaryType : never)
-        | (TypedData extends TTypedData ? string : never)
-        | 'EIP712Domain'
-    : never
-  : TPrimaryType
+type MessageDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+  schema extends Record<string, unknown> = typedData extends TypedData
+    ? TypedDataToPrimitiveTypes<typedData>
+    : Record<string, unknown>,
+  message = schema[primaryType extends keyof schema
+    ? primaryType
+    : keyof schema],
+> = {
+  types: typedData
+} & {
+  primaryType:
+    | primaryTypes // show all values
+    | (primaryType extends primaryTypes ? primaryType : never) // infer value
+  domain?:
+    | (schema extends { EIP712Domain: infer domain }
+        ? domain
+        : Prettify<TypedDataDomain>)
+    | undefined
+  message: { [_: string]: any } extends message // Check if message was inferred
+    ? Record<string, unknown>
+    : message
+}
 
-export type GetTypedDataTypes<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
-> = TPrimaryType extends 'EIP712Domain'
-  ? {
-      types?: TTypedData
-    }
-  : {
-      types: TTypedData
-    }
+type EIP712DomainDefinition<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends 'EIP712Domain' = 'EIP712Domain',
+  ///
+  schema extends Record<string, unknown> = typedData extends TypedData
+    ? TypedDataToPrimitiveTypes<typedData>
+    : Record<string, unknown>,
+> = {
+  types?: typedData | undefined
+} & {
+  primaryType: 'EIP712Domain' | primaryType
+  domain: schema extends { EIP712Domain: infer domain }
+    ? domain
+    : Prettify<TypedDataDomain>
+  message?: never
+}