Update types again

packages/core/src/hooks/index.ts

@@ -1,7 +1,6 @@
 export * from './useBlockMeta'
 export * from './useBlockNumber'
 export * from './useBlockNumbers'
-export * from './useChainCalls'
 export * from './useConfig'
 export * from './useDebounce'
 export * from './useDebouncePair'

packages/core/src/hooks/useCallResilency.test.tsx

@@ -133,8 +133,8 @@ describe.skip('useCall Resilency tests', () => {
               },
               pollingInterval: 200,
               multicallAddresses: {
-                [1337]: multicall0.address,
-                [31337]: multicall1.address,
+                [1337]: multicall0.target as string,
+                [31337]: multicall1.target as string,
               },
             }
           })

packages/core/src/hooks/useContractFunction.test.tsx

@@ -199,7 +199,7 @@ describe('useContractFunction', () => {
 
   it('transfer amount with just mnemonic phrase', async () => {
     const { result, waitForCurrent, waitForNextUpdate } = await renderDAppHook(
-      () => useContractFunction(token, 'transfer', { chainId: 1, mnemonicPhrase: wallet1.mnemonic?.phrase }),
+      () => useContractFunction(token, 'transfer', { chainId: 1, mnemonicPhrase: wallet1.mnemonic?.phrase as string }),
       {
         config,
       }

packages/core/src/hooks/useContractFunction.ts

@@ -99,7 +99,7 @@ export function useContractFunction<T extends BaseContract, FN extends ContractF
             ? opts.gasLimit
             : (await estimateContractFunctionGasLimit(
                 contractWithSigner,
-                functionName,
+                functionName as string,
                 args,
                 gasLimitBufferPercentage
               )) ?? null
@@ -110,11 +110,11 @@ export function useContractFunction<T extends BaseContract, FN extends ContractF
         }
         const modifiedArgs = hasOpts ? args.slice(0, args.length - 1) : args
 
-        const receipt = await promiseTransaction(contractWithSigner[functionName](...modifiedArgs, modifiedOpts), {
+        const receipt = await promiseTransaction(contractWithSigner[functionName as string](...modifiedArgs, modifiedOpts), {
           safeTransaction: {
-            to: contract.target,
+            to: contract.target as string,
             value: opts?.value,
-            data: contract.interface.encodeFunctionData(functionName, modifiedArgs),
+            data: contract.interface.encodeFunctionData(functionName as string, modifiedArgs),
             safeTxGas: gasLimit ?? undefined,
           },
         })
@@ -130,7 +130,7 @@ export function useContractFunction<T extends BaseContract, FN extends ContractF
           }, [] as LogDescription[])
           setEvents(events)
         }
-        return receipt
+        return receipt ?? undefined
       }
     },
     [contract, functionName, options, provider, library, gasLimitBufferPercentage, promiseTransaction]

packages/core/src/hooks/useGnosisSafeContract.ts

@@ -1,5 +1,5 @@
 import { useEffect, useRef } from 'react'
-import type { Signer, providers } from 'ethers'
+import type { Provider, Signer } from 'ethers'
 import { Contract } from 'ethers'
 import { GNOSIS_SAFE_ABI } from '../helpers/gnosisSafeUtils'
 
@@ -8,7 +8,7 @@ import { GNOSIS_SAFE_ABI } from '../helpers/gnosisSafeUtils'
  */
 export const useGnosisSafeContract = (
   account: string | undefined,
-  provider: Signer | providers.Provider | undefined
+  provider: Signer | Provider | undefined
 ) => {
   const safeContract = useRef<Contract | undefined>(undefined)
 

packages/core/src/hooks/useLogs.ts

@@ -1,6 +1,6 @@
 import { useMemo } from 'react'
-import { Contract } from 'ethers'
-import { ContractEventNames, Falsy, EventParams, TypedContract } from '../model/types'
+import { BaseContract } from 'ethers'
+import { ContractEventNames, Falsy, EventParams } from '../model/types'
 import { useRawLogs } from './useRawLogs'
 import { decodeLogs, encodeFilterData } from '../helpers'
 import { LogQueryParams } from '../constants/type/QueryParams'
@@ -18,7 +18,7 @@ import { LogQueryParams } from '../constants/type/QueryParams'
  * }
  */
 export interface TypedFilter<
-  T extends TypedContract = Contract,
+  T extends BaseContract = BaseContract,
   EN extends ContractEventNames<T> = ContractEventNames<T>
 > {
   contract: T
@@ -35,7 +35,7 @@ export interface TypedFilter<
  * @returns an array of decoded logs (see {@link LogsResult})
  * @public
  */
-export function useLogs<T extends Contract = Contract, EN extends ContractEventNames<T> = ContractEventNames<T>>(
+export function useLogs<T extends BaseContract = BaseContract, EN extends ContractEventNames<T> = ContractEventNames<T>>(
   filter: TypedFilter<T, EN> | Falsy,
   queryParams: LogQueryParams = {}
 ) {

packages/core/src/index.ts

@@ -48,8 +48,6 @@ export {
   useCalls,
   useConfig,
   useUpdateConfig,
-  useChainCall,
-  useChainCalls,
   useChainMeta,
   useChainState,
   useContractFunction,

packages/core/src/model/types.ts

@@ -3,19 +3,19 @@ import { BaseContract, ContractTransaction } from "ethers"
 
 export type Falsy = false | 0 | '' | null | undefined
 
-type ReplaceNever<T, R = string> = [T] extends [never] ? R : T;
+type ReplaceNever<T, R = any> = [T] extends [never] ? R : T;
 
 export type ContractFunctionNames<T extends BaseContract> = ReplaceNever<keyof { [K in Parameters<T['interface']['getFunction']>[0] as ReturnType<K extends keyof T ? T[K] extends (...args: any) => any ? T[K] : never : never> extends Promise<ContractTransaction> ? K : never]: void }>
 
 export type ContractMethodNames<T extends BaseContract> =  ReplaceNever<keyof { [K in Parameters<T['interface']['getFunction']>[0] as ReturnType<K extends keyof T ? T[K] extends (...args: any) => any ? T[K] : never : never> extends Promise<ContractTransaction> ? never : K]: void }>
 
-export type ContractEventNames<T extends BaseContract> = ReplaceNever<keyof { [K in keyof T['filters']]: void }>
+export type ContractEventNames<T extends BaseContract> = keyof { [K in Exclude<keyof T['filters'], number | symbol>]: void }
 
-export type Params<T extends BaseContract, FN extends ContractFunctionNames<T> | ContractMethodNames<T>> = ReplaceNever<Parameters<FN extends keyof T ? T[FN] extends (...args: any) => any ? T[FN] : never : never>, any[]>
+export type Params<T extends BaseContract, FN extends ContractFunctionNames<T> | ContractMethodNames<T>> = ReplaceNever<Parameters<FN extends keyof T ? T[FN] extends (...args: any) => any ? T[FN] : never : never>>
 
-export type Results<T extends BaseContract, FN extends ContractMethodNames<T>> = ReplaceNever<Awaited<ReturnType<FN extends keyof T ? T[FN] extends (...args: any) => any ? T[FN] : never : never>>, any[]>
+export type Results<T extends BaseContract, FN extends ContractMethodNames<T>> = ReplaceNever<Awaited<ReturnType<FN extends keyof T ? T[FN] extends (...args: any) => any ? T[FN] : never : never>>>
 
-export type EventParams<T extends BaseContract, EN extends ContractEventNames<T>> = ReplaceNever<Parameters<T['filters'][EN]>, any[]>
+export type EventParams<T extends BaseContract, EN extends ContractEventNames<T>> = ReplaceNever<Parameters<T['filters'][EN]>>
 
 export type EventRecord<T extends BaseContract, EN extends ContractEventNames<T>> =  { [P in keyof EventParams<T, EN> as string]: any }