@cofhe/abi 0.0.0-beta-20260216104742

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# @cofhe/abi Changelog
+
+## 0.0.0-beta-20260216104742
+
+### Patch Changes
+
+- be9bfd9: Fix deployment include `dist` folder.
+  - @cofhe/sdk@0.0.0-beta-20260216104742
+
+## 0.2.0
+
+### Patch Changes
+
+- Updated dependencies [8fda09a]
+- Updated dependencies [4057a76]
+- Updated dependencies [dba2759]
+- Updated dependencies [e0caeca]
+- Updated dependencies [7c861af]
+- Updated dependencies [2a9d6c5]
+  - @cofhe/sdk@0.2.0

package/README.md

@@ -0,0 +1,184 @@
+# @cofhe/abi
+
+Type-safe ABI utilities for Fhenix fully homomorphic encryption (FHE) smart contracts. Provides type-safe transformations between encrypted input/output types and their underlying primitive values.
+
+## Overview
+
+Fhenix contracts use encrypted types (e.g., `euint32`, `ebool`) that are represented as structs in ABIs. This package bridges the gap between:
+
+- **Encrypted types** (`struct InEuint32`, `euint32`) - the ABI representation
+- **Primitive types** (`bigint`, `boolean`, `string`) - developer-friendly values
+- **Encryptable types** (`EncryptableItem`) - intermediate encryption format
+
+The package provides compile-time type safety through TypeScript generics, ensuring encrypted values are correctly extracted, transformed, and inserted based on ABI definitions.
+
+## Installation
+
+```bash
+npm install @cofhe/abi
+# or
+pnpm add @cofhe/abi
+# or
+yarn add @cofhe/abi
+```
+
+**Peer Dependencies:**
+
+- `@cofhe/sdk` - Core encryption types and utilities
+- `abitype` - ABI type utilities
+
+## Quick Start
+
+```typescript
+import { extractEncryptableValues, insertEncryptedValues, transformEncryptedReturnTypes } from '@cofhe/abi';
+import type { CofheInputArgs, CofheInputArgsPreTransform, CofheReturnType } from '@cofhe/abi';
+import { encrypt } from '@cofhe/sdk';
+
+const abi = [
+  {
+    type: 'function',
+    name: 'add',
+    inputs: [
+      { name: 'a', type: 'uint256', internalType: 'uint256' },
+      { name: 'b', type: 'tuple', internalType: 'struct InEuint32', components: [...] }
+    ],
+    outputs: [{ name: '', type: 'uint256', internalType: 'euint32' }],
+    stateMutability: 'nonpayable'
+  }
+] as const;
+
+// 1. Prepare arguments with primitive values
+const args: CofheInputArgsPreTransform<typeof abi, 'add'> = [100n, 200n];
+
+// 2. Extract encryptable values
+const encryptables = extractEncryptableValues(abi, 'add', args);
+//    ^? [Encryptable.uint32(200n)]
+
+// 3. Encrypt the values
+const encrypted = await encrypt(encryptables);
+//    ^? [EncryptedUint32Input]
+
+// 4. Insert encrypted values back into arguments
+const encryptedArgs: CofheInputArgs<typeof abi, 'add'> = insertEncryptedValues(abi, 'add', args, encrypted);
+//    ^? [100n, EncryptedUint32Input]
+
+// 5. Call contract and transform return value
+const result = await contract.add(...encryptedArgs);
+//    ^? bigint
+
+// 6. Transform raw return value into correct encrypted value type
+const transformed: CofheReturnType<typeof abi, 'add'> = transformEncryptedReturnTypes(abi, 'add', result);
+//    ^? Euint32
+```
+
+## Public API Reference
+
+### Return Types
+
+#### `CofheReturnType<abi, functionName, args?>`
+
+Type-level utility that infers the return type of a function, transforming encrypted return types to their typed representations.
+
+**Type Parameters:**
+
+- `abi` - Contract ABI (must be `const`-asserted for type inference)
+- `functionName` - Function name (string literal)
+- `args` - Optional function arguments for overload disambiguation
+
+**Returns:**
+
+- Transformed return type where encrypted types (`euint32`, `ebool`, etc.) are converted to typed objects (`{ ctHash: bigint, utype: FheTypes }`)
+- Non-encrypted types remain unchanged
+- Supports single values, tuples, arrays, and nested structures
+
+**Supported Encrypted Return Types:**
+
+- `ebool` → `{ ctHash: bigint; utype: FheTypes.Bool }`
+- `euint8` → `{ ctHash: bigint; utype: FheTypes.Uint8 }`
+- `euint16` → `{ ctHash: bigint; utype: FheTypes.Uint16 }`
+- `euint32` → `{ ctHash: bigint; utype: FheTypes.Uint32 }`
+- `euint64` → `{ ctHash: bigint; utype: FheTypes.Uint64 }`
+- `euint128` → `{ ctHash: bigint; utype: FheTypes.Uint128 }`
+- `eaddress` → `{ ctHash: bigint; utype: FheTypes.Uint160 }`
+
+#### `transformEncryptedReturnTypes(abi, functionName, data)`
+
+Runtime function that transforms contract return values from `bigint` ciphertext hashes to typed encrypted return objects.
+
+**Parameters:**
+
+- `abi` - Contract ABI
+- `functionName` - Function name
+- `data` - Raw return value(s) from contract call (single value or array)
+
+**Returns:**
+Transformed return value matching `CofheReturnType<abi, functionName>`
+Works with multiple return values, nested structures and arrays.
+
+### Encrypted Inputs
+
+#### `CofheInputArgs<abi, functionName>`
+
+Type-level utility that infers function input arguments with encrypted types represented as encrypted input structs.
+
+**Type Parameters:**
+
+- `abi` - Contract ABI (must be `const`-asserted for type inference)
+- `functionName` - Function name (string literal)
+
+**Returns:**
+
+- Tuple type where encrypted inputs are represented as encrypted input structs (`EncryptedUint32Input`, `EncryptedBoolInput`, etc.)
+- Non-encrypted types use their primitive representations
+
+#### `CofheInputArgsPreTransform<abi, functionName>`
+
+Type-level utility that infers function input arguments with encrypted types represented as their underlying primitive values (before encryption).
+
+**Type Parameters:**
+
+- `abi` - Contract ABI (must be `const`-asserted for type inference)
+- `functionName` - Function name (string literal)
+
+**Returns:**
+
+- Tuple type where encrypted inputs use primitive types (`bigint` for uints, `boolean` for bool, `string` for address)
+- This is the format you provide to `extractEncryptableValues`
+
+**Supported Encrypted Input Types:**
+
+- `struct InEbool` → `boolean` (pre-transform) → `EncryptedBoolInput` (post-transform)
+- `struct InEuint8` → `bigint | string` → `EncryptedUint8Input`
+- `struct InEuint16` → `bigint | string` → `EncryptedUint16Input`
+- `struct InEuint32` → `bigint | string` → `EncryptedUint32Input`
+- `struct InEuint64` → `bigint | string` → `EncryptedUint64Input`
+- `struct InEuint128` → `bigint | string` → `EncryptedUint128Input`
+- `struct InEaddress` → `string | bigint` → `EncryptedAddressInput`
+
+#### `extractEncryptableValues(abi, functionName, args)`
+
+Extracts encryptable values from function arguments, converting primitive values to `EncryptableItem` objects ready for encryption.
+
+**Parameters:**
+
+- `abi` - Contract ABI
+- `functionName` - Function name
+- `args` - Function arguments in `CofheInputArgsPreTransform` format (primitives)
+
+**Returns:**
+Flat array of `EncryptableItem` objects in the order they appear in the ABI (depth-first traversal).
+Works with arrays (fixed length or unbounded) and nested structures.
+
+#### `insertEncryptedValues(abi, functionName, args, encryptedValues)`
+
+Re-inserts encrypted values back into function arguments, replacing primitive values with encrypted input structs.
+
+**Parameters:**
+
+- `abi` - Contract ABI
+- `functionName` - Function name
+- `args` - Original function arguments in `CofheInputArgsPreTransform` format
+- `encryptedValues` - Array of encrypted values in the same order as returned by `extractEncryptableValues`
+
+**Returns:**
+Function arguments in `CofheInputArgs` format (ready for contract calls)

