{"version":3,"sources":["../src/index.ts","../src/encryptedInputs.ts","../src/utils.ts","../src/encryptedReturnTypes.ts"],"sourcesContent":["export * from './encryptedInputs';\nexport * from './encryptedReturnTypes';\nexport * from './fhenixMap';\nexport type { Abi } from 'abitype';\nexport type { ContractReturnType } from './utils';\nexport { transformEncryptedReturnTypes } from './encryptedReturnTypes';\n","import {\n  Encryptable,\n  type EncryptableAddress,\n  type EncryptableBool,\n  type EncryptableItem,\n  type EncryptableUint128,\n  type EncryptableUint16,\n  type EncryptableUint32,\n  type EncryptableUint64,\n  type EncryptableUint8,\n  type EncryptedAddressInput,\n  type EncryptedBoolInput,\n  type EncryptedItemInput,\n  type EncryptedUint128Input,\n  type EncryptedUint16Input,\n  type EncryptedUint32Input,\n  type EncryptedUint64Input,\n  type EncryptedUint8Input,\n  type LiteralToPrimitive,\n  type Primitive,\n} from '@cofhe/sdk';\nimport type { Abi, AbiFunction, AbiParameter, ExtractAbiFunction } from 'abitype';\nimport type { CofheAbiParametersToPrimitiveTypes } from './fhenixMap';\nimport { extractArrayParameterType, getAbiFunction, type MaybePartialBy, type ReadonlyWiden } from './utils';\n\nexport type CofheInputArgs<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = GetArgs<\n  abi,\n  functionName\n>['args'];\n\ntype EncryptedInputToInputMap<E extends EncryptedItemInput> = E extends EncryptedBoolInput\n  ? EncryptableBool['data']\n  : E extends EncryptedUint8Input\n    ? EncryptableUint8['data']\n    : E extends EncryptedUint16Input\n      ? EncryptableUint16['data']\n      : E extends EncryptedUint32Input\n        ? EncryptableUint32['data']\n        : E extends EncryptedUint64Input\n          ? EncryptableUint64['data']\n          : E extends EncryptedUint128Input\n            ? EncryptableUint128['data']\n            : E extends EncryptedAddressInput\n              ? EncryptableAddress['data']\n              : never;\n\ntype EncryptedInputsToInputs<T> = T extends Primitive\n  ? LiteralToPrimitive<T>\n  : T extends EncryptedItemInput\n    ? EncryptedInputToInputMap<T>\n    : {\n        [K in keyof T]: EncryptedInputsToInputs<T[K]>;\n      };\n\nexport type CofheInputArgsPreTransform<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n> = EncryptedInputsToInputs<CofheInputArgs<abi, functionName>>;\n\n/// GetArgs from abitype (not exported from abitype)\ntype GetArgs<\n  abi extends Abi | readonly unknown[] = Abi, // `readonly unknown[]` allows for non-const asserted types\n  functionName extends string = string,\n  args extends readonly unknown[] | undefined = readonly [],\n  ///\n  abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction,\n  primitiveTypes = CofheAbiParametersToPrimitiveTypes<abiFunction['inputs']>,\n  args_ =\n    | primitiveTypes // show all values\n    | (abi extends Abi\n        ? args extends primitiveTypes // infer value (if valid)\n          ? primitiveTypes extends args // make sure `args` exactly matches `primitiveTypes` (e.g. avoid `args: readonly [{ foo: string; bar: number; }] | readonly [{ foo: string; }]`)\n            ? // make inferred value of `args` match `primitiveTypes` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)\n              ReadonlyWiden<args>\n            : never\n          : never\n        : never)\n    | (Abi extends abi ? readonly unknown[] : never), // fallback if `abi` is declared as `Abi`\n> = MaybePartialBy<{ args: args_ }, readonly [] extends primitiveTypes ? 'args' : Abi extends abi ? 'args' : string>;\n\n// Runtime helper to check if an internalType is an encrypted input type\nconst ENCRYPTED_INPUT_INTERNAL_TYPES = [\n  'struct InEbool',\n  'struct InEuint8',\n  'struct InEuint16',\n  'struct InEuint32',\n  'struct InEuint64',\n  'struct InEuint128',\n  'struct InEaddress',\n] as const;\ntype EncryptedInputInternalType = (typeof ENCRYPTED_INPUT_INTERNAL_TYPES)[number];\n\nfunction transformSingleEncryptedInputToEncryptable(\n  internalType: EncryptedInputInternalType,\n  data: unknown\n): EncryptableItem {\n  switch (internalType) {\n    case 'struct InEbool':\n      return Encryptable.bool(data as boolean);\n    case 'struct InEuint8':\n      return Encryptable.uint8(data as string | bigint);\n    case 'struct InEuint16':\n      return Encryptable.uint16(data as string | bigint);\n    case 'struct InEuint32':\n      return Encryptable.uint32(data as string | bigint);\n    case 'struct InEuint64':\n      return Encryptable.uint64(data as string | bigint);\n    case 'struct InEuint128':\n      return Encryptable.uint128(data as string | bigint);\n    case 'struct InEaddress':\n      return Encryptable.address(data as string | bigint);\n    default:\n      throw new Error(`Unknown encrypted input type: ${internalType}`);\n  }\n}\n\nfunction transformArrayOfEncryptedInputsToEncryptables(\n  internalType: EncryptedInputInternalType,\n  size: string | undefined,\n  data: unknown\n): EncryptableItem[] {\n  // Ensure data is an array\n  if (!Array.isArray(data)) {\n    throw new Error('Data must be an array');\n  }\n\n  // Ensure length of fixed length tuple matches the length of the data array\n  if (size != null && size !== '' && parseInt(size) !== data.length) {\n    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);\n  }\n\n  // Transform each item in the data array into an encryptable item\n  return data.map((item) => transformSingleEncryptedInputToEncryptable(internalType, item));\n}\n\n// Pathways\n// - type is a tuple && internalType is exactly an encrypted input type (struct InEbool)\n// - - extract the base encrypted type (InEbool) and convert into an encryptable item\n// - type is a tuple && internalType is a tuple of encrypted input types (struct InEuint32[2] / struct InEuint32[])\n// - - extract the base encrypted type and length, and convert into an array of encryptable items\n// - type is a tuple && internalType is not an encrypted input type\n// - - iterate components\n// - type is not a tuple\n// - - throw away\n\nfunction internalTypeIsEncryptedInput(internalType: string): internalType is EncryptedInputInternalType {\n  return ENCRYPTED_INPUT_INTERNAL_TYPES.includes(internalType as any);\n}\n\n/**\n * Extracts encryptable values from function arguments based on the ABI.\n * Transforms raw data values into EncryptableItem objects that can be passed to the encrypt function.\n *\n * @param abi - The ABI containing the function definition\n * @param functionName - Name of the function\n * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values)\n * @returns Array of EncryptableItem objects ready for encryption\n */\nexport function extractEncryptableValues<TAbi extends Abi, TFunctionName extends string>(\n  abi: TAbi,\n  functionName: TFunctionName,\n  args: CofheInputArgsPreTransform<TAbi, TFunctionName>\n): EncryptableItem[] {\n  const abiFunction = getAbiFunction(abi, functionName);\n  const inputs = abiFunction?.inputs;\n  if (abiFunction == null || inputs == null) {\n    throw new Error(`Function ${functionName} not found in ABI`);\n  }\n\n  if (!Array.isArray(args)) {\n    throw new Error('Arguments must be an array');\n  }\n\n  // Collect encrypted values as EncryptableItem objects in order (flat array)\n  const encryptableItems: EncryptableItem[] = [];\n\n  // Process each parameter - transforms raw values into EncryptableItem objects\n  function processParameter(param: AbiParameter, value: unknown): void {\n    const [typeHead, typeSize] = extractArrayParameterType(param.type);\n    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);\n\n    /** \n      {\n        name: 'inNumber',\n        type: 'tuple',\n        internalType: 'struct InEuint32',\n        components: [\n          {\n            name: 'ctHash',\n            type: 'uint256',\n            internalType: 'uint256',\n          },\n          {\n            name: 'securityZone',\n            type: 'uint8',\n            internalType: 'uint8',\n          },\n          {\n            name: 'utype',\n            type: 'uint8',\n            internalType: 'uint8',\n          },\n          {\n            name: 'signature',\n            type: 'bytes',\n            internalType: 'bytes',\n          },\n        ],\n      }\n    */\n    if (\n      typeHead === 'tuple' &&\n      typeSize == null &&\n      internalTypeHead != null &&\n      internalTypeIsEncryptedInput(internalTypeHead)\n    ) {\n      const encryptable = transformSingleEncryptedInputToEncryptable(internalTypeHead, value);\n      encryptableItems.push(encryptable);\n      return;\n    }\n\n    /**\n      {\n        name: 'inEuint32Array',\n        type: 'tuple[2]',\n        internalType: 'struct InEuint32[2]',\n        components: [\n          {\n            name: 'ctHash',\n            type: 'uint256',\n            internalType: 'uint256',\n          },\n          {\n            name: 'securityZone',\n            type: 'uint8',\n            internalType: 'uint8',\n          },\n          {\n            name: 'utype',\n            type: 'uint8',\n            internalType: 'uint8',\n          },\n          {\n            name: 'signature',\n            type: 'bytes',\n            internalType: 'bytes',\n          },\n        ],\n      }\n     */\n    if (\n      typeHead === 'tuple' &&\n      typeSize != null &&\n      internalTypeHead != null &&\n      internalTypeIsEncryptedInput(internalTypeHead)\n    ) {\n      const encryptables = transformArrayOfEncryptedInputsToEncryptables(internalTypeHead, typeSize, value);\n      encryptableItems.push(...encryptables);\n      return;\n    }\n\n    /**\n     {\n        name: 'containsEncryptedInput',\n        type: 'tuple',\n        internalType: 'struct ABITest.ContainsEncryptedInput',\n        components: [\n          {\n            name: 'value',\n            type: 'uint256',\n            internalType: 'uint256',\n          },\n          {\n            name: 'encryptedInput',\n            type: 'tuple',\n            internalType: 'struct InEuint32',\n            components: [\n              {\n                name: 'ctHash',\n                type: 'uint256',\n                internalType: 'uint256',\n              },\n              {\n                name: 'securityZone',\n                type: 'uint8',\n                internalType: 'uint8',\n              },\n              {\n                name: 'utype',\n                type: 'uint8',\n                internalType: 'uint8',\n              },\n              {\n                name: 'signature',\n                type: 'bytes',\n                internalType: 'bytes',\n              },\n            ],\n          },\n        ],\n      }\n     */\n    if (typeHead === 'tuple' && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {\n      if ('components' in param && Array.isArray(param.components)) {\n        param.components.forEach((component) => {\n          processParameter(component, (value as Record<string, unknown>)[component.name]);\n        });\n      }\n      return;\n    }\n\n    // param.type is not a tuple, so cannot be an encrypted input or contain encrypted inputs\n    return;\n  }\n\n  // Process all inputs\n  inputs.forEach((input, index) => {\n    const arg = args[index];\n    if (arg == null) {\n      throw new Error(`Argument ${index} is undefined`);\n    }\n    processParameter(input, arg);\n  });\n\n  return encryptableItems;\n}\n\n/**\n * Re-inserts encrypted values back into function arguments based on the ABI.\n * Takes the extracted values (now encrypted) and the original args structure, and replaces\n * the encryptable values with their encrypted counterparts.\n *\n * This function mirrors the extraction logic in extractEncryptableValues, ensuring values\n * are inserted in the exact same order and locations where they were extracted.\n *\n * @param abi - The ABI containing the function definition\n * @param functionName - Name of the function\n * @param args - Original function arguments in the format of CofheInputArgsPreTransform\n * @param encryptedValues - Encrypted values in the same order as returned by extractEncryptableValues\n * @returns Function arguments with encrypted values inserted (format of CofheInputArgs)\n */\nexport function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(\n  abi: TAbi,\n  functionName: TFunctionName,\n  args: CofheInputArgsPreTransform<TAbi, TFunctionName>,\n  encryptedValues: readonly EncryptedItemInput[]\n): CofheInputArgs<TAbi, TFunctionName> {\n  const abiFunction = getAbiFunction(abi, functionName);\n  const inputs = abiFunction?.inputs;\n  if (abiFunction == null || inputs == null) {\n    throw new Error(`Function ${functionName} not found in ABI`);\n  }\n\n  if (!Array.isArray(args)) {\n    throw new Error('Arguments must be an array');\n  }\n\n  // Track position in encrypted values array\n  let encryptedIndex = 0;\n\n  // Process each parameter - replaces raw values with encrypted values\n  function processParameter(param: AbiParameter, value: unknown): unknown {\n    const [typeHead, typeSize] = extractArrayParameterType(param.type);\n    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);\n\n    // Single encrypted input (tuple with encrypted input type)\n    if (\n      typeHead === 'tuple' &&\n      typeSize == null &&\n      internalTypeHead != null &&\n      internalTypeIsEncryptedInput(internalTypeHead)\n    ) {\n      if (encryptedIndex >= encryptedValues.length) {\n        throw new Error(\n          `Not enough encrypted values: expected at least ${encryptedIndex + 1}, got ${encryptedValues.length}`\n        );\n      }\n      const encryptedValue = encryptedValues[encryptedIndex];\n      encryptedIndex++;\n      return encryptedValue;\n    }\n\n    // Array of encrypted inputs (tuple[2] or tuple[] with encrypted input type)\n    if (\n      typeHead === 'tuple' &&\n      typeSize != null &&\n      internalTypeHead != null &&\n      internalTypeIsEncryptedInput(internalTypeHead)\n    ) {\n      // Determine how many encrypted values we need\n      const arrayLength = Array.isArray(value) ? value.length : 0;\n      if (arrayLength === 0) {\n        return [];\n      }\n\n      if (encryptedIndex + arrayLength > encryptedValues.length) {\n        throw new Error(\n          `Not enough encrypted values: expected at least ${encryptedIndex + arrayLength}, got ${encryptedValues.length}`\n        );\n      }\n\n      // Extract the required number of encrypted values\n      const encryptedArray = encryptedValues.slice(encryptedIndex, encryptedIndex + arrayLength);\n      encryptedIndex += arrayLength;\n      return encryptedArray;\n    }\n\n    // Tuple recursive case (not encrypted input)\n    if (typeHead === 'tuple' && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {\n      if ('components' in param && Array.isArray(param.components)) {\n        const valueObj = value as Record<string, unknown>;\n        const result: Record<string, unknown> = {};\n\n        // Process each component in order\n        param.components.forEach((component) => {\n          const componentName = component.name;\n          if (componentName) {\n            const componentValue = valueObj[componentName];\n            if (componentValue !== undefined) {\n              result[componentName] = processParameter(component, componentValue);\n            }\n          }\n        });\n\n        return result;\n      }\n      return value;\n    }\n\n    // Not an encrypted input, return original value\n    return value;\n  }\n\n  // Process all inputs in order\n  const result = inputs.map((input, index) => {\n    const arg = args[index];\n    if (arg == null) {\n      throw new Error(`Argument ${index} is undefined`);\n    }\n    return processParameter(input, arg);\n  });\n\n  // Verify we used all encrypted values\n  if (encryptedIndex !== encryptedValues.length) {\n    throw new Error(\n      `Mismatch in encrypted values count: used ${encryptedIndex}, but provided ${encryptedValues.length}`\n    );\n  }\n\n  return result as CofheInputArgs<TAbi, TFunctionName>;\n}\n","import type {\n  Abi,\n  AbiConstructor,\n  AbiError,\n  AbiEvent,\n  AbiFallback,\n  AbiFunction,\n  AbiParameter,\n  AbiParametersToPrimitiveTypes,\n  AbiReceive,\n  AbiType,\n  Address,\n  ExtractAbiFunction,\n  ResolvedRegister,\n  SolidityArray,\n  SolidityFixedArrayRange,\n  SolidityTuple,\n} from 'abitype';\n\nexport type ContractReturnType<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,\n  ///\n  abiFunction extends AbiFunction = (\n    abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction\n  ) extends infer abiFunction_ extends AbiFunction\n    ? IsUnion<abiFunction_> extends true // narrow overloads by `args` by converting to tuple and filtering out overloads that don't match\n      ? UnionToTuple<abiFunction_> extends infer abiFunctions extends readonly AbiFunction[]\n        ? {\n            [K in keyof abiFunctions]: (\n              readonly unknown[] | undefined extends args // for functions that don't have inputs, `args` can be `undefined` so fallback to `readonly []`\n                ? readonly []\n                : args\n            ) extends AbiParametersToPrimitiveTypes<abiFunctions[K]['inputs'], 'inputs'>\n              ? abiFunctions[K]\n              : never;\n          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)\n        : never\n      : abiFunction_\n    : never,\n  outputs extends readonly AbiParameter[] = abiFunction['outputs'],\n  primitiveTypes extends readonly unknown[] = AbiParametersToPrimitiveTypes<outputs, 'outputs', true>,\n> = [abiFunction] extends [never]\n  ? unknown // `abiFunction` was not inferrable (e.g. `abi` declared as `Abi`)\n  : readonly unknown[] extends primitiveTypes\n    ? unknown // `abiFunction` was not inferrable (e.g. `abi` not const-asserted)\n    : primitiveTypes extends readonly [] // unwrap `primitiveTypes`\n      ? // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\n        void // no outputs\n      : primitiveTypes extends readonly [infer primitiveType]\n        ? primitiveType // single output\n        : primitiveTypes;\n\nexport type Error<messages extends string | string[]> = messages extends string\n  ? [\n      // Surrounding with array to prevent `messages` from being widened to `string`\n      `Error: ${messages}`,\n    ]\n  : {\n      [key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never;\n    };\n\ntype PartialBy<TType, TKeys extends keyof TType> = ExactPartial<Pick<TType, TKeys>> & Omit<TType, TKeys>;\ntype ExactPartial<T> = { [K in keyof T]?: T[K] | undefined };\n\nexport type MaybePartialBy<TType, TKeys extends string> = TKeys extends keyof TType ? PartialBy<TType, TKeys> : TType;\n\nexport type ReadonlyWiden<TType> =\n  | (TType extends Function ? TType : never)\n  | (TType extends ResolvedRegister['bigIntType'] ? bigint : never)\n  | (TType extends boolean ? boolean : never)\n  | (TType extends ResolvedRegister['intType'] ? number : never)\n  | (TType extends string\n      ? TType extends Address\n        ? Address\n        : TType extends ResolvedRegister['bytesType']['inputs']\n          ? ResolvedRegister['bytesType']\n          : string\n      : never)\n  | (TType extends readonly [] ? readonly [] : never)\n  | (TType extends Record<string, unknown> ? { [K in keyof TType]: ReadonlyWiden<TType[K]> } : never)\n  | (TType extends { length: number }\n      ? {\n          [K in keyof TType]: ReadonlyWiden<TType[K]>;\n        } extends infer Val extends unknown[]\n        ? readonly [...Val]\n        : never\n      : never);\n\nexport type AbiBasicType = Exclude<AbiType, SolidityTuple | SolidityArray>;\n\n/**\n * First, infer `Head` against a known size type (either fixed-length array value or `\"\"`).\n *\n * | Input           | Head         |\n * | --------------- | ------------ |\n * | `string[]`      | `string`     |\n * | `string[][][3]` | `string[][]` |\n */\nexport type MaybeExtractArrayParameterType<type> = type extends `${infer head}[${'' | `${SolidityFixedArrayRange}`}]`\n  ? //   * Then, infer in the opposite direction, using the known `head` to infer the exact `size` value.\n    //   *\n    //   * | Input        | Size |\n    //   * | ------------ | ---- |\n    //   * | `${head}[]`  | `\"\"` |\n    //   * | `${head}[3]` | `3`  |\n    //   */\n    type extends `${head}[${infer size}]`\n    ? [head, size]\n    : undefined\n  : undefined;\n\nexport type IsUnion<T, C = T> = T extends C ? ([C] extends [T] ? false : true) : never;\nexport type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]\n  ? []\n  : [...UnionToTuple<Exclude<U, Last>>, Last];\ntype LastInUnion<U> =\n  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;\ntype UnionToIntersection<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;\n\n/**\n * Create tuple of {@link type} type with {@link size} size\n *\n * @param Type - Type of tuple\n * @param Size - Size of tuple\n * @returns Tuple of {@link type} type with {@link size} size\n *\n * @example\n * type Result = Tuple<string, 2>\n * //   ^? type Result = [string, string]\n */\n// https://github.com/Microsoft/TypeScript/issues/26223#issuecomment-674500430\nexport type Tuple<type, size extends number> = size extends size\n  ? number extends size\n    ? type[]\n    : _TupleOf<type, size, []>\n  : never;\ntype _TupleOf<length, size extends number, acc extends readonly unknown[]> = acc['length'] extends size\n  ? acc\n  : _TupleOf<length, size, readonly [length, ...acc]>;\n\n/**\n * Merges two object types into new type\n *\n * @param object1 - Object to merge into\n * @param object2 - Object to merge and override keys from {@link object1}\n * @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.\n *\n * @example\n * type Result = Merge<{ foo: string }, { foo: number; bar: string }>\n * //   ^? type Result = { foo: number; bar: string }\n */\nexport type Merge<object1, object2> = Omit<object1, keyof object2> & object2;\n\n// FUNCTIONS\n\n/**\n * Extracts array parameter type information from a type string.\n * Always returns a tuple, with undefined for non-array types.\n *\n * @param type - Type string like \"tuple\", \"tuple[]\", or \"tuple[2]\"\n * @returns [head, size] where:\n *   - head is the base type\n *   - size is undefined for non-arrays, \"\" for dynamic arrays, or the number as a string for fixed arrays\n *\n * @example\n * extractArrayParameterType(\"tuple\") // [\"tuple\", undefined]\n * extractArrayParameterType(\"tuple[]\") // [\"tuple\", \"\"]\n * extractArrayParameterType(\"tuple[2]\") // [\"tuple\", \"2\"]\n */\nexport function extractArrayParameterType<T extends string | undefined>(type: T): [T, string | undefined] {\n  if (type == null) return [type, undefined];\n\n  const match = type.match(/^(.+)\\[(\\d*)\\]$/);\n\n  if (!match) {\n    // Not an array type, return [type, undefined]\n    return [type, undefined];\n  }\n\n  const head = match[1];\n  const size = match[2]; // Empty string for dynamic arrays, or digits for fixed arrays\n\n  // Return empty string for dynamic arrays, or the size string for fixed arrays\n  return [head as T, size === '' ? '' : size];\n}\n\ntype AbiItem = AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive;\n\nexport function isAbiFunction(item: AbiItem | unknown): item is AbiFunction {\n  if (typeof item !== 'object' || item === null) return false;\n  return 'type' in item && item.type === 'function' && 'name' in item && 'outputs' in item;\n}\n\nexport function getAbiFunction<TAbi extends Abi | readonly unknown[], TFunctionName extends string>(\n  abi: TAbi,\n  functionName: TFunctionName\n): AbiFunction | undefined {\n  return abi.find((item) => {\n    const isFunction = isAbiFunction(item);\n    if (!isFunction) return false;\n    return item.name === functionName;\n  }) as AbiFunction | undefined;\n}\n","import { type Primitive, type LiteralToPrimitive, FheTypes } from '@cofhe/sdk';\nimport type { Abi, AbiFunction, ExtractAbiFunction, AbiParameter } from 'abitype';\nimport type {\n  EncryptedReturnType,\n  CofheAbiParametersToPrimitiveTypes,\n  EBool,\n  EAddress,\n  EUint128,\n  EUint16,\n  EUint32,\n  EUint64,\n  EUint8,\n} from './fhenixMap';\nimport {\n  getAbiFunction,\n  type IsUnion,\n  type UnionToTuple,\n  type ContractReturnType,\n  extractArrayParameterType,\n} from './utils';\n\ntype FirstCofheReturnValue<T> = [T] extends [void]\n  ? never\n  : T extends readonly [infer Head, ...(readonly unknown[])]\n    ? Head\n    : T;\n\ntype FheTypeFromCofheReturnValue<T> = T extends { utype: infer U }\n  ? U\n  : T extends readonly (infer Element)[]\n    ? FheTypeFromCofheReturnValue<Element>\n    : never;\n\n/**\n * Extracts the `FheTypes` of the first returned value of a CoFHE call.\n *\n * Examples:\n * - `returns (ebool)` -> `FheTypes.Bool`\n * - `returns (euint8, euint64)` -> `FheTypes.Uint8`\n * - `returns (euint16[])` -> `FheTypes.Uint16`\n */\nexport type CofheFirstReturnFheType<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,\n> = FheTypeFromCofheReturnValue<FirstCofheReturnValue<CofheReturnType<abi, functionName, args>>>;\n\nexport type CofheReturnType<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,\n  ///\n  abiFunction extends AbiFunction = (\n    abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction\n  ) extends infer abiFunction_ extends AbiFunction\n    ? IsUnion<abiFunction_> extends true // narrow overloads by `args` by converting to tuple and filtering out overloads that don't match\n      ? UnionToTuple<abiFunction_> extends infer abiFunctions extends readonly AbiFunction[]\n        ? {\n            [K in keyof abiFunctions]: (\n              readonly unknown[] | undefined extends args // for functions that don't have inputs, `args` can be `undefined` so fallback to `readonly []`\n                ? readonly []\n                : args\n            ) extends CofheAbiParametersToPrimitiveTypes<abiFunctions[K]['inputs'], 'inputs'>\n              ? abiFunctions[K]\n              : never;\n          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)\n        : never\n      : abiFunction_\n    : never,\n  outputs extends readonly AbiParameter[] = abiFunction['outputs'],\n  primitiveTypes extends readonly unknown[] = CofheAbiParametersToPrimitiveTypes<outputs, 'outputs'>,\n> = [abiFunction] extends [never]\n  ? unknown // `abiFunction` was not inferrable (e.g. `abi` declared as `Abi`)\n  : readonly unknown[] extends primitiveTypes\n    ? unknown // `abiFunction` was not inferrable (e.g. `abi` not const-asserted)\n    : primitiveTypes extends readonly [] // unwrap `primitiveTypes`\n      ? // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\n        void // no outputs\n      : primitiveTypes extends readonly [infer primitiveType]\n        ? primitiveType // single output\n        : primitiveTypes;\n\ntype EncryptedReturnTypeToReturnTypeMap<E extends EncryptedReturnType> = E extends EBool\n  ? boolean\n  : E extends EUint8\n    ? bigint\n    : E extends EUint16\n      ? bigint\n      : E extends EUint32\n        ? bigint\n        : E extends EUint64\n          ? bigint\n          : E extends EUint128\n            ? bigint\n            : E extends EAddress\n              ? string\n              : never;\n\ntype EncryptedReturnTypesToReturnTypes<T> = T extends Primitive\n  ? LiteralToPrimitive<T>\n  : T extends EncryptedReturnType\n    ? EncryptedReturnTypeToReturnTypeMap<T>\n    : {\n        [K in keyof T]: EncryptedReturnTypesToReturnTypes<T[K]>;\n      };\n\nexport type CofheReturnTypePostTransform<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,\n> = EncryptedReturnTypesToReturnTypes<CofheReturnType<abi, functionName, args>>;\n\nconst ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES = [\n  'ebool',\n  'euint8',\n  'euint16',\n  'euint32',\n  'euint64',\n  'euint128',\n  'eaddress',\n] as const;\ntype EncryptedReturnTypeInternalType = (typeof ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES)[number];\n\ntype EncryptedReturnTypeInternalTypeToReturnTypeMap<T extends EncryptedReturnTypeInternalType> = T extends 'ebool'\n  ? EBool\n  : T extends 'euint8'\n    ? EUint8\n    : T extends 'euint16'\n      ? EUint16\n      : T extends 'euint32'\n        ? EUint32\n        : T extends 'euint64'\n          ? EUint64\n          : T extends 'euint128'\n            ? EUint128\n            : T extends 'eaddress'\n              ? EAddress\n              : never;\n\nfunction transformSingleEncryptedReturnTypeToReturnType<T extends EncryptedReturnTypeInternalType>(\n  internalType: T,\n  data: string\n): EncryptedReturnTypeInternalTypeToReturnTypeMap<T> {\n  switch (internalType) {\n    case 'ebool':\n      return {\n        ctHash: data,\n        utype: FheTypes.Bool,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'euint8':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint8,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'euint16':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint16,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'euint32':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint32,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'euint64':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint64,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'euint128':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint128,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    case 'eaddress':\n      return {\n        ctHash: data,\n        utype: FheTypes.Uint160,\n      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;\n    default:\n      throw new Error(`Unknown encrypted return type: ${internalType}`);\n  }\n}\n\nfunction transformArrayOfEncryptedReturnTypesToReturnTypes<T extends EncryptedReturnTypeInternalType>(\n  internalType: T,\n  size: string | undefined,\n  data: string[]\n): EncryptedReturnTypeInternalTypeToReturnTypeMap<T>[] {\n  // Ensure data is an array\n  if (!Array.isArray(data)) {\n    throw new Error('Data must be an array');\n  }\n\n  // Ensure length of fixed length tuple matches the length of the data array\n  if (size != null && size !== '' && parseInt(size) !== data.length) {\n    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);\n  }\n\n  // Transform each item in the data array into an return type\n  return data.map((item) => transformSingleEncryptedReturnTypeToReturnType(internalType, item));\n}\n\nfunction internalTypeIsEncryptedReturnType(internalType: string): internalType is EncryptedReturnTypeInternalType {\n  return ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES.includes(internalType as any);\n}\n\nexport function transformEncryptedReturnTypes<TAbi extends Abi, TFunctionName extends string>(\n  abi: TAbi,\n  functionName: TFunctionName,\n  data: ContractReturnType<TAbi, TFunctionName>\n): CofheReturnType<TAbi, TFunctionName> {\n  const abiFunction = getAbiFunction(abi, functionName);\n  const outputs = abiFunction?.outputs;\n  if (abiFunction == null || outputs == null) {\n    throw new Error(`Function ${functionName} not found in ABI`);\n  }\n  const outputsLength = outputs.length;\n\n  function processParameter(param: AbiParameter, value: unknown): unknown {\n    const [typeHead, typeSize] = extractArrayParameterType(param.type);\n    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);\n\n    // Is encrypted return type\n    if (internalTypeHead != null && internalTypeIsEncryptedReturnType(internalTypeHead)) {\n      // Is single encrypted return type\n      if (internalTypeSize == null) {\n        return transformSingleEncryptedReturnTypeToReturnType(internalTypeHead, value as string);\n      }\n\n      // Is array of encrypted return types\n      if (internalTypeSize != null) {\n        console.log('array of encrypted return types', internalTypeHead, internalTypeSize, value);\n        return transformArrayOfEncryptedReturnTypesToReturnTypes(internalTypeHead, internalTypeSize, value as string[]);\n      }\n    }\n\n    // Tuple but not an encrypted return type (recursive case)\n    if (typeHead === 'tuple') {\n      if ('components' in param && Array.isArray(param.components)) {\n        const valueObj = value as Record<string, unknown>;\n        const result: Record<string, unknown> = {};\n\n        param.components.forEach((component) => {\n          const componentName = component.name;\n          if (componentName) {\n            const componentValue = valueObj[componentName];\n            if (componentValue !== undefined) {\n              result[componentName] = processParameter(component, componentValue);\n            }\n          }\n        });\n\n        return result;\n      }\n\n      return value;\n    }\n\n    // Not an encrypted return type, return original value\n    return value;\n  }\n\n  // Process results (array case)\n  if (outputsLength > 1) {\n    if (!Array.isArray(data)) {\n      throw new Error('Data must be an array');\n    }\n    if (outputsLength !== data.length) {\n      throw new Error(`Mismatch in outputs length: ${outputsLength} !== ${data.length}`);\n    }\n    return data.map((item, index) => {\n      return processParameter(outputs[index], item);\n    }) as CofheReturnType<TAbi, TFunctionName>;\n  }\n\n  // Process retuls (single item case)\n  return processParameter(outputs[0], data) as CofheReturnType<TAbi, TFunctionName>;\n}\n"],"mappings":"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","names":["result","import_sdk"]}