encodeFunctionData and similar with generics

[pociej]

H
I wanna use encodeFunctionData inside generic function

function generic<T extends Abi, F extends ContractFunctionName<T>>(
  abi: T,
  functionName: F, 
  args : ContractFunctionArgs<T,AbiStateMutability,F> 
) {
  const callData = encodeFunctionData({
    abi, 
    functionName,
    args 
  })
}

And here problem comes as typescripts gives complicated error which most important part is :

'{ abi: T; functionName: F; args: ContractFunctionArgs<T, AbiStateMutability, F>; }' 
is not assignable to type 
'UnionEvaluate<
   IsNarrowable<T, Abi> extends true 
     ? T["length"] extends 1 
       ? { functionName?: `0x${string}` | F | ContractFunctionName<T, AbiStateMutability> | undefined; } 
       : { functionName: `0x${string}` | F | ContractFunctionName<T, AbiStateMutability>; } 
     : { functionName?: `0x${string}` | F | ContractFunctionName<T, AbiStateMutability> | undefined; }
>'.

I checked utils implementation and seens that all the evil comes from how UnionEvaluate uses Prettify https://github.com/wevm/viem/blob/main/src/types/utils.ts#L165
Which is very useful in development but doesnt seem to work well with generics. Does one of you meet and solve this problem already?

[tmm]

Couple quick options for you in this TypeScript Playground.

Cast in function body

Perfectly fine and natural to cast internal function values.

function generic<
  abi extends Abi,
  functionName extends ContractFunctionName<abi>,
>(
  abi: abi,
  functionName: functionName,
  args: ContractFunctionArgs<abi, AbiStateMutability, functionName>,
) {
  const callData = encodeFunctionData({
    abi: abi as Abi,
    functionName: functionName as string,
    args: args as readonly unknown[],
  })
}

Use overload for type inference

Create one signature that handles type inference, while the implementation uses the non-inferred values.

function generic<
  abi extends Abi,
  functionName extends ContractFunctionName<abi>,
>(
  abi: abi,
  functionName: functionName,
  args: ContractFunctionArgs<abi, AbiStateMutability, functionName>,
): void

function generic(
  abi: Abi,
  functionName: string,
  args: readonly unknown[] | undefined,
) {
  const callData = encodeFunctionData({ abi, functionName, args })
}

[pociej]

Thx for reply @tmm. I see downsides in both approach.

Perfectly fine and natural to cast internal function values.

If encodeFunnctionData is properly typed then such casting could cause runtime errors.

Create one signature that handles type inference, while the implementation uses the non-inferred values.

In second implemenation functionName is of type string while should be exact name of function actually existing on contract. Look at the same Typescript Playground i just edited

[pociej]

I went through implementation and I see it shouldn't work in case I described in initial post as generally there could Abi without function. Anyways look at this, input types should work and it still produces mentioned TS error.

export async function generic<
  T extends readonly [AbiFunction, ...Abi[number][]],
  F extends ContractFunctionName<T>,
>(
  abi: T,
  functionName: F,
  args: ContractFunctionArgs<T, AbiStateMutability, F>,
) {
  const calldata = encodeFunctionData({
    abi: abi,
    functionName: functionName,
    args: args,
  });
}

With small refactor in viem it should work, however it would most probably need us to resign from using Prettify under the hood.
I could create draft PR to show idea if you are open to consider such changes.