@cofhe/abi 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @cofhe/abi Changelog
 
+## 0.7.0
+
+### Minor Changes
+
+- fb87d91: Migrate `cofheClient.encryptInputs` from one-signature-per-ciphertext to the new batch verification scheme (one signature per batch, per `FhenixProtocol/cofhe-contracts#78`).
+
+  **Breaking:** `EncryptInputsBuilder.execute()` now always returns `[...hashes, signature]` (`HashPlusProofResult<T>`) instead of an array of per-item `EncryptedItemInput` structs. `EncryptedItemInput` and its per-type aliases (`EncryptedBoolInput`, `EncryptedUint8Input`, etc.) are removed, along with `EncryptInputsBuilder.asHashPlusProof()` (no longer needed - it's the only shape now). `@cofhe/abi`'s `extractEncryptableValues`/`insertEncryptedValues` now detect `external*` ABI types instead of `struct InEuintXX`, with a new calling convention: any function with encrypted inputs must end with a plain `bytes` parameter to receive the shared batch signature. `@cofhe/foundry-plugin`'s `CofheClient.createIn*` helpers are renamed to `createExternal*` (`createInEuint32` → `createExternalEuint32`, etc.) and now return an `external*` handle plus a batch signature rather than an `InEuintXX` struct; the `createIn*_asHashPlusProof` variants are removed as redundant. See the [0.7.0 migration guide](https://cofhesdk.fhenix.io/migrating-to-0-7-0) for the full list of changes and what contract authors need to update.
+
+- fb87d91: Find the batch-signature parameter by pairing instead of position: it is now the plain `bytes` immediately after the contiguous run of `external*` inputs, not necessarily the function's last parameter. ERC-7984-style `*AndCall` ABIs (`..., externalEuint64 amount, bytes inputProof, bytes data`) now work in `extractEncryptableValues` / `insertEncryptedValues` / `useCofheEncryptAndWriteContract`, and `CofheInputArgsPreTransform` drops that slot wherever it sits. Non-adjacent `external*` inputs now throw — they share one signature, so there is no unambiguous slot. ABIs with the signature already last are unaffected.
+
+### Patch Changes
+
+- Updated dependencies [fb87d91]
+- Updated dependencies [fb87d91]
+- Updated dependencies [fb87d91]
+- Updated dependencies [fb87d91]
+- Updated dependencies [fb87d91]
+- Updated dependencies [d4d662f]
+- Updated dependencies [fb87d91]
+- Updated dependencies [f01cac7]
+  - @cofhe/sdk@0.7.0
+
 ## 0.6.1
 
 ### Patch Changes

package/README.md

@@ -4,12 +4,19 @@ Type-safe ABI utilities for Fhenix fully homomorphic encryption (FHE) smart cont
 
 ## Overview
 
-Fhenix contracts use encrypted types (e.g., `euint32`, `ebool`) that are represented as structs in ABIs. This package bridges the gap between:
+Fhenix contracts use encrypted types (e.g., `euint32`, `ebool`) in their ABIs. This package bridges the gap between:
 
-- **Encrypted types** (`struct InEuint32`, `euint32`) - the ABI representation
+- **Encrypted types** (`externalEuint32` for inputs, `euint32` for outputs) - the ABI representation
 - **Primitive types** (`bigint`, `boolean`, `string`) - developer-friendly values
 - **Encryptable types** (`EncryptableItem`) - intermediate encryption format
 
+> **Calling convention for encrypted inputs.** Encrypted inputs are `external*` handles — plain
+> `bytes32`-based value types, not structs — and a single signature authenticates the whole batch.
+> Any ABI function with one or more `external*` inputs must therefore end with a plain `bytes`
+> parameter, the slot that receives that shared batch signature. `extractEncryptableValues` and
+> `insertEncryptedValues` throw if a function has `external*` inputs but its last parameter isn't
+> `bytes`.
+
 The package provides compile-time type safety through TypeScript generics, ensuring encrypted values are correctly extracted, transformed, and inserted based on ABI definitions.
 
 ## Installation
@@ -32,7 +39,6 @@ yarn add @cofhe/abi
 ```typescript
 import { extractEncryptableValues, insertEncryptedValues, transformEncryptedReturnTypes } from '@cofhe/abi';
 import type { CofheInputArgs, CofheInputArgsPreTransform, CofheReturnType } from '@cofhe/abi';
-import { encrypt } from '@cofhe/sdk';
 
 const abi = [
   {
@@ -40,27 +46,30 @@ const abi = [
     name: 'add',
     inputs: [
       { name: 'a', type: 'uint256', internalType: 'uint256' },
-      { name: 'b', type: 'tuple', internalType: 'struct InEuint32', components: [...] }
+      { name: 'b', type: 'bytes32', internalType: 'externalEuint32' },
+      // Required trailing slot: receives the shared batch signature.
+      { name: 'signature', type: 'bytes', internalType: 'bytes' },
     ],
-    outputs: [{ name: '', type: 'uint256', internalType: 'euint32' }],
-    stateMutability: 'nonpayable'
-  }
+    outputs: [{ name: '', type: 'bytes32', internalType: 'euint32' }],
+    stateMutability: 'nonpayable',
+  },
 ] as const;
 
-// 1. Prepare arguments with primitive values
+// 1. Prepare arguments with primitive values.
+//    The trailing signature parameter is NOT part of the pre-transform shape - you never supply it.
 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]
+// 3. Encrypt the values - one hash per input, followed by one signature for the whole batch
+const encrypted = await client.encryptInputs(encryptables).setConsumingContract(contractAddress).execute();
+//    ^? [ExternalUint32Hash, ExternalHashProof]
 
-// 4. Insert encrypted values back into arguments
+// 4. Insert encrypted values back into arguments (the signature lands in the trailing slot)
 const encryptedArgs: CofheInputArgs<typeof abi, 'add'> = insertEncryptedValues(abi, 'add', args, encrypted);
-//    ^? [100n, EncryptedUint32Input]
+//    ^? [100n, ExternalUint32Hash, ExternalHashProof]
 
 // 5. Call contract and transform return value
 const result = await contract.add(...encryptedArgs);
@@ -119,7 +128,7 @@ Works with multiple return values, nested structures and arrays.
 
 #### `CofheInputArgs<abi, functionName>`
 
-Type-level utility that infers function input arguments with encrypted types represented as encrypted input structs.
+Type-level utility that infers function input arguments with encrypted types represented as external handle types.
 
 **Type Parameters:**
 
@@ -128,8 +137,9 @@ Type-level utility that infers function input arguments with encrypted types rep
 
 **Returns:**
 
-- Tuple type where encrypted inputs are represented as encrypted input structs (`EncryptedUint32Input`, `EncryptedBoolInput`, etc.)
+- Tuple type where encrypted inputs are represented as branded external handles (`ExternalUint32Hash`, `ExternalBoolHash`, etc.)
 - Non-encrypted types use their primitive representations
+- Includes the trailing `bytes` signature parameter (typed `ExternalHashProof`), since this is the shape passed to the contract
 
 #### `CofheInputArgsPreTransform<abi, functionName>`
 
@@ -143,17 +153,18 @@ Type-level utility that infers function input arguments with encrypted types rep
 **Returns:**
 
 - Tuple type where encrypted inputs use primitive types (`bigint` for uints, `boolean` for bool, `string` for address)
+- When the function has `external*` inputs, the trailing `bytes` signature parameter is **dropped** — callers never supply it; the SDK injects it after encryption
 - 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`
+- `externalEbool` → `boolean` (pre-transform) → `ExternalBoolHash` (post-transform)
+- `externalEuint8` → `bigint | string` → `ExternalUint8Hash`
+- `externalEuint16` → `bigint | string` → `ExternalUint16Hash`
+- `externalEuint32` → `bigint | string` → `ExternalUint32Hash`
+- `externalEuint64` → `bigint | string` → `ExternalUint64Hash`
+- `externalEuint128` → `bigint | string` → `ExternalUint128Hash`
+- `externalEaddress` → `string | bigint` → `ExternalAddressHash`
 
 #### `extractEncryptableValues(abi, functionName, args)`
 
@@ -171,14 +182,14 @@ 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.
+Re-inserts encrypted values back into function arguments, replacing primitive values with their external handles and appending the shared batch signature.
 
 **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`
+- `encryptedResult` - `readonly \`0x${string}\`[]`— the`[...hashes, signature]`tuple returned by`EncryptInputsBuilder.execute()`: one hash per encryptable, in the order returned by `extractEncryptableValues`, followed by the single batch signature
 
 **Returns:**
-Function arguments in `CofheInputArgs` format (ready for contract calls)
+Function arguments in `CofheInputArgs` format (ready for contract calls), with the batch signature placed in the function's trailing `bytes` slot.

package/dist/index.cjs

@@ -53,46 +53,54 @@ function getAbiFunction(abi, functionName) {
 }
 
 // src/encryptedInputs.ts
-var ENCRYPTED_INPUT_INTERNAL_TYPES = [
-  "struct InEbool",
-  "struct InEuint8",
-  "struct InEuint16",
-  "struct InEuint32",
-  "struct InEuint64",
-  "struct InEuint128",
-  "struct InEaddress"
+var EXTERNAL_INPUT_INTERNAL_TYPES = [
+  "externalEbool",
+  "externalEuint8",
+  "externalEuint16",
+  "externalEuint32",
+  "externalEuint64",
+  "externalEuint128",
+  "externalEaddress"
 ];
-function transformSingleEncryptedInputToEncryptable(internalType, data) {
+function internalTypeIsExternalInput(internalType) {
+  return EXTERNAL_INPUT_INTERNAL_TYPES.includes(internalType);
+}
+function paramHasExternalInput(param) {
+  const [internalTypeHead] = extractArrayParameterType(param.internalType);
+  if (internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) return true;
+  if ("components" in param && Array.isArray(param.components)) {
+    return param.components.some((component) => paramHasExternalInput(component));
+  }
+  return false;
+}
+function transformSingleExternalToEncryptable(internalType, data) {
   switch (internalType) {
-    case "struct InEbool":
+    case "externalEbool":
       return import_sdk.Encryptable.bool(data);
-    case "struct InEuint8":
+    case "externalEuint8":
       return import_sdk.Encryptable.uint8(data);
-    case "struct InEuint16":
+    case "externalEuint16":
       return import_sdk.Encryptable.uint16(data);
-    case "struct InEuint32":
+    case "externalEuint32":
       return import_sdk.Encryptable.uint32(data);
-    case "struct InEuint64":
+    case "externalEuint64":
       return import_sdk.Encryptable.uint64(data);
-    case "struct InEuint128":
+    case "externalEuint128":
       return import_sdk.Encryptable.uint128(data);
-    case "struct InEaddress":
+    case "externalEaddress":
       return import_sdk.Encryptable.address(data);
     default:
-      throw new Error(`Unknown encrypted input type: ${internalType}`);
+      throw new Error(`Unknown external input type: ${internalType}`);
   }
 }
-function transformArrayOfEncryptedInputsToEncryptables(internalType, size, data) {
+function transformArrayOfExternalsToEncryptables(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);
+  return data.map((item) => transformSingleExternalToEncryptable(internalType, item));
 }
 function extractEncryptableValues(abi, functionName, args) {
   const abiFunction = getAbiFunction(abi, functionName);
@@ -103,21 +111,22 @@ function extractEncryptableValues(abi, functionName, args) {
   if (!Array.isArray(args)) {
     throw new Error("Arguments must be an array");
   }
+  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));
+  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);
   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);
+    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      encryptableItems.push(transformSingleExternalToEncryptable(internalTypeHead, value));
       return;
     }
