fix: type multicall usage

src/hooks/multicall.ts

@@ -1,4 +1,7 @@
+import { Contract } from '@ethersproject/contracts'
+import { CallState as CallStateBase } from '@uniswap/redux-multicall'
 import { useWeb3React } from '@web3-react/core'
+import { Interface } from 'ethers/lib/utils'
 import useBlockNumber from 'hooks/useBlockNumber'
 import multicall from 'state/multicall'
 
@@ -7,33 +10,53 @@ export { NEVER_RELOAD } from '@uniswap/redux-multicall' // re-export for conveni
 
 // Create wrappers for hooks so consumers don't need to get latest block themselves
 
-type MulticallParams<T extends (chainId: number | undefined, latestBlock: number | undefined, ...args: any) => any> =
-  Parameters<T> extends [any, any, ...infer P] ? P : never
+interface CallState<C extends Contract, M extends keyof C['functions']> extends Omit<CallStateBase, 'result'> {
+  result: C['functions'][M] extends (...args: any) => Promise<infer T> ? T | undefined : never
+}
+
+type MultipleContractParams<
+  M extends string,
+  T extends (
+    chainId: number | undefined,
+    latestBlock: number | undefined,
+    addresses: (string | undefined)[],
+    contractInterface: Interface,
+    methodName: M,
+    ...args: any
+  ) => any
+> = Parameters<T> extends [any, any, ...infer P] ? P : never
 