package/dist/index.cjs

@@ -0,0 +1,331 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  extractEncryptableValues: () => extractEncryptableValues,
+  insertEncryptedValues: () => insertEncryptedValues,
+  transformEncryptedReturnTypes: () => transformEncryptedReturnTypes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/encryptedInputs.ts
+var import_sdk = require("@cofhe/sdk");
+
+// src/utils.ts
+function extractArrayParameterType(type) {
+  if (type == null) return [type, void 0];
+  const match = type.match(/^(.+)\[(\d*)\]$/);
+  if (!match) {
+    return [type, void 0];
+  }
+  const head = match[1];
+  const size = match[2];
+  return [head, size === "" ? "" : size];
+}
+function isAbiFunction(item) {
+  if (typeof item !== "object" || item === null) return false;
+  return "type" in item && item.type === "function" && "name" in item && "outputs" in item;
+}
+function getAbiFunction(abi, functionName) {
+  return abi.find((item) => {
+    const isFunction = isAbiFunction(item);
+    if (!isFunction) return false;
+    return item.name === functionName;
+  });
+}
+
+// src/encryptedInputs.ts
+var ENCRYPTED_INPUT_INTERNAL_TYPES = [
+  "struct InEbool",
+  "struct InEuint8",
+  "struct InEuint16",
+  "struct InEuint32",
+  "struct InEuint64",
+  "struct InEuint128",
+  "struct InEaddress"
+];
+function transformSingleEncryptedInputToEncryptable(internalType, data) {
+  switch (internalType) {
+    case "struct InEbool":
+      return import_sdk.Encryptable.bool(data);
+    case "struct InEuint8":
+      return import_sdk.Encryptable.uint8(data);
+    case "struct InEuint16":
+      return import_sdk.Encryptable.uint16(data);
+    case "struct InEuint32":
+      return import_sdk.Encryptable.uint32(data);
+    case "struct InEuint64":
+      return import_sdk.Encryptable.uint64(data);
+    case "struct InEuint128":
+      return import_sdk.Encryptable.uint128(data);
+    case "struct InEaddress":
+      return import_sdk.Encryptable.address(data);
+    default:
+      throw new Error(`Unknown encrypted input type: ${internalType}`);
+  }
+}
+function transformArrayOfEncryptedInputsToEncryptables(internalType, size, data) {
+  if (!Array.isArray(data)) {
+    throw new Error("Data must be an array");
+  }
+  if (size != null && size !== "" && parseInt(size) !== data.length) {
+    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);
+  }
+  return data.map((item) => transformSingleEncryptedInputToEncryptable(internalType, item));
+}
+function internalTypeIsEncryptedInput(internalType) {
+  return ENCRYPTED_INPUT_INTERNAL_TYPES.includes(internalType);
+}
+function extractEncryptableValues(abi, functionName, args) {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const inputs = abiFunction?.inputs;
+  if (abiFunction == null || inputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+  if (!Array.isArray(args)) {
+    throw new Error("Arguments must be an array");
+  }
+  const encryptableItems = [];
+  function processParameter(param, value) {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+    if (typeHead === "tuple" && typeSize == null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+      const encryptable = transformSingleEncryptedInputToEncryptable(internalTypeHead, value);
+      encryptableItems.push(encryptable);
+      return;
+    }
+    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+      const encryptables = transformArrayOfEncryptedInputsToEncryptables(internalTypeHead, typeSize, value);
+      encryptableItems.push(...encryptables);
+      return;
+    }
+    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+      if ("components" in param && Array.isArray(param.components)) {
+        param.components.forEach((component) => {
+          processParameter(component, value[component.name]);
+        });
+      }
+      return;
+    }
+    return;
+  }
+  inputs.forEach((input, index) => {
+    const arg = args[index];
+    if (arg == null) {
+      throw new Error(`Argument ${index} is undefined`);
+    }
+    processParameter(input, arg);
+  });
+  return encryptableItems;
+}
+function insertEncryptedValues(abi, functionName, args, encryptedValues) {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const inputs = abiFunction?.inputs;
+  if (abiFunction == null || inputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+  if (!Array.isArray(args)) {
+    throw new Error("Arguments must be an array");
+  }
+  let encryptedIndex = 0;
+  function processParameter(param, value) {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+    if (typeHead === "tuple" && typeSize == null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+      if (encryptedIndex >= encryptedValues.length) {
+        throw new Error(
+          `Not enough encrypted values: expected at least ${encryptedIndex + 1}, got ${encryptedValues.length}`
+        );
+      }
+      const encryptedValue = encryptedValues[encryptedIndex];
+      encryptedIndex++;
+      return encryptedValue;
+    }
+    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+      const arrayLength = Array.isArray(value) ? value.length : 0;
+      if (arrayLength === 0) {
+        return [];
+      }
+      if (encryptedIndex + arrayLength > encryptedValues.length) {
+        throw new Error(
+          `Not enough encrypted values: expected at least ${encryptedIndex + arrayLength}, got ${encryptedValues.length}`
+        );
+      }
+      const encryptedArray = encryptedValues.slice(encryptedIndex, encryptedIndex + arrayLength);
+      encryptedIndex += arrayLength;
+      return encryptedArray;
+    }
+    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+      if ("components" in param && Array.isArray(param.components)) {
+        const valueObj = value;
+        const result2 = {};
+        param.components.forEach((component) => {
+          const componentName = component.name;
+          if (componentName) {
+            const componentValue = valueObj[componentName];
+            if (componentValue !== void 0) {
+              result2[componentName] = processParameter(component, componentValue);
+            }
+          }
+        });
+        return result2;
+      }
+      return value;
+    }
+    return value;
+  }
+  const result = inputs.map((input, index) => {
+    const arg = args[index];
+    if (arg == null) {
+      throw new Error(`Argument ${index} is undefined`);
+    }
+    return processParameter(input, arg);
+  });
+  if (encryptedIndex !== encryptedValues.length) {
+    throw new Error(
+      `Mismatch in encrypted values count: used ${encryptedIndex}, but provided ${encryptedValues.length}`
+    );
+  }
+  return result;
+}
+
+// src/encryptedReturnTypes.ts
+var import_sdk2 = require("@cofhe/sdk");
+var ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES = [
+  "ebool",
+  "euint8",
+  "euint16",
+  "euint32",
+  "euint64",
+  "euint128",
+  "eaddress"
+];
+function transformSingleEncryptedReturnTypeToReturnType(internalType, data) {
+  switch (internalType) {
+    case "ebool":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Bool
+      };
+    case "euint8":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint8
+      };
+    case "euint16":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint16
+      };
+    case "euint32":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint32
+      };
+    case "euint64":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint64
+      };
+    case "euint128":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint128
+      };
+    case "eaddress":
+      return {
+        ctHash: data,
+        utype: import_sdk2.FheTypes.Uint160
+      };
+    default:
+      throw new Error(`Unknown encrypted return type: ${internalType}`);
+  }
+}
+function transformArrayOfEncryptedReturnTypesToReturnTypes(internalType, size, data) {
+  if (!Array.isArray(data)) {
+    throw new Error("Data must be an array");
+  }
+  if (size != null && size !== "" && parseInt(size) !== data.length) {
+    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);
+  }
+  return data.map((item) => transformSingleEncryptedReturnTypeToReturnType(internalType, item));
+}
+function internalTypeIsEncryptedReturnType(internalType) {
+  return ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES.includes(internalType);
+}
+function transformEncryptedReturnTypes(abi, functionName, data) {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const outputs = abiFunction?.outputs;
+  if (abiFunction == null || outputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+  const outputsLength = outputs.length;
+  function processParameter(param, value) {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+    if (internalTypeHead != null && internalTypeIsEncryptedReturnType(internalTypeHead)) {
+      if (internalTypeSize == null) {
+        return transformSingleEncryptedReturnTypeToReturnType(internalTypeHead, value);
+      }
+      if (internalTypeSize != null) {
+        console.log("array of encrypted return types", internalTypeHead, internalTypeSize, value);
+        return transformArrayOfEncryptedReturnTypesToReturnTypes(internalTypeHead, internalTypeSize, value);
+      }
+    }
+    if (typeHead === "tuple") {
+      if ("components" in param && Array.isArray(param.components)) {
+        const valueObj = value;
+        const result = {};
+        param.components.forEach((component) => {
+          const componentName = component.name;
+          if (componentName) {
+            const componentValue = valueObj[componentName];
+            if (componentValue !== void 0) {
+              result[componentName] = processParameter(component, componentValue);
+            }
+          }
+        });
+        return result;
+      }
+      return value;
+    }
+    return value;
+  }
+  if (outputsLength > 1) {
+    if (!Array.isArray(data)) {
+      throw new Error("Data must be an array");
+    }
+    if (outputsLength !== data.length) {
+      throw new Error(`Mismatch in outputs length: ${outputsLength} !== ${data.length}`);
+    }
+    return data.map((item, index) => {
+      return processParameter(outputs[index], item);
+    });
+  }
+  return processParameter(outputs[0], data);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractEncryptableValues,
+  insertEncryptedValues,
+  transformEncryptedReturnTypes
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"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: bigint\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: bigint[]\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 bigint);\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 bigint[]);\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"]}