-    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
-      const encryptables = transformArrayOfEncryptedInputsToEncryptables(internalTypeHead, typeSize, value);
+    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      const encryptables = transformArrayOfExternalsToEncryptables(internalTypeHead, typeSize, value);
       encryptableItems.push(...encryptables);
       return;
     }
-    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+    if (typeHead === "tuple") {
       if ("components" in param && Array.isArray(param.components)) {
         param.components.forEach((component) => {
           processParameter(component, value[component.name]);
@@ -127,16 +136,41 @@ function extractEncryptableValues(abi, functionName, args) {
     }
     return;
   }
+  let argIndex = 0;
   inputs.forEach((input, index) => {
-    const arg = args[index];
+    if (index === signatureSlotIndex) return;
+    const arg = args[argIndex];
     if (arg == null) {
-      throw new Error(`Argument ${index} is undefined`);
+      throw new Error(`Argument ${argIndex} is undefined`);
     }
+    argIndex++;
     processParameter(input, arg);
   });
   return encryptableItems;
 }
-function insertEncryptedValues(abi, functionName, args, encryptedValues) {
+function findSignatureSlotIndex(inputs, hasExternalInputs, functionName) {
+  if (!hasExternalInputs) return -1;
+  const externalIndices = inputs.reduce((acc, input, index) => {
+    if (paramHasExternalInput(input)) acc.push(index);
+    return acc;
+  }, []);
+  const first = externalIndices[0];
+  const last = externalIndices[externalIndices.length - 1];
+  if (last - first + 1 !== externalIndices.length) {
+    throw new Error(
+      `Function ${functionName} has encrypted (external*) inputs at non-adjacent positions (${externalIndices.join(", ")}). They share one batch signature, so they must be contiguous with the 'bytes' signature parameter immediately after them`
+    );
+  }
+  const slotIndex = last + 1;
+  const slot = inputs[slotIndex];
+  if (slot?.type !== "bytes") {
+    throw new Error(
+      `Function ${functionName} has encrypted (external*) inputs, so the parameter immediately after them must be a plain 'bytes' parameter to receive the shared batch signature - found '${slot?.type ?? "nothing"}' at position ${slotIndex} instead`
+    );
+  }
+  return slotIndex;
+}
+function insertEncryptedValues(abi, functionName, args, encryptedResult) {
   const abiFunction = getAbiFunction(abi, functionName);
   const inputs = abiFunction?.inputs;
   if (abiFunction == null || inputs == null) {
@@ -145,35 +179,37 @@ function insertEncryptedValues(abi, functionName, args, encryptedValues) {
   if (!Array.isArray(args)) {
     throw new Error("Arguments must be an array");
   }
-  let encryptedIndex = 0;
+  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));
+  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);
+  const hashes = hasExternalInputs ? encryptedResult.slice(0, -1) : [];
+  const signature = hasExternalInputs ? encryptedResult[encryptedResult.length - 1] : void 0;
+  let hashIndex = 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 [internalTypeHead] = extractArrayParameterType(param.internalType);
+    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
+      if (hashIndex >= hashes.length) {
+        throw new Error(`Not enough encrypted hashes: expected at least ${hashIndex + 1}, got ${hashes.length}`);
       }
-      const encryptedValue = encryptedValues[encryptedIndex];
-      encryptedIndex++;
-      return encryptedValue;
+      const hash = hashes[hashIndex];
+      hashIndex++;
+      return hash;
     }
-    if (typeHead === "tuple" && typeSize != null && internalTypeHead != null && internalTypeIsEncryptedInput(internalTypeHead)) {
+    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {
       const arrayLength = Array.isArray(value) ? value.length : 0;
       if (arrayLength === 0) {
         return [];
       }
-      if (encryptedIndex + arrayLength > encryptedValues.length) {
+      if (hashIndex + arrayLength > hashes.length) {
         throw new Error(
-          `Not enough encrypted values: expected at least ${encryptedIndex + arrayLength}, got ${encryptedValues.length}`
+          `Not enough encrypted hashes: expected at least ${hashIndex + arrayLength}, got ${hashes.length}`
         );
       }
-      const encryptedArray = encryptedValues.slice(encryptedIndex, encryptedIndex + arrayLength);
-      encryptedIndex += arrayLength;
-      return encryptedArray;
+      const hashArray = hashes.slice(hashIndex, hashIndex + arrayLength);
+      hashIndex += arrayLength;
+      return hashArray;
     }
-    if (typeHead === "tuple" && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+    if (typeHead === "tuple") {
       if ("components" in param && Array.isArray(param.components)) {
         const valueObj = value;
         const result2 = {};
@@ -192,17 +228,20 @@ function insertEncryptedValues(abi, functionName, args, encryptedValues) {
     }
     return value;
   }
+  let argIndex = 0;
   const result = inputs.map((input, index) => {
-    const arg = args[index];
+    if (index === signatureSlotIndex) {
+      return signature;
+    }
+    const arg = args[argIndex];
     if (arg == null) {
-      throw new Error(`Argument ${index} is undefined`);
+      throw new Error(`Argument ${argIndex} is undefined`);
     }
+    argIndex++;
     return processParameter(input, arg);
   });
-  if (encryptedIndex !== encryptedValues.length) {
-    throw new Error(
-      `Mismatch in encrypted values count: used ${encryptedIndex}, but provided ${encryptedValues.length}`
-    );
+  if (hashIndex !== hashes.length) {
+    throw new Error(`Mismatch in encrypted hashes count: used ${hashIndex}, but provided ${hashes.length}`);
   }
   return result;
 }

package/dist/index.cjs.map

@@ -1 +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: 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"]}
+{"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 AnyExternalHash,\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 ExternalAddressHash,\n  type ExternalBoolHash,\n  type ExternalUint128Hash,\n  type ExternalUint16Hash,\n  type ExternalUint32Hash,\n  type ExternalUint64Hash,\n  type ExternalUint8Hash,\n  type LiteralToPrimitive,\n  type Primitive,\n} from '@cofhe/sdk';\nimport type { Abi, AbiFunction, AbiParameter, ExtractAbiFunction } from 'abitype';\nimport type { CofheAbiParametersToPrimitiveTypes } from './fhenixMap';\nimport {\n  extractArrayParameterType,\n  getAbiFunction,\n  type MaybeExtractArrayParameterType,\n  type MaybePartialBy,\n  type ReadonlyWiden,\n} 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 ExternalHashToInputMap<E extends AnyExternalHash> = E extends ExternalBoolHash\n  ? EncryptableBool['data']\n  : E extends ExternalUint8Hash\n    ? EncryptableUint8['data']\n    : E extends ExternalUint16Hash\n      ? EncryptableUint16['data']\n      : E extends ExternalUint32Hash\n        ? EncryptableUint32['data']\n        : E extends ExternalUint64Hash\n          ? EncryptableUint64['data']\n          : E extends ExternalUint128Hash\n            ? EncryptableUint128['data']\n            : E extends ExternalAddressHash\n              ? EncryptableAddress['data']\n              : never;\n\n// Note: AnyExternalHash is checked before Primitive - the branded hash types are structurally\n// `0x${string}` (a subtype of `string`, which is itself a Primitive), so Primitive must not be\n// checked first or every hash would be (incorrectly) widened via LiteralToPrimitive instead.\ntype EncryptedInputsToInputs<T> = T extends AnyExternalHash\n  ? ExternalHashToInputMap<T>\n  : T extends Primitive\n    ? LiteralToPrimitive<T>\n    : {\n        [K in keyof T]: EncryptedInputsToInputs<T[K]>;\n      };\n\n/**\n * Drops the batch-signature argument from an args tuple.\n *\n * The signature slot is the first non-`external*` parameter that follows the contiguous run of\n * `external*` parameters - `FHE.asEuintXX(hash, proof)` is a pair, so the proof sits with the\n * hashes it authenticates rather than at the end of the parameter list. Walks the ABI parameters\n * and the args tuple in lockstep and elides the arg at that position.\n */\ntype DropSignatureSlotTuple<\n  params extends readonly unknown[],\n  args extends readonly unknown[],\n  afterExternalRun extends boolean = false,\n> = params extends readonly [infer P, ...infer PRest extends readonly unknown[]]\n  ? args extends readonly [infer A, ...infer ARest extends readonly unknown[]]\n    ? P extends AbiParameter\n      ? ParamHasExternalInput<P> extends true\n        ? readonly [A, ...DropSignatureSlotTuple<PRest, ARest, true>]\n        : afterExternalRun extends true\n          ? DropSignatureSlotTuple<PRest, ARest, false>\n          : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, false>]\n      : readonly [A, ...DropSignatureSlotTuple<PRest, ARest, afterExternalRun>]\n    : readonly []\n  : args;\n\n/** Non-tuple args (e.g. `undefined`) pass through unchanged, as the previous `DropLast` did. */\ntype DropSignatureSlot<params extends readonly unknown[], args> = args extends readonly unknown[]\n  ? DropSignatureSlotTuple<params, args>\n  : args;\n\nconst EXTERNAL_INPUT_INTERNAL_TYPES = [\n  'externalEbool',\n  'externalEuint8',\n  'externalEuint16',\n  'externalEuint32',\n  'externalEuint64',\n  'externalEuint128',\n  'externalEaddress',\n] as const;\ntype ExternalInputInternalType = (typeof EXTERNAL_INPUT_INTERNAL_TYPES)[number];\n\n/** Type-level: does this ABI parameter carry (or, if a tuple, recursively contain) an `external*` input? */\ntype ParamHasExternalInput<param extends AbiParameter> =\n  MaybeExtractArrayParameterType<param['internalType']> extends [infer head extends string, any]\n    ? head extends ExternalInputInternalType\n      ? true\n      : false\n    : param['internalType'] extends ExternalInputInternalType\n      ? true\n      : param extends { type: 'tuple'; components: infer components extends readonly AbiParameter[] }\n        ? ParamsHaveExternalInput<components>\n        : false;\n\ntype ParamsHaveExternalInput<params extends readonly AbiParameter[]> = params extends readonly [\n  infer Head extends AbiParameter,\n  ...infer Rest extends readonly AbiParameter[],\n]\n  ? ParamHasExternalInput<Head> extends true\n    ? true\n    : ParamsHaveExternalInput<Rest>\n  : false;\n\n/**\n * Pre-transform args for a function ABI: the raw plain values a caller supplies before encryption.\n *\n * If the function has one or more `external*` (encrypted) inputs, the plain `bytes` parameter\n * immediately following them is the shared batch signature slot - the caller never supplies it\n * directly (the SDK injects it after encryption), so it's dropped from this type entirely.\n */\nexport type CofheInputArgsPreTransform<\n  abi extends Abi | readonly unknown[] = Abi,\n  functionName extends string = string,\n  abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction,\n> = EncryptedInputsToInputs<\n  ParamsHaveExternalInput<abiFunction['inputs']> extends true\n    ? DropSignatureSlot<abiFunction['inputs'], CofheInputArgs<abi, functionName>>\n    : CofheInputArgs<abi, functionName>\n>;\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\nfunction internalTypeIsExternalInput(internalType: string): internalType is ExternalInputInternalType {\n  return EXTERNAL_INPUT_INTERNAL_TYPES.includes(internalType as any);\n}\n\nfunction paramHasExternalInput(param: AbiParameter): boolean {\n  const [internalTypeHead] = extractArrayParameterType(param.internalType);\n  if (internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) return true;\n  if ('components' in param && Array.isArray(param.components)) {\n    return param.components.some((component) => paramHasExternalInput(component));\n  }\n  return false;\n}\n\nfunction transformSingleExternalToEncryptable(internalType: ExternalInputInternalType, data: unknown): EncryptableItem {\n  switch (internalType) {\n    case 'externalEbool':\n      return Encryptable.bool(data as boolean);\n    case 'externalEuint8':\n      return Encryptable.uint8(data as string | bigint);\n    case 'externalEuint16':\n      return Encryptable.uint16(data as string | bigint);\n    case 'externalEuint32':\n      return Encryptable.uint32(data as string | bigint);\n    case 'externalEuint64':\n      return Encryptable.uint64(data as string | bigint);\n    case 'externalEuint128':\n      return Encryptable.uint128(data as string | bigint);\n    case 'externalEaddress':\n      return Encryptable.address(data as string | bigint);\n    default:\n      throw new Error(`Unknown external input type: ${internalType}`);\n  }\n}\n\nfunction transformArrayOfExternalsToEncryptables(\n  internalType: ExternalInputInternalType,\n  size: string | undefined,\n  data: unknown\n): EncryptableItem[] {\n  if (!Array.isArray(data)) {\n    throw new Error('Data must be an array');\n  }\n\n  if (size != null && size !== '' && parseInt(size) !== data.length) {\n    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);\n  }\n\n  return data.map((item) => transformSingleExternalToEncryptable(internalType, item));\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 *   if the function has `external*` inputs, the trailing batch-signature slot is NOT included)\n * @returns Array of EncryptableItem objects ready for encryption, in ABI parameter order\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  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));\n  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);\n\n  // Collect encrypted values as EncryptableItem objects in order (flat array)\n  const encryptableItems: EncryptableItem[] = [];\n\n  function processParameter(param: AbiParameter, value: unknown): void {\n    const [typeHead, typeSize] = extractArrayParameterType(param.type);\n    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);\n\n    // Bare external input (e.g. `externalEuint32`, type: 'bytes32')\n    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {\n      encryptableItems.push(transformSingleExternalToEncryptable(internalTypeHead, value));\n      return;\n    }\n\n    // Array of external inputs (e.g. `externalEuint32[]`/`externalEuint32[2]`, type: 'bytes32[]'/'bytes32[2]')\n    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {\n      const encryptables = transformArrayOfExternalsToEncryptables(internalTypeHead, typeSize, value);\n      encryptableItems.push(...encryptables);\n      return;\n    }\n\n    // Tuple recursive case (struct that may itself contain external inputs)\n    if (typeHead === 'tuple') {\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    // Not an external input, and cannot contain one\n    return;\n  }\n\n  // Process all inputs, skipping the batch-signature slot (nothing to extract there). `args` is the\n  // pre-transform tuple, which omits that slot, so its indices lag by one past the signature.\n  let argIndex = 0;\n  inputs.forEach((input, index) => {\n    if (index === signatureSlotIndex) return;\n    const arg = args[argIndex];\n    if (arg == null) {\n      throw new Error(`Argument ${argIndex} is undefined`);\n    }\n    argIndex++;\n    processParameter(input, arg);\n  });\n\n  return encryptableItems;\n}\n\n/**\n * Index of the shared batch-signature parameter: the plain `bytes` immediately after the\n * contiguous run of `external*` parameters. Returns -1 when the function has no encrypted inputs.\n *\n * The proof pairs with the hashes it authenticates (`FHE.asEuintXX(hash, proof)`), so it does not\n * have to be the last parameter - anything may follow it.\n */\nfunction findSignatureSlotIndex(\n  inputs: readonly AbiParameter[],\n  hasExternalInputs: boolean,\n  functionName: string\n): number {\n  if (!hasExternalInputs) return -1;\n\n  const externalIndices = inputs.reduce<number[]>((acc, input, index) => {\n    if (paramHasExternalInput(input)) acc.push(index);\n    return acc;\n  }, []);\n\n  const first = externalIndices[0]!;\n  const last = externalIndices[externalIndices.length - 1]!;\n  if (last - first + 1 !== externalIndices.length) {\n    throw new Error(\n      `Function ${functionName} has encrypted (external*) inputs at non-adjacent positions ` +\n        `(${externalIndices.join(', ')}). They share one batch signature, so they must be contiguous ` +\n        `with the 'bytes' signature parameter immediately after them`\n    );\n  }\n\n  const slotIndex = last + 1;\n  const slot = inputs[slotIndex];\n  if (slot?.type !== 'bytes') {\n    throw new Error(\n      `Function ${functionName} has encrypted (external*) inputs, so the parameter immediately after ` +\n        `them must be a plain 'bytes' parameter to receive the shared batch signature - found ` +\n        `'${slot?.type ?? 'nothing'}' at position ${slotIndex} instead`\n    );\n  }\n\n  return slotIndex;\n}\n\n/**\n * Re-inserts encrypted values back into function arguments based on the ABI.\n * Takes the batch-verified result (per-input hashes, in order, followed by the single shared\n * signature) and the original args structure, and produces the final call args: each `external*`\n * position gets its corresponding hash, and the trailing `bytes` parameter gets the signature.\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 encryptedResult - `[...hashes, signature]`, as returned by `EncryptInputsBuilder.execute()`\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  encryptedResult: readonly `0x${string}`[]\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  const hasExternalInputs = inputs.some((input) => paramHasExternalInput(input));\n  const signatureSlotIndex = findSignatureSlotIndex(inputs, hasExternalInputs, functionName);\n\n  const hashes = hasExternalInputs ? encryptedResult.slice(0, -1) : [];\n  const signature = hasExternalInputs ? encryptedResult[encryptedResult.length - 1] : undefined;\n\n  // Track position in the hashes array\n  let hashIndex = 0;\n\n  function processParameter(param: AbiParameter, value: unknown): unknown {\n    const [typeHead, typeSize] = extractArrayParameterType(param.type);\n    const [internalTypeHead] = extractArrayParameterType(param.internalType);\n\n    // Bare external input - substitute its hash\n    if (typeSize == null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {\n      if (hashIndex >= hashes.length) {\n        throw new Error(`Not enough encrypted hashes: expected at least ${hashIndex + 1}, got ${hashes.length}`);\n      }\n      const hash = hashes[hashIndex];\n      hashIndex++;\n      return hash;\n    }\n\n    // Array of external inputs - substitute the corresponding slice of hashes\n    if (typeSize != null && internalTypeHead != null && internalTypeIsExternalInput(internalTypeHead)) {\n      const arrayLength = Array.isArray(value) ? value.length : 0;\n      if (arrayLength === 0) {\n        return [];\n      }\n\n      if (hashIndex + arrayLength > hashes.length) {\n        throw new Error(\n          `Not enough encrypted hashes: expected at least ${hashIndex + arrayLength}, got ${hashes.length}`\n        );\n      }\n\n      const hashArray = hashes.slice(hashIndex, hashIndex + arrayLength);\n      hashIndex += arrayLength;\n      return hashArray;\n    }\n\n    // Tuple recursive case (struct that may itself contain external inputs)\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      return value;\n    }\n\n    // Not an external input, return original value\n    return value;\n  }\n\n  // Rebuild the full arg list; the signature slot is injected directly. `args` omits that slot, so\n  // its indices lag by one past the signature position.\n  let argIndex = 0;\n  const result = inputs.map((input, index) => {\n    if (index === signatureSlotIndex) {\n      return signature;\n    }\n    const arg = args[argIndex];\n    if (arg == null) {\n      throw new Error(`Argument ${argIndex} is undefined`);\n    }\n    argIndex++;\n    return processParameter(input, arg);\n  });\n\n  // Verify we used all encrypted hashes\n  if (hashIndex !== hashes.length) {\n    throw new Error(`Mismatch in encrypted hashes count: used ${hashIndex}, but provided ${hashes.length}`);\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"]}