Discriminated union type output for decodeFunctionData

[fubhy]

It should be possible to support type coverage for the output of decodeFunctionData using a discriminated union type with the functionName as the type discriminator based on the passed abi.

[tmm]

What do you mean? Inferring that args is readonly unknown[] or undefined based on functionName instead of returning readonly unknown[] | undefined?

[fubhy]

No, so we can return the actual arg types alongside the functionName and use the functionName as discriminator for the union of all the different abis that were passed in:

// E.g. imagine I'm loading all transactions that took place on a specific contract. I know the abi of the contract but I want to recreate
// a timeline of txs (and their functions & parameters) on that contract. So, I first load the tx(s) in question, retrieve the tx data from it,
// and pass it to `decodeFunctionData` with the `abi` of that contract. Now, this returns a union of the possible types and I can use
// a switch statement to properly inspect the values at runtime in a type safe manner:

const decoded = decodeFunctionData({
  abi: [abi],
  data: params,
});

switch (decoded.functionName) {
  case 'myFunction': {
     // Within this scope, `decoded.args` has the type of the args of `myFunction`.
   }
}

[fubhy]

So basically like decodeFunctionResult but with a union return type because I'm not passing the functionName but a range of functions that might match based on the abis I'm passing.

... I can tackle that in a PR if you don't mind (already doing that in my SDK now).

[fubhy]

Something like this basically (there's maybe a more idiomatic way even, haven't spent too much time with the type harness yet):

export type DecodeFunctionDataTypedResult<TAbi extends Abi, TFunctionNames extends string = ExtractAbiFunctionNames<TAbi>> = {
  [TName in TFunctionNames]: {
    args: GetFunctionArgs<TAbi, TName>["args"];
    functionName: TName;
  };
}[TFunctionNames];

export function decodeFunctionDataTyped<TAbi extends Abi>({
  data,
  abi,
}: {
  data: Hex;
  abi: TAbi;
}) {
  return decodeFunctionData({
    abi: [abi],
    data,
  }) as DecodeFunctionDataTypedResult<TAbi>;
}

[fubhy]

That allows me to do this (turning txs into human readable json):

export function decodeFundDeployerTransactionData(data: Hex) {
  const decoded = decodeFunctionDataTyped({
    abi: IFundDeployer,
    data,
  });
  
  switch (decoded.functionName) {
    case "createNewFund": {
      const [
        vaultOwner,
        vaultName,
        vaultSymbol,
        denominationAsset,
        sharesActionTimelock,
        encodedFeeSettings,
        encodedPolicySettings,
      ] = decoded.args;

      const feeSettings = decodeFeeSettings(encodedFeeSettings);
      const policySettings = decodePolicySettings(encodedPolicySettings);

      return {
        functionName: "createNewFund",
        vaultOwner,
        vaultName,
        vaultSymbol,
        denominationAsset,
        sharesActionTimelock,
        feeSettings,
        policySettings,
      };
    }

    // Other cases ...
  }
}

[tmm]

Nice one! Infer all the things!

[fubhy]

Implemented in 9a15a61