@cofhe/abi 0.2.0

package/src/utils.ts

@@ -0,0 +1,205 @@
+import type {
+  Abi,
+  AbiConstructor,
+  AbiError,
+  AbiEvent,
+  AbiFallback,
+  AbiFunction,
+  AbiParameter,
+  AbiParametersToPrimitiveTypes,
+  AbiReceive,
+  AbiType,
+  Address,
+  ExtractAbiFunction,
+  ResolvedRegister,
+  SolidityArray,
+  SolidityFixedArrayRange,
+  SolidityTuple,
+} from 'abitype';
+
+export type ContractReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends string = string,
+  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,
+  ///
+  abiFunction extends AbiFunction = (
+    abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction
+  ) extends infer abiFunction_ extends AbiFunction
+    ? IsUnion<abiFunction_> extends true // narrow overloads by `args` by converting to tuple and filtering out overloads that don't match
+      ? UnionToTuple<abiFunction_> extends infer abiFunctions extends readonly AbiFunction[]
+        ? {
+            [K in keyof abiFunctions]: (
+              readonly unknown[] | undefined extends args // for functions that don't have inputs, `args` can be `undefined` so fallback to `readonly []`
+                ? readonly []
+                : args
+            ) extends AbiParametersToPrimitiveTypes<abiFunctions[K]['inputs'], 'inputs'>
+              ? abiFunctions[K]
+              : never;
+          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+        : never
+      : abiFunction_
+    : never,
+  outputs extends readonly AbiParameter[] = abiFunction['outputs'],
+  primitiveTypes extends readonly unknown[] = AbiParametersToPrimitiveTypes<outputs, 'outputs', true>,
+> = [abiFunction] extends [never]
+  ? unknown // `abiFunction` was not inferrable (e.g. `abi` declared as `Abi`)
+  : readonly unknown[] extends primitiveTypes
+    ? unknown // `abiFunction` was not inferrable (e.g. `abi` not const-asserted)
+    : primitiveTypes extends readonly [] // unwrap `primitiveTypes`
+      ? // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
+        void // no outputs
+      : primitiveTypes extends readonly [infer primitiveType]
+        ? primitiveType // single output
+        : primitiveTypes;
+
+export type Error<messages extends string | string[]> = messages extends string
+  ? [
+      // Surrounding with array to prevent `messages` from being widened to `string`
+      `Error: ${messages}`,
+    ]
+  : {
+      [key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never;
+    };
+
+type PartialBy<TType, TKeys extends keyof TType> = ExactPartial<Pick<TType, TKeys>> & Omit<TType, TKeys>;
+type ExactPartial<T> = { [K in keyof T]?: T[K] | undefined };
+
+export type MaybePartialBy<TType, TKeys extends string> = TKeys extends keyof TType ? PartialBy<TType, TKeys> : TType;
+
+export type ReadonlyWiden<TType> =
+  | (TType extends Function ? TType : never)
+  | (TType extends ResolvedRegister['bigIntType'] ? bigint : never)
+  | (TType extends boolean ? boolean : never)
+  | (TType extends ResolvedRegister['intType'] ? number : never)
+  | (TType extends string
+      ? TType extends Address
+        ? Address
+        : TType extends ResolvedRegister['bytesType']['inputs']
+          ? ResolvedRegister['bytesType']
+          : string
+      : never)
+  | (TType extends readonly [] ? readonly [] : never)
+  | (TType extends Record<string, unknown> ? { [K in keyof TType]: ReadonlyWiden<TType[K]> } : never)
+  | (TType extends { length: number }
+      ? {
+          [K in keyof TType]: ReadonlyWiden<TType[K]>;
+        } extends infer Val extends unknown[]
+        ? readonly [...Val]
+        : never
+      : never);
+
+export type AbiBasicType = Exclude<AbiType, SolidityTuple | SolidityArray>;
+
+/**
+ * First, infer `Head` against a known size type (either fixed-length array value or `""`).
+ *
+ * | Input           | Head         |
+ * | --------------- | ------------ |
+ * | `string[]`      | `string`     |
+ * | `string[][][3]` | `string[][]` |
+ */
+export type MaybeExtractArrayParameterType<type> = type extends `${infer head}[${'' | `${SolidityFixedArrayRange}`}]`
+  ? //   * Then, infer in the opposite direction, using the known `head` to infer the exact `size` value.
+    //   *
+    //   * | Input        | Size |
+    //   * | ------------ | ---- |
+    //   * | `${head}[]`  | `""` |
+    //   * | `${head}[3]` | `3`  |
+    //   */
+    type extends `${head}[${infer size}]`
+    ? [head, size]
+    : undefined
+  : undefined;
+
+export type IsUnion<T, C = T> = T extends C ? ([C] extends [T] ? false : true) : never;
+export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
+  ? []
+  : [...UnionToTuple<Exclude<U, Last>>, Last];
+type LastInUnion<U> =
+  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+type UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+
+/**
+ * Create tuple of {@link type} type with {@link size} size
+ *
+ * @param Type - Type of tuple
+ * @param Size - Size of tuple
+ * @returns Tuple of {@link type} type with {@link size} size
+ *
+ * @example
+ * type Result = Tuple<string, 2>
+ * //   ^? type Result = [string, string]
+ */
+// https://github.com/Microsoft/TypeScript/issues/26223#issuecomment-674500430
+export type Tuple<type, size extends number> = size extends size
+  ? number extends size
+    ? type[]
+    : _TupleOf<type, size, []>
+  : never;
+type _TupleOf<length, size extends number, acc extends readonly unknown[]> = acc['length'] extends size
+  ? acc
+  : _TupleOf<length, size, readonly [length, ...acc]>;
+
+/**
+ * Merges two object types into new type
+ *
+ * @param object1 - Object to merge into
+ * @param object2 - Object to merge and override keys from {@link object1}
+ * @returns New object type with keys from {@link object1} and {@link object2}. If a key exists in both {@link object1} and {@link object2}, the key from {@link object2} will be used.
+ *
+ * @example
+ * type Result = Merge<{ foo: string }, { foo: number; bar: string }>
+ * //   ^? type Result = { foo: number; bar: string }
+ */
+export type Merge<object1, object2> = Omit<object1, keyof object2> & object2;
+
+// FUNCTIONS
+
+/**
+ * Extracts array parameter type information from a type string.
+ * Always returns a tuple, with undefined for non-array types.
+ *
+ * @param type - Type string like "tuple", "tuple[]", or "tuple[2]"
+ * @returns [head, size] where:
+ *   - head is the base type
+ *   - size is undefined for non-arrays, "" for dynamic arrays, or the number as a string for fixed arrays
+ *
+ * @example
+ * extractArrayParameterType("tuple") // ["tuple", undefined]
+ * extractArrayParameterType("tuple[]") // ["tuple", ""]
+ * extractArrayParameterType("tuple[2]") // ["tuple", "2"]
+ */
+export function extractArrayParameterType<T extends string | undefined>(type: T): [T, string | undefined] {
+  if (type == null) return [type, undefined];
+
+  const match = type.match(/^(.+)\[(\d*)\]$/);
+
+  if (!match) {
+    // Not an array type, return [type, undefined]
+    return [type, undefined];
+  }
+
+  const head = match[1];
+  const size = match[2]; // Empty string for dynamic arrays, or digits for fixed arrays
+
+  // Return empty string for dynamic arrays, or the size string for fixed arrays
+  return [head as T, size === '' ? '' : size];
+}
+
+type AbiItem = AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive;
+
+export function isAbiFunction(item: AbiItem | unknown): item is AbiFunction {
+  if (typeof item !== 'object' || item === null) return false;
+  return 'type' in item && item.type === 'function' && 'name' in item && 'outputs' in item;
+}
+
+export function getAbiFunction<TAbi extends Abi | readonly unknown[], TFunctionName extends string>(
+  abi: TAbi,
+  functionName: TFunctionName
+): AbiFunction | undefined {
+  return abi.find((item) => {
+    const isFunction = isAbiFunction(item);
+    if (!isFunction) return false;
+    return item.name === functionName;
+  }) as AbiFunction | undefined;
+}