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

package/actions/public/simulateContract.ts

@@ -1,4 +1,4 @@
-import type { Abi } from 'abitype'
+import type { Abi, Address } from 'abitype'
 
 import {
   type ParseAccountErrorType,
@@ -7,22 +7,25 @@ import {
 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 { ErrorType } from '../../errors/utils.js'
+import type { Account, ParseAccount } from '../../types/account.js'
+import type { Chain, DeriveChain } from '../../types/chain.js'
 import type {
-  ContractFunctionConfig,
-  ContractFunctionResult,
+  ContractFunctionArgs,
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ContractFunctionReturnType,
+  ExtractAbiFunctionForArgs,
   GetValue,
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import type { UnionOmit } from '../../types/utils.js'
+import type { Prettify, UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import {
   type DecodeFunctionResultErrorType,
-  type DecodeFunctionResultParameters,
   decodeFunctionResult,
 } from '../../utils/abi/decodeFunctionResult.js'
 import {
   type EncodeFunctionDataErrorType,
-  type EncodeFunctionDataParameters,
   encodeFunctionData,
 } from '../../utils/abi/encodeFunctionData.js'
 import {
@@ -31,52 +34,112 @@ import {
 } from '../../utils/errors/getContractError.js'
 import type { WriteContractParameters } from '../wallet/writeContract.js'
 
-import type { ErrorType } from '../../errors/utils.js'
 import { getAction } from '../../utils/getAction.js'
 import { type CallErrorType, type CallParameters, call } from './call.js'
 
 export type SimulateContractParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = any,
-  TChain extends Chain | undefined = Chain | undefined,
-  TChainOverride extends Chain | undefined = Chain | undefined,
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'nonpayable' | 'payable'
+  > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | Address | undefined = undefined,
+  ///
+  derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = {
-  chain?: TChainOverride
+  account?: accountOverride
+  chain?: chainOverride
   /** 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'> &
+} & ContractFunctionParameters<
+  abi,
+  'nonpayable' | 'payable',
+  functionName,
+  args
+> &
   UnionOmit<
-    CallParameters<TChainOverride extends Chain ? TChainOverride : TChain>,
-    'batch' | 'to' | 'data' | 'value'
+    CallParameters<derivedChain>,
+    'account' | 'batch' | 'to' | 'data' | 'value'
   > &
   GetValue<
-    TAbi,
-    TFunctionName,
-    CallParameters<TChain> extends CallParameters
-      ? CallParameters<TChain>['value']
+    abi,
+    functionName,
+    CallParameters<derivedChain> extends CallParameters
+      ? CallParameters<derivedChain>['value']
       : CallParameters['value']
   >
 
 export type SimulateContractReturnType<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TFunctionName extends string = string,
-  TChain extends Chain | undefined = Chain | undefined,
-  TChainOverride extends Chain | undefined = Chain | undefined,
-> = {
-  result: ContractFunctionResult<TAbi, TFunctionName>
-  request: UnionOmit<
-    WriteContractParameters<
-      TAbi,
-      TFunctionName,
-      TChain,
-      undefined,
-      TChainOverride
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends ContractFunctionName<
+    abi,
+    'nonpayable' | 'payable'
+  > = ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  > = ContractFunctionArgs<abi, 'nonpayable' | 'payable', functionName>,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  accountOverride extends Account | Address | undefined =
+    | Account
+    | Address
+    | undefined,
+  ///
+  minimizedAbi extends Abi = readonly [
+    ExtractAbiFunctionForArgs<
+      abi extends Abi ? abi : Abi,
+      'nonpayable' | 'payable',
+      functionName,
+      args
     >,
-    'chain' | 'functionName'
-  > & {
-    chain: TChainOverride
-    functionName: TFunctionName
-  } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>
+  ],
+  resolvedAccount extends Account | undefined = accountOverride extends
+    | Account
+    | Address
+    ? ParseAccount<accountOverride>
+    : account,
+> = {
+  result: ContractFunctionReturnType<
+    minimizedAbi,
+    'nonpayable' | 'payable',
+    functionName,
+    args
+  >
+  request: Prettify<
+    UnionEvaluate<
+      UnionOmit<
+        WriteContractParameters<
+          minimizedAbi,
+          functionName,
+          args,
+          chain,
+          undefined,
+          chainOverride
+        >,
+        'account' | 'abi' | 'args' | 'chain' | 'functionName'
+      >
+    > &
+      ContractFunctionParameters<
+        minimizedAbi,
+        'nonpayable' | 'payable',
+        functionName,
+        args
+      > & {
+        chain: DeriveChain<chain, chainOverride>
+      } & (resolvedAccount extends Account
+        ? { account: resolvedAccount }
+        : { account?: undefined })
+  >
 }
 
 export type SimulateContractErrorType =
@@ -117,31 +180,45 @@ export type SimulateContractErrorType =
  * })
  */
 export async function simulateContract<
-  TChain extends Chain | undefined,
-  const TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
-  TChainOverride extends Chain | undefined = undefined,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'nonpayable' | 'payable'>,
+  args extends ContractFunctionArgs<
+    abi,
+    'nonpayable' | 'payable',
+    functionName
+  >,
+  chainOverride extends Chain | undefined = undefined,
+  accountOverride extends Account | Address | undefined = undefined,
 >(
-  client: Client<Transport, TChain>,
-  {
+  client: Client<Transport, chain, account>,
+  parameters: SimulateContractParameters<
     abi,
-    address,
-    args,
-    dataSuffix,
     functionName,
-    ...callRequest
-  }: SimulateContractParameters<TAbi, TFunctionName, TChain, TChainOverride>,
+    args,
+    chain,
+    chainOverride,
+    accountOverride
+  >,
 ): Promise<
-  SimulateContractReturnType<TAbi, TFunctionName, TChain, TChainOverride>
+  SimulateContractReturnType<
+    abi,
+    functionName,
+    args,
+    chain,
+    account,
+    chainOverride,
+    accountOverride
+  >
 > {
+  const { abi, address, args, dataSuffix, functionName, ...callRequest } =
+    parameters as SimulateContractParameters
+
   const account = callRequest.account
     ? parseAccount(callRequest.account)
-    : undefined
-  const calldata = encodeFunctionData({
-    abi,
-    args,
-    functionName,
-  } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
+    : client.account
+  const calldata = encodeFunctionData({ abi, args, functionName })
   try {
     const { data } = await getAction(
       client,
@@ -152,32 +229,41 @@ export async function simulateContract<
       data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
       to: address,
       ...callRequest,
-    } as unknown as CallParameters<TChain>)
+      account,
+    })
     const result = decodeFunctionResult({
       abi,
       args,
       functionName,
       data: data || '0x',
-    } as DecodeFunctionResultParameters)
+    })
+    const minimizedAbi = abi.filter(
+      (abiItem) =>
+        'name' in abiItem && abiItem.name === parameters.functionName,
+    )
     return {
       result,
       request: {
-        abi,
+        abi: minimizedAbi,
         address,
         args,
         dataSuffix,
         functionName,
         ...callRequest,
+        account,
       },
     } as unknown as SimulateContractReturnType<
-      TAbi,
-      TFunctionName,
-      TChain,
-      TChainOverride
+      abi,
+      functionName,
+      args,
+      chain,
+      account,
+      chainOverride,
+      accountOverride
     >
-  } catch (err) {
-    throw getContractError(err as BaseError, {
-      abi: abi as Abi,
+  } catch (error) {
+    throw getContractError(error as BaseError, {
+      abi,
       address,
       args,
       docsPath: '/docs/contract/simulateContract',

package/actions/public/verifyTypedData.ts

@@ -17,10 +17,10 @@ import {
 } from './verifyHash.js'
 
 export type VerifyTypedDataParameters<
-  TTypedData extends TypedData | { [key: string]: unknown } = TypedData,
-  TPrimaryType extends string = string,
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
 > = Omit<VerifyHashParameters, 'hash'> &
-  TypedDataDefinition<TTypedData, TPrimaryType> & {
+  TypedDataDefinition<typedData, primaryType> & {
     /** The address to verify the typed data for. */
     address: Address
     /** The signature to verify */
@@ -43,9 +43,15 @@ export type VerifyTypedDataErrorType =
  * @param parameters - {@link VerifyTypedDataParameters}
  * @returns Whether or not the signature is valid. {@link VerifyTypedDataReturnType}
  */
-export async function verifyTypedData<TChain extends Chain | undefined>(
-  client: Client<Transport, TChain>,
-  {
+export async function verifyTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  chain extends Chain | undefined,
+>(
+  client: Client<Transport, chain>,
+  parameters: VerifyTypedDataParameters<typedData, primaryType>,
+): Promise<VerifyTypedDataReturnType> {
+  const {
     address,
     signature,
     message,
@@ -53,8 +59,7 @@ export async function verifyTypedData<TChain extends Chain | undefined>(
     types,
     domain,
     ...callRequest
-  }: VerifyTypedDataParameters,
-): Promise<VerifyTypedDataReturnType> {
+  } = parameters as VerifyTypedDataParameters
   const hash = hashTypedData({ message, primaryType, types, domain })
   return verifyHash(client, {
     address,

package/actions/public/waitForTransactionReceipt.ts

@@ -221,10 +221,14 @@ export async function waitForTransactionReceipt<
               // If the receipt is not found, the transaction will be pending.
               // We need to check if it has potentially been replaced.
               if (
-                transaction &&
-                (err instanceof TransactionNotFoundError ||
-                  err instanceof TransactionReceiptNotFoundError)
+                err instanceof TransactionNotFoundError ||
+                err instanceof TransactionReceiptNotFoundError
               ) {
+                if (!transaction) {
+                  retrying = false
+                  return
+                }
+
                 try {
                   replacedTransaction = transaction
 
@@ -296,7 +300,7 @@ export async function waitForTransactionReceipt<
                   done(() => {
                     emit.onReplaced?.({
                       reason,
-                      replacedTransaction: replacedTransaction!,
+                      replacedTransaction: replacedTransaction! as any,
                       transaction: replacementTransaction,
                       transactionReceipt: receipt,
                     })

package/actions/public/watchBlockNumber.ts

@@ -20,15 +20,6 @@ export type OnBlockNumberFn = (
   prevBlockNumber: OnBlockNumberParameter | undefined,
 ) => void
 
-export type PollOptions = {
-  /** Whether or not to emit the missed block numbers to the callback. */
-  emitMissed?: boolean
-  /** Whether or not to emit the latest block number to the callback when the subscription opens. */
-  emitOnBegin?: boolean
-  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
-  pollingInterval?: number
-}
-
 export type WatchBlockNumberParameters<
   TTransport extends Transport = Transport,
 > = {
@@ -36,17 +27,26 @@ export type WatchBlockNumberParameters<
   onBlockNumber: OnBlockNumberFn
   /** The callback to call when an error occurred when trying to get for a new block. */
   onError?: (error: Error) => void
-} & (GetTransportConfig<TTransport>['type'] extends 'webSocket'
-  ?
-      | {
-          emitMissed?: never
-          emitOnBegin?: never
+} & (
+  | (GetTransportConfig<TTransport>['type'] extends 'webSocket'
+      ? {
+          emitMissed?: undefined
+          emitOnBegin?: undefined
           /** Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`. */
-          poll?: false
-          pollingInterval?: never
+          poll?: false | undefined
+          pollingInterval?: undefined
         }
-      | (PollOptions & { poll: true })
-  : PollOptions & { poll?: true })
+      : never)
+  | {
+      /** Whether or not to emit the missed block numbers to the callback. */
+      emitMissed?: boolean | undefined
+      /** Whether or not to emit the latest block number to the callback when the subscription opens. */
+      emitOnBegin?: boolean | undefined
+      poll?: true | undefined
+      /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+      pollingInterval?: number | undefined
+    }
+)
 
 export type WatchBlockNumberReturnType = () => void
 

package/actions/public/watchBlocks.ts

@@ -29,22 +29,6 @@ export type OnBlock<
     | undefined,
 ) => void
 
-type PollOptions<
-  TIncludeTransactions extends boolean = false,
-  TBlockTag extends BlockTag = 'latest',
-> = {
-  /** The block tag. Defaults to "latest". */
-  blockTag?: TBlockTag | BlockTag
-  /** Whether or not to emit the missed blocks to the callback. */
-  emitMissed?: boolean
-  /** Whether or not to emit the block to the callback when the subscription opens. */
-  emitOnBegin?: boolean
-  /** Whether or not to include transaction data in the response. */
-  includeTransactions?: TIncludeTransactions
-  /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
-  pollingInterval?: number
-}
-
 export type WatchBlocksParameters<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain,
@@ -54,20 +38,33 @@ export type WatchBlocksParameters<
   /** The callback to call when a new block is received. */
   onBlock: OnBlock<TChain, TIncludeTransactions, TBlockTag>
   /** The callback to call when an error occurred when trying to get for a new block. */
-  onError?: (error: Error) => void
-} & (GetTransportConfig<TTransport>['type'] extends 'webSocket'
-  ?
-      | {
-          blockTag?: never
-          emitMissed?: never
-          emitOnBegin?: never
-          includeTransactions?: never
+  onError?: ((error: Error) => void) | undefined
+} & (
+  | (GetTransportConfig<TTransport>['type'] extends 'webSocket'
+      ? {
+          blockTag?: undefined
+          emitMissed?: undefined
+          emitOnBegin?: undefined
+          includeTransactions?: undefined
           /** Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`. */
-          poll?: false
-          pollingInterval?: never
+          poll?: false | undefined
+          pollingInterval?: undefined
         }
-      | (PollOptions<TIncludeTransactions, TBlockTag> & { poll?: true })
-  : PollOptions<TIncludeTransactions, TBlockTag> & { poll?: true })
+      : never)
+  | {
+      /** The block tag. Defaults to "latest". */
+      blockTag?: TBlockTag | BlockTag | undefined
+      /** Whether or not to emit the missed blocks to the callback. */
+      emitMissed?: boolean | undefined
+      /** Whether or not to emit the block to the callback when the subscription opens. */
+      emitOnBegin?: boolean | undefined
+      /** Whether or not to include transaction data in the response. */
+      includeTransactions?: TIncludeTransactions | undefined
+      poll?: true | undefined
+      /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
+      pollingInterval?: number | undefined
+    }
+)
 
 export type WatchBlocksReturnType = () => void