@cofhe/abi 0.2.0

package/src/encryptedReturnTypes.ts

@@ -0,0 +1,279 @@
+import { type Primitive, type LiteralToPrimitive, FheTypes } from '@cofhe/sdk';
+import type { Abi, AbiFunction, ExtractAbiFunction, AbiParameter } from 'abitype';
+import type {
+  EncryptedReturnType,
+  CofheAbiParametersToPrimitiveTypes,
+  EBool,
+  EAddress,
+  EUint128,
+  EUint16,
+  EUint32,
+  EUint64,
+  EUint8,
+} from './fhenixMap';
+import {
+  getAbiFunction,
+  type IsUnion,
+  type UnionToTuple,
+  type ContractReturnType,
+  extractArrayParameterType,
+} from './utils';
+
+type FirstCofheReturnValue<T> = [T] extends [void]
+  ? never
+  : T extends readonly [infer Head, ...(readonly unknown[])]
+    ? Head
+    : T;
+
+type FheTypeFromCofheReturnValue<T> = T extends { utype: infer U }
+  ? U
+  : T extends readonly (infer Element)[]
+    ? FheTypeFromCofheReturnValue<Element>
+    : never;
+
+/**
+ * Extracts the `FheTypes` of the first returned value of a CoFHE call.
+ *
+ * Examples:
+ * - `returns (ebool)` -> `FheTypes.Bool`
+ * - `returns (euint8, euint64)` -> `FheTypes.Uint8`
+ * - `returns (euint16[])` -> `FheTypes.Uint16`
+ */
+export type CofheFirstReturnFheType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends string = string,
+  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,
+> = FheTypeFromCofheReturnValue<FirstCofheReturnValue<CofheReturnType<abi, functionName, args>>>;
+
+export type CofheReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends string = string,
+  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,
+  ///
+  abiFunction extends AbiFunction = (
+    abi extends Abi ? ExtractAbiFunction<abi, functionName> : AbiFunction
+  ) extends infer abiFunction_ extends AbiFunction
+    ? IsUnion<abiFunction_> extends true // narrow overloads by `args` by converting to tuple and filtering out overloads that don't match
+      ? UnionToTuple<abiFunction_> extends infer abiFunctions extends readonly AbiFunction[]
+        ? {
+            [K in keyof abiFunctions]: (
+              readonly unknown[] | undefined extends args // for functions that don't have inputs, `args` can be `undefined` so fallback to `readonly []`
+                ? readonly []
+                : args
+            ) extends CofheAbiParametersToPrimitiveTypes<abiFunctions[K]['inputs'], 'inputs'>
+              ? abiFunctions[K]
+              : never;
+          }[number] // convert back to union (removes `never` tuple entries: `['foo', never, 'bar'][number]` => `'foo' | 'bar'`)
+        : never
+      : abiFunction_
+    : never,
+  outputs extends readonly AbiParameter[] = abiFunction['outputs'],
+  primitiveTypes extends readonly unknown[] = CofheAbiParametersToPrimitiveTypes<outputs, 'outputs'>,
+> = [abiFunction] extends [never]
+  ? unknown // `abiFunction` was not inferrable (e.g. `abi` declared as `Abi`)
+  : readonly unknown[] extends primitiveTypes
+    ? unknown // `abiFunction` was not inferrable (e.g. `abi` not const-asserted)
+    : primitiveTypes extends readonly [] // unwrap `primitiveTypes`
+      ? // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
+        void // no outputs
+      : primitiveTypes extends readonly [infer primitiveType]
+        ? primitiveType // single output
+        : primitiveTypes;
+
+type EncryptedReturnTypeToReturnTypeMap<E extends EncryptedReturnType> = E extends EBool
+  ? boolean
+  : E extends EUint8
+    ? bigint
+    : E extends EUint16
+      ? bigint
+      : E extends EUint32
+        ? bigint
+        : E extends EUint64
+          ? bigint
+          : E extends EUint128
+            ? bigint
+            : E extends EAddress
+              ? string
+              : never;
+
+type EncryptedReturnTypesToReturnTypes<T> = T extends Primitive
+  ? LiteralToPrimitive<T>
+  : T extends EncryptedReturnType
+    ? EncryptedReturnTypeToReturnTypeMap<T>
+    : {
+        [K in keyof T]: EncryptedReturnTypesToReturnTypes<T[K]>;
+      };
+
+export type CofheReturnTypePostTransform<
+  abi extends Abi | readonly unknown[] = Abi,
+  functionName extends string = string,
+  args extends readonly unknown[] | undefined = readonly unknown[] | undefined,
+> = EncryptedReturnTypesToReturnTypes<CofheReturnType<abi, functionName, args>>;
+
+const ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES = [
+  'ebool',
+  'euint8',
+  'euint16',
+  'euint32',
+  'euint64',
+  'euint128',
+  'eaddress',
+] as const;
+type EncryptedReturnTypeInternalType = (typeof ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES)[number];
+
+type EncryptedReturnTypeInternalTypeToReturnTypeMap<T extends EncryptedReturnTypeInternalType> = T extends 'ebool'
+  ? EBool
+  : T extends 'euint8'
+    ? EUint8
+    : T extends 'euint16'
+      ? EUint16
+      : T extends 'euint32'
+        ? EUint32
+        : T extends 'euint64'
+          ? EUint64
+          : T extends 'euint128'
+            ? EUint128
+            : T extends 'eaddress'
+              ? EAddress
+              : never;
+
+function transformSingleEncryptedReturnTypeToReturnType<T extends EncryptedReturnTypeInternalType>(
+  internalType: T,
+  data: bigint
+): EncryptedReturnTypeInternalTypeToReturnTypeMap<T> {
+  switch (internalType) {
+    case 'ebool':
+      return {
+        ctHash: data,
+        utype: FheTypes.Bool,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'euint8':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint8,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'euint16':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint16,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'euint32':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint32,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'euint64':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint64,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'euint128':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint128,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    case 'eaddress':
+      return {
+        ctHash: data,
+        utype: FheTypes.Uint160,
+      } as EncryptedReturnTypeInternalTypeToReturnTypeMap<T>;
+    default:
+      throw new Error(`Unknown encrypted return type: ${internalType}`);
+  }
+}
+
+function transformArrayOfEncryptedReturnTypesToReturnTypes<T extends EncryptedReturnTypeInternalType>(
+  internalType: T,
+  size: string | undefined,
+  data: bigint[]
+): EncryptedReturnTypeInternalTypeToReturnTypeMap<T>[] {
+  // 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 return type
+  return data.map((item) => transformSingleEncryptedReturnTypeToReturnType(internalType, item));
+}
+
+function internalTypeIsEncryptedReturnType(internalType: string): internalType is EncryptedReturnTypeInternalType {
+  return ENCRYPTED_RETURN_TYPE_INTERNAL_TYPES.includes(internalType as any);
+}
+
+export function transformEncryptedReturnTypes<TAbi extends Abi, TFunctionName extends string>(
+  abi: TAbi,
+  functionName: TFunctionName,
+  data: ContractReturnType<TAbi, TFunctionName>
+): CofheReturnType<TAbi, TFunctionName> {
+  const abiFunction = getAbiFunction(abi, functionName);
+  const outputs = abiFunction?.outputs;
+  if (abiFunction == null || outputs == null) {
+    throw new Error(`Function ${functionName} not found in ABI`);
+  }
+  const outputsLength = outputs.length;
+
+  function processParameter(param: AbiParameter, value: unknown): unknown {
+    const [typeHead, typeSize] = extractArrayParameterType(param.type);
+    const [internalTypeHead, internalTypeSize] = extractArrayParameterType(param.internalType);
+
+    // Is encrypted return type
+    if (internalTypeHead != null && internalTypeIsEncryptedReturnType(internalTypeHead)) {
+      // Is single encrypted return type
+      if (internalTypeSize == null) {
+        return transformSingleEncryptedReturnTypeToReturnType(internalTypeHead, value as bigint);
+      }
+
+      // Is array of encrypted return types
+      if (internalTypeSize != null) {
+        console.log('array of encrypted return types', internalTypeHead, internalTypeSize, value);
+        return transformArrayOfEncryptedReturnTypesToReturnTypes(internalTypeHead, internalTypeSize, value as bigint[]);
+      }
+    }
+
+    // Tuple but not an encrypted return type (recursive case)
+    if (typeHead === 'tuple') {
+      if ('components' in param && Array.isArray(param.components)) {
+        const valueObj = value as Record<string, unknown>;
+        const result: Record<string, unknown> = {};
+
+        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 return type, return original value
+    return value;
+  }
+
+  // Process results (array case)
+  if (outputsLength > 1) {
+    if (!Array.isArray(data)) {
+      throw new Error('Data must be an array');
+    }
+    if (outputsLength !== data.length) {
+      throw new Error(`Mismatch in outputs length: ${outputsLength} !== ${data.length}`);
+    }
+    return data.map((item, index) => {
+      return processParameter(outputs[index], item);
+    }) as CofheReturnType<TAbi, TFunctionName>;
+  }
+
+  // Process retuls (single item case)
+  return processParameter(outputs[0], data) as CofheReturnType<TAbi, TFunctionName>;
+}

package/src/fhenixMap.ts

@@ -0,0 +1,162 @@
+import type {
+  EncryptedAddressInput,
+  EncryptedBoolInput,
+  EncryptedUint128Input,
+  EncryptedUint16Input,
+  EncryptedUint32Input,
+  EncryptedUint64Input,
+  EncryptedUint8Input,
+  FheTypes,
+} from '@cofhe/sdk';
+import type {
+  AbiParameter,
+  AbiParameterKind,
+  AbiTypeToPrimitiveType,
+  SolidityTuple,
+  ResolvedRegister,
+  SolidityFixedArraySizeLookup,
+} from 'abitype';
+import type { AbiBasicType, Error, Merge, Tuple, MaybeExtractArrayParameterType } from './utils';
+
+export type EBool = {
+  ctHash: bigint;
+  utype: FheTypes.Bool;
+};
+export type EUint8 = {
+  ctHash: bigint;
+  utype: FheTypes.Uint8;
+};
+export type EUint16 = {
+  ctHash: bigint;
+  utype: FheTypes.Uint16;
+};
+export type EUint32 = {
+  ctHash: bigint;
+  utype: FheTypes.Uint32;
+};
+export type EUint64 = {
+  ctHash: bigint;
+  utype: FheTypes.Uint64;
+};
+export type EUint128 = {
+  ctHash: bigint;
+  utype: FheTypes.Uint128;
+};
+export type EAddress = {
+  ctHash: bigint;
+  utype: FheTypes.Uint160;
+};
+export type EncryptedReturnType = EBool | EUint8 | EUint16 | EUint32 | EUint64 | EUint128 | EAddress;
+
+/**
+ * Narrows {@link EncryptedReturnType} to the specific member matching a given `utype`.
+ *
+ * @example
+ * type T = EncryptedReturnTypeByUtype<FheTypes.Uint32> // EUint32
+ */
+export type EncryptedReturnTypeByUtype<U extends FheTypes> = Extract<EncryptedReturnType, { utype: U }>;
+
+export type FhenixInternalTypeMap = {
+  // Input Structs
+  'struct InEbool': EncryptedBoolInput;
+  'struct InEuint8': EncryptedUint8Input;
+  'struct InEuint16': EncryptedUint16Input;
+  'struct InEuint32': EncryptedUint32Input;
+  'struct InEuint64': EncryptedUint64Input;
+  'struct InEuint128': EncryptedUint128Input;
+  'struct InEaddress': EncryptedAddressInput;
+
+  // Exposed encrypted primitives
+  ebool: EBool;
+  euint8: EUint8;
+  euint16: EUint16;
+  euint32: EUint32;
+  euint64: EUint64;
+  euint128: EUint128;
+  eaddress: EAddress;
+};
+
+export type FhenixInternalTypeMapUnion = keyof FhenixInternalTypeMap;
+
+export type CofheAbiParameterToPrimitiveType<
+  abiParameter extends AbiParameter | { name: string; type: unknown; internalType?: unknown },
+  abiParameterKind extends AbiParameterKind = AbiParameterKind,
+  // 1. Check to see if type is basic (not tuple or array) and can be looked up immediately.
+> = abiParameter['internalType'] extends FhenixInternalTypeMapUnion
+  ? FhenixInternalTypeMap[abiParameter['internalType']]
+  : abiParameter['type'] extends AbiBasicType
+    ? AbiTypeToPrimitiveType<abiParameter['type'], abiParameterKind>
+    : // 2. Check if type is tuple and covert each component
+      abiParameter extends {
+          type: SolidityTuple;
+          components: infer components extends readonly AbiParameter[];
+        }
+      ? CofheAbiComponentsToPrimitiveType<components, abiParameterKind>
+      : // 2.5 Check if type is array of fhenix types (struct InEuint32[2])
+        MaybeExtractArrayParameterType<abiParameter['internalType']> extends [
+            infer head extends FhenixInternalTypeMapUnion,
+            infer size,
+          ]
+        ? CofheArrayToPrimitiveType<head, size>
+        : // 3. Check if type is array.
+          MaybeExtractArrayParameterType<abiParameter['type']> extends [infer head extends string, infer size]
+          ? CofheAbiArrayToPrimitiveType<abiParameter, abiParameterKind, head, size>
+          : // 4. If type is not basic, tuple, or array, we don't know what the type is.
+            // This can happen when a fixed-length array is out of range (`Size` doesn't exist in `SolidityFixedArraySizeLookup`),
+            // the array has depth greater than `ResolvedRegister['arrayMaxDepth']`, etc.
+            ResolvedRegister['strictAbiType'] extends true
+            ? Error<`Unknown type '${abiParameter['type'] & string}'.`>
+            : // 5. If we've gotten this far, let's check for errors in tuple components.
+              // (Happens for recursive tuple typed data types.)
+              abiParameter extends { components: Error<string> }
+              ? abiParameter['components']
+              : unknown;
+
+export type CofheAbiParametersToPrimitiveTypes<
+  abiParameters extends readonly AbiParameter[],
+  abiParameterKind extends AbiParameterKind = AbiParameterKind,
+> = {
+  [key in keyof abiParameters]: CofheAbiParameterToPrimitiveType<abiParameters[key], abiParameterKind>;
+};
+
+type CofheAbiComponentsToPrimitiveType<
+  components extends readonly AbiParameter[],
+  abiParameterKind extends AbiParameterKind,
+> = components extends readonly []
+  ? []
+  : // Compare the original set of names to a "validated"
+    // set where each name is coerced to a string and undefined|"" are excluded
+    components[number]['name'] extends Exclude<components[number]['name'] & string, undefined | ''>
+    ? // If all the original names are present, all tuple parameters are named so return as object
+      {
+        [component in components[number] as component['name'] & {}]: CofheAbiParameterToPrimitiveType<
+          component,
+          abiParameterKind
+        >;
+      }
+    : // Otherwise, has unnamed tuple parameters so return as array
+      {
+        [key in keyof components]: CofheAbiParameterToPrimitiveType<components[key], abiParameterKind>;
+      };
+
+type CofheArrayToPrimitiveType<
+  head extends FhenixInternalTypeMapUnion,
+  size,
+> = size extends keyof SolidityFixedArraySizeLookup
+  ? Tuple<FhenixInternalTypeMap[head], SolidityFixedArraySizeLookup[size]>
+  : readonly FhenixInternalTypeMap[head][];
+
+type CofheAbiArrayToPrimitiveType<
+  abiParameter extends AbiParameter | { name: string; type: unknown },
+  abiParameterKind extends AbiParameterKind,
+  head extends string,
+  size,
+> = size extends keyof SolidityFixedArraySizeLookup
+  ? // Check if size is within range for fixed-length arrays, if so create a tuple.
+    Tuple<
+      CofheAbiParameterToPrimitiveType<Merge<abiParameter, { type: head }>, abiParameterKind>,
+      SolidityFixedArraySizeLookup[size]
+    >
+  : // Otherwise, create an array. Tuples and arrays are created with `[${Size}]` popped off the end
+    // and passed back into the function to continue reducing down to the basic types found in Step 1.
+    readonly CofheAbiParameterToPrimitiveType<Merge<abiParameter, { type: head }>, abiParameterKind>[];

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './encryptedInputs';
+export * from './encryptedReturnTypes';
+export * from './fhenixMap';
+export type { Abi } from 'abitype';
+export type { ContractReturnType } from './utils';
+export { transformEncryptedReturnTypes } from './encryptedReturnTypes';

package/src/mockEncrypt.ts

@@ -0,0 +1,86 @@
+import {
+  FheTypes,
+  type EncryptableItem,
+  type EncryptableToEncryptedItemInputMap,
+  type EncryptedAddressInput,
+  type EncryptedBoolInput,
+  type EncryptedItemInput,
+  type EncryptedItemInputs,
+  type EncryptedUint128Input,
+  type EncryptedUint16Input,
+  type EncryptedUint32Input,
+  type EncryptedUint64Input,
+  type EncryptedUint8Input,
+} from '@cofhe/sdk';
+
+/**
+ * Generates a mock ctHash from the encryptable data.
+ * This is a simple deterministic hash function for testing purposes.
+ */
+export function generateMockCtHash(data: unknown): bigint {
+  if (typeof data === 'boolean') {
+    return BigInt(data ? 1 : 0);
+  }
+  if (typeof data === 'bigint') {
+    return data;
+  }
+  if (typeof data === 'string') {
+    // Simple hash: convert string to number and create a bigint
+    let hash = 0n;
+    for (let i = 0; i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5n) - hash + BigInt(char);
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return hash < 0n ? -hash : hash;
+  }
+  // Fallback: use a simple hash based on string representation
+  return BigInt(
+    Math.abs(
+      JSON.stringify(data)
+        .split('')
+        .reduce((a, b) => {
+          a = (a << 5) - a + b.charCodeAt(0);
+          return a & a;
+        }, 0)
+    )
+  );
+}
+
+/**
+ * Generates a mock signature for testing purposes.
+ * Returns a hex string that looks like a valid signature.
+ */
+function generateMockSignature(): `0x${string}` {
+  return '0xMockSignature';
+}
+
+export function mockEncryptEncryptable<T extends EncryptableItem>(encryptable: T): EncryptedItemInputs<T> {
+  const ctHash = generateMockCtHash(encryptable.data);
+  const signature = generateMockSignature();
+
+  return {
+    ctHash,
+    securityZone: 0,
+    utype: encryptable.utype,
+    signature,
+  } as EncryptedItemInputs<T>;
+}
+
+/**
+ * Converts an EncryptableItem to a mock EncryptedItemInput.
+ * This is useful for testing and development when you don't need actual encryption.
+ *
+ * @param encryptable - The EncryptableItem to convert
+ * @returns A mock EncryptedItemInput with the same utype and securityZone, but with mock ctHash and signature
+ *
+ * @example
+ * const encryptable = Encryptable.uint32(100n);
+ * const mockEncrypted = mockEncryptedInput(encryptable);
+ * // Returns: { ctHash: 100n, securityZone: 0, utype: FheTypes.Uint32, signature: "0x..." }
+ */
+export function mockEncrypt<T extends EncryptableItem[]>(
+  encryptables: [...T] | readonly [...T]
+): [...EncryptedItemInputs<T>] {
+  return encryptables.map(mockEncryptEncryptable) as [...EncryptedItemInputs<[...T]>];
+}

package/src/mockEncryptedInput.ts

@@ -0,0 +1,139 @@
+import {
+  FheTypes,
+  type EncryptableItem,
+  type EncryptedAddressInput,
+  type EncryptedBoolInput,
+  type EncryptedItemInput,
+  type EncryptedUint128Input,
+  type EncryptedUint16Input,
+  type EncryptedUint32Input,
+  type EncryptedUint64Input,
+  type EncryptedUint8Input,
+} from '@cofhe/sdk';
+
+/**
+ * Generates a mock ctHash from the encryptable data.
+ * This is a simple deterministic hash function for testing purposes.
+ */
+function generateMockCtHash(data: unknown): bigint {
+  if (typeof data === 'boolean') {
+    return BigInt(data ? 1 : 0);
+  }
+  if (typeof data === 'bigint') {
+    return data;
+  }
+  if (typeof data === 'string') {
+    // Simple hash: convert string to number and create a bigint
+    let hash = 0n;
+    for (let i = 0; i < data.length; i++) {
+      const char = data.charCodeAt(i);
+      hash = (hash << 5n) - hash + BigInt(char);
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return hash < 0n ? -hash : hash;
+  }
+  // Fallback: use a simple hash based on string representation
+  return BigInt(
+    Math.abs(
+      JSON.stringify(data)
+        .split('')
+        .reduce((a, b) => {
+          a = (a << 5) - a + b.charCodeAt(0);
+          return a & a;
+        }, 0)
+    )
+  );
+}
+
+/**
+ * Generates a mock signature for testing purposes.
+ * Returns a hex string that looks like a valid signature.
+ */
+function generateMockSignature(): `0x${string}` {
+  // Generate a 64-character hex string (32 bytes)
+  const hexChars = '0123456789abcdef';
+  let signature = '0x';
+  for (let i = 0; i < 64; i++) {
+    signature += hexChars[Math.floor(Math.random() * hexChars.length)];
+  }
+  return signature as `0x${string}`;
+}
+
+/**
+ * Converts an EncryptableItem to a mock EncryptedItemInput.
+ * This is useful for testing and development when you don't need actual encryption.
+ *
+ * @param encryptable - The EncryptableItem to convert
+ * @returns A mock EncryptedItemInput with the same utype and securityZone, but with mock ctHash and signature
+ *
+ * @example
+ * const encryptable = Encryptable.uint32(100n);
+ * const mockEncrypted = mockEncryptedInput(encryptable);
+ * // Returns: { ctHash: 100n, securityZone: 0, utype: FheTypes.Uint32, signature: "0x..." }
+ */
+export function mockEncryptedInput<T extends EncryptableItem>(encryptable: T): EncryptedItemInput {
+  const ctHash = generateMockCtHash(encryptable.data);
+  const signature = generateMockSignature();
+
+  // Map based on utype to return the correct specific type
+  switch (encryptable.utype) {
+    case FheTypes.Bool:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Bool,
+        signature,
+      } as EncryptedBoolInput;
+
+    case FheTypes.Uint8:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint8,
+        signature,
+      } as EncryptedUint8Input;
+
+    case FheTypes.Uint16:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint16,
+        signature,
+      } as EncryptedUint16Input;
+
+    case FheTypes.Uint32:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint32,
+        signature,
+      } as EncryptedUint32Input;
+
+    case FheTypes.Uint64:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint64,
+        signature,
+      } as EncryptedUint64Input;
+
+    case FheTypes.Uint128:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint128,
+        signature,
+      } as EncryptedUint128Input;
+
+    case FheTypes.Uint160:
+      return {
+        ctHash,
+        securityZone: 0,
+        utype: FheTypes.Uint160,
+        signature,
+      } as EncryptedAddressInput;
+
+    default:
+      throw new Error(`Unsupported encryptable: ${encryptable}`);
+  }
+}