@cofhe/abi 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @cofhe/abi Changelog
+
+## 0.2.0
+
+### Patch Changes
+
+- Updated dependencies [8fda09a]
+- Updated dependencies [4057a76]
+- Updated dependencies [dba2759]
+- Updated dependencies [e0caeca]
+- Updated dependencies [7c861af]
+- Updated dependencies [2a9d6c5]
+  - @cofhe/sdk@0.2.0

package/README.md

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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@cofhe/abi",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "ABI utilities for Fhenix FHE contracts",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FhenixProtocol/cofhesdk.git",
+    "directory": "packages/abi"
+  },
+  "files": [
+    "dist/**",
+    "src/**",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "abitype": "^1.2.3",
+    "@cofhe/sdk": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "eslint": "^8.57.0",
+    "tsup": "^8.0.2",
+    "typescript": "5.5.4",
+    "vitest": "^3.0.0",
+    "@cofhe/tsconfig": "0.1.1",
+    "@cofhe/eslint-config": "0.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"**/*.ts*\"",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/encryptedInputs.ts

@@ -0,0 +1,451 @@
+import {
+  Encryptable,
+  type EncryptableAddress,
+  type EncryptableBool,
+  type EncryptableItem,
+  type EncryptableUint128,
+  type EncryptableUint16,
+  type EncryptableUint32,
+  type EncryptableUint64,
+  type EncryptableUint8,
+  type EncryptedAddressInput,
+  type EncryptedBoolInput,
+  type EncryptedItemInput,
+  type EncryptedUint128Input,
+  type EncryptedUint16Input,
+  type EncryptedUint32Input,
+  type EncryptedUint64Input,
+  type EncryptedUint8Input,
+  type LiteralToPrimitive,
+  type Primitive,
+} from '@cofhe/sdk';
+import type { Abi, AbiFunction, AbiParameter, ExtractAbiFunction } from 'abitype';
+import type { CofheAbiParametersToPrimitiveTypes } from './fhenixMap';
+import { extractArrayParameterType, getAbiFunction, type MaybePartialBy, type ReadonlyWiden } from './utils';
+
+export type CofheInputArgs<abi extends Abi | readonly unknown[] = Abi, functionName extends string = string> = GetArgs<
+  abi,
+  functionName
+>['args'];
+
+type EncryptedInputToInputMap<E extends EncryptedItemInput> = E extends EncryptedBoolInput
+  ? EncryptableBool['data']
+  : E extends EncryptedUint8Input
+    ? EncryptableUint8['data']
+    : E extends EncryptedUint16Input
+      ? EncryptableUint16['data']
+      : E extends EncryptedUint32Input
+        ? EncryptableUint32['data']
+        : E extends EncryptedUint64Input
+          ? EncryptableUint64['data']
+          : E extends EncryptedUint128Input
+            ? EncryptableUint128['data']
+            : E extends EncryptedAddressInput
+              ? EncryptableAddress['data']
+              : never;
+
+type EncryptedInputsToInputs<T> = T extends Primitive
+  ? LiteralToPrimitive<T>
+  : T extends EncryptedItemInput
+    ? EncryptedInputToInputMap<T>
+    : {
+        [K in keyof T]: EncryptedInputsToInputs<T[K]>;
+      };
+
+export type CofheInputArgsPreTransform<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends string = string,
+> = EncryptedInputsToInputs<CofheInputArgs<abi, functionName>>;
+
+/// GetArgs from abitype (not exported from abitype)
+type GetArgs<
+  abi extends Abi | readonly unknown[] = Abi, // `readonly unknown[]` allows for non-const asserted types
+  functionName extends string = string,
+  args extends readonly unknown[] | undefined = readonly [],
+  ///
+  abiFunction extends AbiFunction = abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction,
+  primitiveTypes = CofheAbiParametersToPrimitiveTypes<abiFunction['inputs']>,
+  args_ =
+    | primitiveTypes // show all values
+    | (abi extends Abi
+        ? args extends primitiveTypes // infer value (if valid)
+          ? primitiveTypes extends args // make sure `args` exactly matches `primitiveTypes` (e.g. avoid `args: readonly [{ foo: string; bar: number; }] | readonly [{ foo: string; }]`)
+            ? // make inferred value of `args` match `primitiveTypes` (e.g. avoid union `args: readonly [123n] | readonly [bigint]`)
+              ReadonlyWiden<args>
+            : never
+          : never
+        : never)
+    | (Abi extends abi ? readonly unknown[] : never), // fallback if `abi` is declared as `Abi`
+> = MaybePartialBy<{ args: args_ }, readonly [] extends primitiveTypes ? 'args' : Abi extends abi ? 'args' : string>;
+
+// Runtime helper to check if an internalType is an encrypted input type
+const ENCRYPTED_INPUT_INTERNAL_TYPES = [
+  'struct InEbool',
+  'struct InEuint8',
+  'struct InEuint16',
+  'struct InEuint32',
+  'struct InEuint64',
+  'struct InEuint128',
+  'struct InEaddress',
+] as const;
+type EncryptedInputInternalType = (typeof ENCRYPTED_INPUT_INTERNAL_TYPES)[number];
+
+function transformSingleEncryptedInputToEncryptable(
+  internalType: EncryptedInputInternalType,
+  data: unknown
+): EncryptableItem {
+  switch (internalType) {
+    case 'struct InEbool':
+      return Encryptable.bool(data as boolean);
+    case 'struct InEuint8':
+      return Encryptable.uint8(data as string | bigint);
+    case 'struct InEuint16':
+      return Encryptable.uint16(data as string | bigint);
+    case 'struct InEuint32':
+      return Encryptable.uint32(data as string | bigint);
+    case 'struct InEuint64':
+      return Encryptable.uint64(data as string | bigint);
+    case 'struct InEuint128':
+      return Encryptable.uint128(data as string | bigint);
+    case 'struct InEaddress':
+      return Encryptable.address(data as string | bigint);
+    default:
+      throw new Error(`Unknown encrypted input type: ${internalType}`);
+  }
+}
+
+function transformArrayOfEncryptedInputsToEncryptables(
+  internalType: EncryptedInputInternalType,
+  size: string | undefined,
+  data: unknown
+): EncryptableItem[] {
+  // Ensure data is an array
+  if (!Array.isArray(data)) {
+    throw new Error('Data must be an array');
+  }
+
+  // Ensure length of fixed length tuple matches the length of the data array
+  if (size != null && size !== '' && parseInt(size) !== data.length) {
+    throw new Error(`Array size mismatch: ${size} !== ${data.length}`);
+  }
+
+  // Transform each item in the data array into an encryptable item
+  return data.map((item) => transformSingleEncryptedInputToEncryptable(internalType, item));
+}
+
+// Pathways
+// - type is a tuple && internalType is exactly an encrypted input type (struct InEbool)
+// - - extract the base encrypted type (InEbool) and convert into an encryptable item
+// - type is a tuple && internalType is a tuple of encrypted input types (struct InEuint32[2] / struct InEuint32[])
+// - - extract the base encrypted type and length, and convert into an array of encryptable items
+// - type is a tuple && internalType is not an encrypted input type
+// - - iterate components
+// - type is not a tuple
+// - - throw away
+
+function internalTypeIsEncryptedInput(internalType: string): internalType is EncryptedInputInternalType {
+  return ENCRYPTED_INPUT_INTERNAL_TYPES.includes(internalType as any);
+}
+
+/**
+ * Extracts encryptable values from function arguments based on the ABI.
+ * Transforms raw data values into EncryptableItem objects that can be passed to the encrypt function.
+ *
+ * @param abi - The ABI containing the function definition
+ * @param functionName - Name of the function
+ * @param args - Function arguments in the format of CofheInputArgsPreTransform (raw data values)
+ * @returns Array of EncryptableItem objects ready for encryption
+ */
+export function extractEncryptableValues<TAbi extends Abi, TFunctionName extends string>(
+  abi: TAbi,
+  functionName: TFunctionName,
+  args: CofheInputArgsPreTransform<TAbi, TFunctionName>
+): EncryptableItem[] {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const inputs = abiFunction?.inputs;
+  if (abiFunction == null || inputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+
+  if (!Array.isArray(args)) {
+    throw new Error('Arguments must be an array');
+  }
+
+  // Collect encrypted values as EncryptableItem objects in order (flat array)
+  const encryptableItems: EncryptableItem[] = [];
+
+  // Process each parameter - transforms raw values into EncryptableItem objects
+  function processParameter(param: AbiParameter, value: unknown): void {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+
+    /** 
+      {
+        name: 'inNumber',
+        type: 'tuple',
+        internalType: 'struct InEuint32',
+        components: [
+          {
+            name: 'ctHash',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'securityZone',
+            type: 'uint8',
+            internalType: 'uint8',
+          },
+          {
+            name: 'utype',
+            type: 'uint8',
+            internalType: 'uint8',
+          },
+          {
+            name: 'signature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+        ],
+      }
+    */
+    if (
+      typeHead === 'tuple' &&
+      typeSize == null &&
+      internalTypeHead != null &&
+      internalTypeIsEncryptedInput(internalTypeHead)
+    ) {
+      const encryptable = transformSingleEncryptedInputToEncryptable(internalTypeHead, value);
+      encryptableItems.push(encryptable);
+      return;
+    }
+
+    /**
+      {
+        name: 'inEuint32Array',
+        type: 'tuple[2]',
+        internalType: 'struct InEuint32[2]',
+        components: [
+          {
+            name: 'ctHash',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'securityZone',
+            type: 'uint8',
+            internalType: 'uint8',
+          },
+          {
+            name: 'utype',
+            type: 'uint8',
+            internalType: 'uint8',
+          },
+          {
+            name: 'signature',
+            type: 'bytes',
+            internalType: 'bytes',
+          },
+        ],
+      }
+     */
+    if (
+      typeHead === 'tuple' &&
+      typeSize != null &&
+      internalTypeHead != null &&
+      internalTypeIsEncryptedInput(internalTypeHead)
+    ) {
+      const encryptables = transformArrayOfEncryptedInputsToEncryptables(internalTypeHead, typeSize, value);
+      encryptableItems.push(...encryptables);
+      return;
+    }
+
+    /**
+     {
+        name: 'containsEncryptedInput',
+        type: 'tuple',
+        internalType: 'struct ABITest.ContainsEncryptedInput',
+        components: [
+          {
+            name: 'value',
+            type: 'uint256',
+            internalType: 'uint256',
+          },
+          {
+            name: 'encryptedInput',
+            type: 'tuple',
+            internalType: 'struct InEuint32',
+            components: [
+              {
+                name: 'ctHash',
+                type: 'uint256',
+                internalType: 'uint256',
+              },
+              {
+                name: 'securityZone',
+                type: 'uint8',
+                internalType: 'uint8',
+              },
+              {
+                name: 'utype',
+                type: 'uint8',
+                internalType: 'uint8',
+              },
+              {
+                name: 'signature',
+                type: 'bytes',
+                internalType: 'bytes',
+              },
+            ],
+          },
+        ],
+      }
+     */
+    if (typeHead === 'tuple' && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+      if ('components' in param && Array.isArray(param.components)) {
+        param.components.forEach((component) => {
+          processParameter(component, (value as Record<string, unknown>)[component.name]);
+        });
+      }
+      return;
+    }
+
+    // param.type is not a tuple, so cannot be an encrypted input or contain encrypted inputs
+    return;
+  }
+
+  // Process all inputs
+  inputs.forEach((input, index) => {
+    const arg = args[index];
+    if (arg == null) {
+      throw new Error(`Argument ${index} is undefined`);
+    }
+    processParameter(input, arg);
+  });
+
+  return encryptableItems;
+}
+
+/**
+ * Re-inserts encrypted values back into function arguments based on the ABI.
+ * Takes the extracted values (now encrypted) and the original args structure, and replaces
+ * the encryptable values with their encrypted counterparts.
+ *
+ * This function mirrors the extraction logic in extractEncryptableValues, ensuring values
+ * are inserted in the exact same order and locations where they were extracted.
+ *
+ * @param abi - The ABI containing the function definition
+ * @param functionName - Name of the function
+ * @param args - Original function arguments in the format of CofheInputArgsPreTransform
+ * @param encryptedValues - Encrypted values in the same order as returned by extractEncryptableValues
+ * @returns Function arguments with encrypted values inserted (format of CofheInputArgs)
+ */
+export function insertEncryptedValues<TAbi extends Abi, TFunctionName extends string>(
+  abi: TAbi,
+  functionName: TFunctionName,
+  args: CofheInputArgsPreTransform<TAbi, TFunctionName>,
+  encryptedValues: readonly EncryptedItemInput[]
+): CofheInputArgs<TAbi, TFunctionName> {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const inputs = abiFunction?.inputs;
+  if (abiFunction == null || inputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+
+  if (!Array.isArray(args)) {
+    throw new Error('Arguments must be an array');
+  }
+
+  // Track position in encrypted values array
+  let encryptedIndex = 0;
+
+  // Process each parameter - replaces raw values with encrypted values
+  function processParameter(param: AbiParameter, value: unknown): unknown {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+
+    // Single encrypted input (tuple with encrypted input type)
+    if (
+      typeHead === 'tuple' &&
+      typeSize == null &&
+      internalTypeHead != null &&
+      internalTypeIsEncryptedInput(internalTypeHead)
+    ) {
+      if (encryptedIndex >= encryptedValues.length) {
+        throw new Error(
+          `Not enough encrypted values: expected at least ${encryptedIndex + 1}, got ${encryptedValues.length}`
+        );
+      }
+      const encryptedValue = encryptedValues[encryptedIndex];
+      encryptedIndex++;
+      return encryptedValue;
+    }
+
+    // Array of encrypted inputs (tuple[2] or tuple[] with encrypted input type)
+    if (
+      typeHead === 'tuple' &&
+      typeSize != null &&
+      internalTypeHead != null &&
+      internalTypeIsEncryptedInput(internalTypeHead)
+    ) {
+      // Determine how many encrypted values we need
+      const arrayLength = Array.isArray(value) ? value.length : 0;
+      if (arrayLength === 0) {
+        return [];
+      }
+
+      if (encryptedIndex + arrayLength > encryptedValues.length) {
+        throw new Error(
+          `Not enough encrypted values: expected at least ${encryptedIndex + arrayLength}, got ${encryptedValues.length}`
+        );
+      }
+
+      // Extract the required number of encrypted values
+      const encryptedArray = encryptedValues.slice(encryptedIndex, encryptedIndex + arrayLength);
+      encryptedIndex += arrayLength;
+      return encryptedArray;
+    }
+
+    // Tuple recursive case (not encrypted input)
+    if (typeHead === 'tuple' && (internalTypeHead == null || !internalTypeIsEncryptedInput(internalTypeHead))) {
+      if ('components' in param && Array.isArray(param.components)) {
+        const valueObj = value as Record<string, unknown>;
+        const result: Record<string, unknown> = {};
+
+        // Process each component in order
+        param.components.forEach((component) => {
+          const componentName = component.name;
+          if (componentName) {
+            const componentValue = valueObj[componentName];
+            if (componentValue !== undefined) {
+              result[componentName] = processParameter(component, componentValue);
+            }
+          }
+        });
+
+        return result;
+      }
+      return value;
+    }
+
+    // Not an encrypted input, return original value
+    return value;
+  }
+
+  // Process all inputs in order
+  const result = inputs.map((input, index) => {
+    const arg = args[index];
+    if (arg == null) {
+      throw new Error(`Argument ${index} is undefined`);
+    }
+    return processParameter(input, arg);
+  });
+
+  // Verify we used all encrypted values
+  if (encryptedIndex !== encryptedValues.length) {
+    throw new Error(
+      `Mismatch in encrypted values count: used ${encryptedIndex}, but provided ${encryptedValues.length}`
+    );
+  }
+
+  return result as CofheInputArgs<TAbi, TFunctionName>;
+}