-export function useMultipleContractSingleData(
-  ...args: MulticallParams<typeof multicall.hooks.useMultipleContractSingleData>
+export function useMultipleContractSingleData<C extends Contract, M extends string>(
+  ...args: MultipleContractParams<M, typeof multicall.hooks.useMultipleContractSingleData>
 ) {
   const { chainId, latestBlock } = useCallContext()
-  return multicall.hooks.useMultipleContractSingleData(chainId, latestBlock, ...args)
+  return multicall.hooks.useMultipleContractSingleData(chainId, latestBlock, ...args) as CallState<C, M>[]
 }
 
-export function useSingleCallResult(...args: MulticallParams<typeof multicall.hooks.useSingleCallResult>) {
-  const { chainId, latestBlock } = useCallContext()
-  return multicall.hooks.useSingleCallResult(chainId, latestBlock, ...args)
-}
+type SingleContractParams<
+  C extends Contract,
+  M extends string,
+  T extends (
+    chainId: number | undefined,
+    latestBlock: number | undefined,
+    contract: C | null | undefined,
+    methodName: M,
+    ...args: any
+  ) => any
+> = Parameters<T> extends [any, any, ...infer P] ? P : never
 
-export function useSingleContractMultipleData(
-  ...args: MulticallParams<typeof multicall.hooks.useSingleContractMultipleData>
+export function useSingleCallResult<C extends Contract, M extends string>(
+  ...args: SingleContractParams<C, M, typeof multicall.hooks.useSingleCallResult>
 ) {
   const { chainId, latestBlock } = useCallContext()
-  return multicall.hooks.useSingleContractMultipleData(chainId, latestBlock, ...args)
+  return multicall.hooks.useSingleCallResult(chainId, latestBlock, ...args) as CallState<C, M>
 }
 
-export function useSingleContractWithCallData(
-  ...args: MulticallParams<typeof multicall.hooks.useSingleContractWithCallData>
+export function useSingleContractMultipleData<C extends Contract, M extends string>(
+  ...args: SingleContractParams<C, M, typeof multicall.hooks.useSingleContractMultipleData>
 ) {
   const { chainId, latestBlock } = useCallContext()
-  return multicall.hooks.useSingleContractWithCallData(chainId, latestBlock, ...args)
+  return multicall.hooks.useSingleContractMultipleData(chainId, latestBlock, ...args) as CallState<C, M>[]
 }
 
 function useCallContext() {

src/hooks/useArgentWalletContract.ts

@@ -8,9 +8,9 @@ import useIsArgentWallet from './useIsArgentWallet'
 export function useArgentWalletContract(): ArgentWalletContract | null {
   const { account } = useWeb3React()
   const isArgentWallet = useIsArgentWallet()
-  return useContract(
+  return useContract<ArgentWalletContract>(
     isArgentWallet ? account ?? undefined : undefined,
     ArgentWalletContractABI,
     true
-  ) as ArgentWalletContract
+  )
 }

src/hooks/useContract.ts

@@ -7,7 +7,7 @@ import ENS_PUBLIC_RESOLVER_ABI from 'abis/ens-public-resolver.json'
 import ENS_ABI from 'abis/ens-registrar.json'
 import ERC20_ABI from 'abis/erc20.json'
 import ERC20_BYTES32_ABI from 'abis/erc20_bytes32.json'
-import { ArgentWalletDetector, EnsPublicResolver, EnsRegistrar, Erc20, Weth } from 'abis/types'
+import { ArgentWalletDetector, Eip2612, EnsPublicResolver, EnsRegistrar, Erc20, Erc20Bytes32, Weth } from 'abis/types'
 import WETH_ABI from 'abis/weth.json'
 import { ARGENT_WALLET_DETECTOR_ADDRESS, ENS_REGISTRAR_ADDRESSES, MULTICALL_ADDRESS } from 'constants/addresses'
 import { WRAPPED_NATIVE_CURRENCY } from 'constants/tokens'
@@ -18,7 +18,7 @@ import { getContract } from 'utils'
 const { abi: MulticallABI } = UniswapInterfaceMulticallJson
 
 // returns null on errors
-export function useContract<T extends Contract = Contract>(
+export function useContract<T extends Contract>(
   addressOrAddressMap: string | { [chainId: number]: string } | undefined,
   ABI: any,
   withSignerIfPossible = true
@@ -65,12 +65,12 @@ export function useENSResolverContract(address: string | undefined, withSignerIf
   return useContract<EnsPublicResolver>(address, ENS_PUBLIC_RESOLVER_ABI, withSignerIfPossible)
 }
 
-export function useBytes32TokenContract(tokenAddress?: string, withSignerIfPossible?: boolean): Contract | null {
-  return useContract(tokenAddress, ERC20_BYTES32_ABI, withSignerIfPossible)
+export function useBytes32TokenContract(tokenAddress?: string, withSignerIfPossible?: boolean) {
+  return useContract<Erc20Bytes32>(tokenAddress, ERC20_BYTES32_ABI, withSignerIfPossible)
 }
 
-export function useEIP2612Contract(tokenAddress?: string): Contract | null {
-  return useContract(tokenAddress, EIP_2612, false)
+export function useEIP2612Contract(tokenAddress?: string) {
+  return useContract<Eip2612>(tokenAddress, EIP_2612, false)
 }
 
 export function useInterfaceMulticall() {

src/hooks/useCurrencyBalance.ts

@@ -2,7 +2,7 @@ import { Interface } from '@ethersproject/abi'
 import { Currency, CurrencyAmount, Token } from '@uniswap/sdk-core'
 import { useWeb3React } from '@web3-react/core'
 import ERC20ABI from 'abis/erc20.json'
-import { Erc20Interface } from 'abis/types/Erc20'
+import { Erc20, Erc20Interface } from 'abis/types/Erc20'
 import { nativeOnChain } from 'constants/tokens'
 import { useMultipleContractSingleData, useSingleContractMultipleData } from 'hooks/multicall'
 import { useInterfaceMulticall } from 'hooks/useContract'
@@ -61,7 +61,7 @@ export function useTokenBalancesWithLoadingIndicator(
   )
   const validatedTokenAddresses = useMemo(() => validatedTokens.map((vt) => vt.address), [validatedTokens])
 
-  const balances = useMultipleContractSingleData(
+  const balances = useMultipleContractSingleData<Erc20, 'balanceOf'>(
     validatedTokenAddresses,
     ERC20Interface,
     'balanceOf',

src/hooks/usePermitAllowance.ts

@@ -22,9 +22,7 @@ export function usePermitAllowance(token?: Token, owner?: string, spender?: stri
   // If there is no allowance yet, re-check next observed block.
   // This guarantees that the permitAllowance is synced upon submission and updated upon being synced.
   const [blocksPerFetch, setBlocksPerFetch] = useState<1>()
-  const result = useSingleCallResult(contract, 'allowance', inputs, {
-    blocksPerFetch,
-  }).result as Awaited<ReturnType<Permit2['allowance']>> | undefined
+  const result = useSingleCallResult(contract, 'allowance', inputs, { blocksPerFetch }).result
 
   const rawAmount = result?.amount.toString() // convert to a string before using in a hook, to avoid spurious rerenders
   const allowance = useMemo(

src/hooks/useTokenAllowance.ts

@@ -1,6 +1,5 @@
 import { BigNumberish } from '@ethersproject/bignumber'
 import { CurrencyAmount, MaxUint256, Token } from '@uniswap/sdk-core'
-import { Erc20 } from 'abis/types'
 import { useSingleCallResult } from 'hooks/multicall'
 import { useTokenContract } from 'hooks/useContract'
 import { useCallback, useEffect, useMemo, useState } from 'react'
@@ -21,10 +20,7 @@ export function useTokenAllowance(
   // If there is no allowance yet, re-check next observed block.
   // This guarantees that the tokenAllowance is marked isSyncing upon approval and updated upon being synced.
   const [blocksPerFetch, setBlocksPerFetch] = useState<1>()
-  const { result, syncing: isSyncing } = useSingleCallResult(contract, 'allowance', inputs, { blocksPerFetch }) as {
-    result: Awaited<ReturnType<Erc20['allowance']>> | undefined
-    syncing: boolean
-  }
+  const { result, syncing: isSyncing } = useSingleCallResult(contract, 'allowance', inputs, { blocksPerFetch })
 
   const rawAmount = result?.toString() // convert to a string before using in a hook, to avoid spurious rerenders
   const allowance = useMemo(