Fix generated read hook return type narrowing (#5020)

* fix(react): narrow generated read hook return types

* chore: tweaks

* chore: tweaks

* refactor: use ReadContractCallOptions to avoid duplicate properties in autocomplete

---------

Co-authored-by: tmm <tmm@tmm.dev>

Author: theamodhshetty

.changeset/young-foxes-rule.md

@@ -0,0 +1,5 @@
+---
+"wagmi": patch
+---
+
+Fixed `createUseReadContract` return type inference when multiple view functions share the same argument shape.

packages/react/src/hooks/codegen/createUseReadContract.test-d.ts

@@ -100,6 +100,17 @@ test('overloads', () => {
       }
     | undefined
   >(result4.data)
+
+  useReadViewOverloads({
+    // @ts-expect-error invalid functionName
+    functionName: 'invalid',
+  })
+
+  useReadViewOverloads({
+    functionName: 'foo',
+    // @ts-expect-error too many args
+    args: ['0x', '0x', '0x'],
+  })
 })
 
 test('functionName', () => {
@@ -146,3 +157,64 @@ test('functionName with overloads', () => {
     | undefined
   >(result4.data)
 })
+
+test('narrows data for functions with matching argument shapes', () => {
+  const abiSameArgsDifferentReturns = [
+    {
+      type: 'function',
+      name: 'foo',
+      stateMutability: 'view',
+      inputs: [{ name: 'ilk', type: 'bytes32' }],
+      outputs: [{ type: 'uint256' }],
+    },
+    {
+      type: 'function',
+      name: 'bar',
+      stateMutability: 'view',
+      inputs: [{ name: 'ilk', type: 'bytes32' }],
+      outputs: [
+        { name: 'art', type: 'uint256' },
+        { name: 'rate', type: 'uint256' },
+      ],
+    },
+  ] as const
+  const useReadContractSameArgs = createUseReadContract({
+    abi: abiSameArgsDifferentReturns,
+  })
+
+  {
+    const result = useReadContractSameArgs({
+      functionName: 'foo',
+      args: [
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+    })
+    assertType<bigint | undefined>(result.data)
+  }
+  {
+    const result = useReadContractSameArgs({
+      functionName: 'bar',
+      args: [
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      ],
+    })
+    assertType<readonly [bigint, bigint] | undefined>(result.data)
+  }
+
+  useReadContractSameArgs({
+    // @ts-expect-error invalid functionName
+    functionName: 'baz',
+  })
+
+  useReadContractSameArgs({
+    functionName: 'foo',
+    // @ts-expect-error wrong args for foo (expects bytes32)
+    args: [123n],
+  })
+
+  useReadContractSameArgs({
+    functionName: 'foo',
+    // @ts-expect-error abi not allowed on generated hook
+    abi: abiSameArgsDifferentReturns,
+  })
+})

packages/react/src/hooks/codegen/createUseReadContract.ts

@@ -9,7 +9,6 @@ import type {
   QueryParameter,
   ScopeKeyParameter,
   UnionCompute,
-  UnionExactPartial,
 } from '@wagmi/core/internal'
 import type {
   ReadContractData,
@@ -21,7 +20,6 @@ import type {
   Address,
   ContractFunctionArgs,
   ContractFunctionName,
-  ExactPartial,
 } from 'viem'
 import { useChainId } from '../useChainId.js'
 import { useConfig } from '../useConfig.js'
@@ -47,15 +45,16 @@ export type CreateUseReadContractParameters<
     | undefined
 }
 
+/** Call-level options from ReadContractParameters (excludes abi, address, functionName, args). */
+type ReadContractCallOptions<config extends Config> = Omit<
+  ReadContractParameters<Abi, string, readonly unknown[], config>,
+  'abi' | 'address' | 'functionName' | 'args'
+>
+
 export type CreateUseReadContractReturnType<
   abi extends Abi | readonly unknown[],
   address extends Address | Record<number, Address> | undefined,
   functionName extends ContractFunctionName<abi, stateMutability> | undefined,
-  ///
-  omittedProperties extends 'abi' | 'address' | 'functionName' =
-    | 'abi'
-    | (address extends undefined ? never : 'address')
-    | (functionName extends undefined ? never : 'functionName'),
 > = <
   name extends functionName extends ContractFunctionName<abi, stateMutability>
     ? functionName
@@ -65,10 +64,12 @@ export type CreateUseReadContractReturnType<
   selectData = ReadContractData<abi, name, args>,
 >(
   parameters?: UnionCompute<
-    UnionExactPartial<
-      // TODO: Ideally use UnionStrictOmit with omittedProperties (abi, address, functionName)
-      ReadContractParameters<abi, name, args, config>
-    > &
+    {
+      abi?: undefined
+      address?: address extends undefined ? Address : undefined
+      functionName?: functionName extends undefined ? name : undefined
+      args?: args | undefined
+    } & Partial<ReadContractCallOptions<config>> &
       ScopeKeyParameter &
       ConfigParameter<config> &
       QueryParameter<
@@ -80,8 +81,7 @@ export type CreateUseReadContractReturnType<
   > &
     (address extends Record<number, Address>
       ? { chainId?: keyof address | undefined }
-      : unknown) &
-    ExactPartial<Record<omittedProperties, undefined>>,
+      : unknown),
 ) => UseReadContractReturnType<abi, name, args, selectData>
 
 export function createUseReadContract<