@cofhe/sdk 0.1.0 → 0.2.0

package/core/types.ts

@@ -0,0 +1,398 @@
+export type TfheInitializer = () => Promise<boolean>;
+
+export interface IStorage {
+  getItem: (name: string) => Promise<any>;
+  setItem: (name: string, value: any) => Promise<void>;
+  removeItem: (name: string) => Promise<void>;
+}
+
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type LiteralToPrimitive<T> = T extends number
+  ? number
+  : T extends bigint
+    ? bigint
+    : T extends string
+      ? string
+      : T extends boolean
+        ? boolean
+        : T extends symbol
+          ? symbol
+          : T extends null
+            ? null
+            : T extends undefined
+              ? undefined
+              : never;
+
+// FHE TYPES
+
+export const FheTypeValues = ['bool', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'address'] as const;
+export type FheTypeValue = (typeof FheTypeValues)[number];
+
+export enum FheTypes {
+  Bool = 0,
+  Uint4 = 1,
+  Uint8 = 2,
+  Uint16 = 3,
+  Uint32 = 4,
+  Uint64 = 5,
+  Uint128 = 6,
+  Uint160 = 7,
+  Uint256 = 8,
+  Uint512 = 9,
+  Uint1024 = 10,
+  Uint2048 = 11,
+  Uint2 = 12,
+  Uint6 = 13,
+  Uint10 = 14,
+  Uint12 = 15,
+  Uint14 = 16,
+  Int2 = 17,
+  Int4 = 18,
+  Int6 = 19,
+  Int8 = 20,
+  Int10 = 21,
+  Int12 = 22,
+  Int14 = 23,
+  Int16 = 24,
+  Int32 = 25,
+  Int64 = 26,
+  Int128 = 27,
+  Int160 = 28,
+  Int256 = 29,
+}
+
+export const FheTypeValueUtype = {
+  bool: FheTypes.Bool,
+  uint8: FheTypes.Uint8,
+  uint16: FheTypes.Uint16,
+  uint32: FheTypes.Uint32,
+  uint64: FheTypes.Uint64,
+  uint128: FheTypes.Uint128,
+  address: FheTypes.Uint160,
+} as const satisfies Record<FheTypeValue, FheTypes>;
+export type FheTypeValueUtypeMap<T extends FheTypeValue> = T extends keyof typeof FheTypeValueUtype
+  ? (typeof FheTypeValueUtype)[T]
+  : never;
+
+/**
+ * List of All FHE uint types (excludes bool and address)
+ */
+export const FheUintUTypes = [
+  FheTypes.Uint8,
+  FheTypes.Uint16,
+  FheTypes.Uint32,
+  FheTypes.Uint64,
+  FheTypes.Uint128,
+  // [U256-DISABLED]
+  // FheTypes.Uint256,
+] as const;
+export type FheUintUTypesType = (typeof FheUintUTypes)[number];
+
+/**
+ * List of All FHE types (uints, bool, and address)
+ */
+export const FheAllUTypes = [
+  FheTypes.Bool,
+  FheTypes.Uint8,
+  FheTypes.Uint16,
+  FheTypes.Uint32,
+  FheTypes.Uint64,
+  FheTypes.Uint128,
+  // [U256-DISABLED]
+  // FheTypes.Uint256,
+  FheTypes.Uint160,
+] as const;
+type FheAllUTypesType = (typeof FheAllUTypes)[number];
+
+// ENCRYPT
+
+export type EncryptedNumber = {
+  data: Uint8Array;
+  securityZone: number;
+};
+
+export type EncryptedItemInput<TSignature = string> = {
+  ctHash: bigint;
+  securityZone: number;
+  utype: FheTypes;
+  signature: TSignature;
+};
+
+export function assertCorrectEncryptedItemInput(
+  input: EncryptedItemInput
+): asserts input is EncryptedItemInput<`0x${string}`> {
+  if (!input.signature.startsWith('0x')) throw new Error('Signature must be a hex string starting with 0x');
+}
+
+export type EncryptedBoolInput = EncryptedItemInput & {
+  utype: FheTypes.Bool;
+};
+export type EncryptedUint8Input = EncryptedItemInput & {
+  utype: FheTypes.Uint8;
+};
+export type EncryptedUint16Input = EncryptedItemInput & {
+  utype: FheTypes.Uint16;
+};
+export type EncryptedUint32Input = EncryptedItemInput & {
+  utype: FheTypes.Uint32;
+};
+export type EncryptedUint64Input = EncryptedItemInput & {
+  utype: FheTypes.Uint64;
+};
+export type EncryptedUint128Input = EncryptedItemInput & {
+  utype: FheTypes.Uint128;
+};
+// [U256-DISABLED]
+// export type EncryptedUint256Input = EncryptedItemInput & {
+//   utype: FheTypes.Uint256;
+// };
+export type EncryptedAddressInput = EncryptedItemInput & {
+  utype: FheTypes.Uint160;
+};
+
+export type EncryptableBase<U extends FheTypes, D> = {
+  data: D;
+  securityZone: number;
+  utype: U;
+};
+
+export type EncryptableBool = EncryptableBase<FheTypes.Bool, boolean>;
+export type EncryptableUint8 = EncryptableBase<FheTypes.Uint8, string | bigint>;
+export type EncryptableUint16 = EncryptableBase<FheTypes.Uint16, string | bigint>;
+export type EncryptableUint32 = EncryptableBase<FheTypes.Uint32, string | bigint>;
+export type EncryptableUint64 = EncryptableBase<FheTypes.Uint64, string | bigint>;
+export type EncryptableUint128 = EncryptableBase<FheTypes.Uint128, string | bigint>;
+// [U256-DISABLED]
+// export type EncryptableUint256 = EncryptableBase<FheTypes.Uint256, string | bigint>;
+export type EncryptableAddress = EncryptableBase<FheTypes.Uint160, string | bigint>;
+
+/**
+ * Maps FheTypeValue to its corresponding Encryptable type
+ * If a new FheTypeValue is added, this type must be updated to include it
+ */
+type EncryptableTypeMap = {
+  bool: EncryptableBool;
+  address: EncryptableAddress;
+  uint8: EncryptableUint8;
+  uint16: EncryptableUint16;
+  uint32: EncryptableUint32;
+  uint64: EncryptableUint64;
+  uint128: EncryptableUint128;
+  // [U256-DISABLED]
+  // uint256: EncryptableUint256;
+};
+
+/**
+ * Ensures all FheTypeValue keys are present as factory functions.
+ * TypeScript will error if EncryptableTypeMap is missing any FheTypeValue key.
+ */
+type EncryptableFactories = {
+  [K in FheTypeValue]: (data: EncryptableTypeMap[K]['data'], securityZone?: number) => EncryptableTypeMap[K];
+};
+
+type EncryptableFactory = EncryptableFactories & {
+  create: {
+    (type: 'bool', data: EncryptableBool['data'], securityZone?: number): EncryptableBool;
+    (type: 'address', data: EncryptableAddress['data'], securityZone?: number): EncryptableAddress;
+    (type: 'uint8', data: EncryptableUint8['data'], securityZone?: number): EncryptableUint8;
+    (type: 'uint16', data: EncryptableUint16['data'], securityZone?: number): EncryptableUint16;
+    (type: 'uint32', data: EncryptableUint32['data'], securityZone?: number): EncryptableUint32;
+    (type: 'uint64', data: EncryptableUint64['data'], securityZone?: number): EncryptableUint64;
+    (type: 'uint128', data: EncryptableUint128['data'], securityZone?: number): EncryptableUint128;
+    // [U256-DISABLED]
+    // (type: 'uint256', data: EncryptableUint256['data'], securityZone?: number): EncryptableUint256;
+
+    (type: FheTypeValue, data: EncryptableItem['data'], securityZone?: number): EncryptableItem;
+  };
+};
+
+const EncryptableFactoriesImpl = {
+  bool: (data: EncryptableBool['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Bool }),
+  address: (data: EncryptableAddress['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint160 }),
+  uint8: (data: EncryptableUint8['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint8 }),
+  uint16: (data: EncryptableUint16['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint16 }),
+  uint32: (data: EncryptableUint32['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint32 }),
+  uint64: (data: EncryptableUint64['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint64 }),
+  uint128: (data: EncryptableUint128['data'], securityZone = 0) => ({ data, securityZone, utype: FheTypes.Uint128 }),
+  // [U256-DISABLED]
+  // uint256: (data: EncryptableUint256['data'], securityZone = 0) =>
+  //   ({ data, securityZone, utype: FheTypes.Uint256 }) as EncryptableUint256,
+} satisfies EncryptableFactories;
+
+/* eslint-disable no-redeclare */
+function createEncryptableByLiteral(
+  type: 'bool',
+  data: EncryptableBool['data'],
+  securityZone?: number
+): EncryptableBool;
+function createEncryptableByLiteral(
+  type: 'address',
+  data: EncryptableAddress['data'],
+  securityZone?: number
+): EncryptableAddress;
+function createEncryptableByLiteral(
+  type: 'uint8',
+  data: EncryptableUint8['data'],
+  securityZone?: number
+): EncryptableUint8;
+function createEncryptableByLiteral(
+  type: 'uint16',
+  data: EncryptableUint16['data'],
+  securityZone?: number
+): EncryptableUint16;
+function createEncryptableByLiteral(
+  type: 'uint32',
+  data: EncryptableUint32['data'],
+  securityZone?: number
+): EncryptableUint32;
+function createEncryptableByLiteral(
+  type: 'uint64',
+  data: EncryptableUint64['data'],
+  securityZone?: number
+): EncryptableUint64;
+function createEncryptableByLiteral(
+  type: 'uint128',
+  data: EncryptableUint128['data'],
+  securityZone?: number
+): EncryptableUint128;
+function createEncryptableByLiteral(
+  type: FheTypeValue,
+  data: EncryptableItem['data'],
+  securityZone?: number
+): EncryptableItem;
+function createEncryptableByLiteral(
+  type: FheTypeValue,
+  data: EncryptableItem['data'],
+  securityZone = 0
+): EncryptableItem {
+  switch (type) {
+    case 'bool': {
+      if (typeof data !== 'boolean') throw new Error('Bool encryptable data must be boolean');
+      return EncryptableFactoriesImpl.bool(data, securityZone);
+    }
+    case 'address':
+    case 'uint8':
+    case 'uint16':
+    case 'uint32':
+    case 'uint64':
+    case 'uint128': {
+      if (typeof data === 'boolean') throw new Error('Uint encryptable data must be string or bigint');
+      return EncryptableFactoriesImpl[type](data, securityZone);
+    }
+    default: {
+      // Exhaustiveness guard
+      const _exhaustive: never = type;
+      throw new Error(`Unsupported encryptable type: ${_exhaustive}`);
+    }
+  }
+}
+/* eslint-enable no-redeclare */
+
+export const Encryptable = {
+  ...EncryptableFactoriesImpl,
+  create: createEncryptableByLiteral,
+} satisfies EncryptableFactory;
+
+export type EncryptableItem =
+  | EncryptableBool
+  | EncryptableUint8
+  | EncryptableUint16
+  | EncryptableUint32
+  | EncryptableUint64
+  | EncryptableUint128
+  // [U256-DISABLED]
+  // | EncryptableUint256
+  | EncryptableAddress;
+
+export type EncryptableItemByFheType<T extends FheTypes> = T extends FheTypes.Bool
+  ? EncryptableBool
+  : T extends FheTypes.Uint8
+    ? EncryptableUint8
+    : T extends FheTypes.Uint16
+      ? EncryptableUint16
+      : T extends FheTypes.Uint32
+        ? EncryptableUint32
+        : T extends FheTypes.Uint64
+          ? EncryptableUint64
+          : T extends FheTypes.Uint128
+            ? EncryptableUint128
+            : // [U256-DISABLED]
+              // : T extends FheTypes.Uint256
+              //   ? EncryptableUint256
+              T extends FheTypes.Uint160
+              ? EncryptableAddress
+              : never;
+
+// COFHE Encrypt
+export type EncryptableToEncryptedItemInputMap<E extends EncryptableItem> = E extends EncryptableBool
+  ? EncryptedBoolInput
+  : E extends EncryptableUint8
+    ? EncryptedUint8Input
+    : E extends EncryptableUint16
+      ? EncryptedUint16Input
+      : E extends EncryptableUint32
+        ? EncryptedUint32Input
+        : E extends EncryptableUint64
+          ? EncryptedUint64Input
+          : E extends EncryptableUint128
+            ? EncryptedUint128Input
+            : // [U256-DISABLED]
+              // : E extends EncryptableUint256
+              //   ? EncryptedUint256Input
+              E extends EncryptableAddress
+              ? EncryptedAddressInput
+              : never;
+
+export type EncryptedItemInputs<T> = T extends Primitive
+  ? LiteralToPrimitive<T>
+  : T extends EncryptableItem
+    ? EncryptableToEncryptedItemInputMap<T>
+    : {
+        [K in keyof T]: EncryptedItemInputs<T[K]>;
+      };
+
+export function isEncryptableItem(value: unknown): value is EncryptableItem {
+  return (
+    // Is object and exists
+    typeof value === 'object' &&
+    value !== null &&
+    // Has securityZone
+    'securityZone' in value &&
+    typeof value.securityZone === 'number' &&
+    // Has utype
+    'utype' in value &&
+    FheAllUTypes.includes(value.utype as FheAllUTypesType) &&
+    // Has data
+    'data' in value &&
+    ['string', 'number', 'bigint', 'boolean'].includes(typeof value.data)
+  );
+}
+
+export enum EncryptStep {
+  InitTfhe = 'initTfhe',
+  FetchKeys = 'fetchKeys',
+  Pack = 'pack',
+  Prove = 'prove',
+  Verify = 'verify',
+}
+
+export function isLastEncryptionStep(step: EncryptStep): boolean {
+  return step === EncryptStep.Verify;
+}
+
+export type EncryptStepCallbackContext = Record<string, any> & {
+  isStart: boolean;
+  isEnd: boolean;
+  duration: number;
+};
+export type EncryptStepCallbackFunction = (state: EncryptStep, context?: EncryptStepCallbackContext) => void;
+
+// DECRYPT
+
+export type UnsealedItem<U extends FheTypes> = U extends FheTypes.Bool
+  ? boolean
+  : U extends FheTypes.Uint160
+    ? string
+    : U extends FheUintUTypesType
+      ? bigint
+      : never;

package/core/utils.ts

@@ -0,0 +1,130 @@
+import { type PublicClient, type WalletClient } from 'viem';
+import { CofhesdkError, CofhesdkErrorCode } from './error.js';
+import { Encryptable, FheTypes } from './types.js';
+
+export const toHexString = (bytes: Uint8Array) =>
+  bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+
+export const fromHexString = (hexString: string): Uint8Array => {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, '').match(/.{1,2}/g);
+  if (!arr) return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+};
+
+export const toBigIntOrThrow = (value: bigint | string): bigint => {
+  if (typeof value === 'bigint') {
+    return value;
+  }
+
+  try {
+    return BigInt(value);
+  } catch (error) {
+    throw new Error('Invalid input: Unable to convert to bigint');
+  }
+};
+
+export const validateBigIntInRange = (value: bigint, max: bigint, min: bigint = 0n): void => {
+  if (typeof value !== 'bigint') {
+    throw new Error('Value must be of type bigint');
+  }
+
+  if (value > max || value < min) {
+    throw new Error(`Value out of range: ${max} - ${min}, try a different uint type`);
+  }
+};
+
+// Helper function to convert hex string to bytes
+export const hexToBytes = (hex: string): Uint8Array => {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+};
+
+export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function getPublicClientChainID(publicClient: PublicClient) {
+  let chainId: number | null = null;
+  try {
+    chainId = publicClient.chain?.id ?? (await publicClient.getChainId());
+  } catch (e) {
+    throw new CofhesdkError({
+      code: CofhesdkErrorCode.PublicWalletGetChainIdFailed,
+      message: 'getting chain ID from public client failed',
+      cause: e instanceof Error ? e : undefined,
+    });
+  }
+  if (chainId === null) {
+    throw new CofhesdkError({
+      code: CofhesdkErrorCode.PublicWalletGetChainIdFailed,
+      message: 'chain ID from public client is null',
+    });
+  }
+  return chainId;
+}
+
+export async function getWalletClientAccount(walletClient: WalletClient) {
+  let address: `0x${string}` | undefined;
+  try {
+    address = walletClient.account?.address;
+    if (!address) {
+      address = (await walletClient.getAddresses())?.[0];
+    }
+  } catch (e) {
+    throw new CofhesdkError({
+      code: CofhesdkErrorCode.PublicWalletGetAddressesFailed,
+      message: 'getting address from wallet client failed',
+      cause: e instanceof Error ? e : undefined,
+    });
+  }
+  if (!address) {
+    throw new CofhesdkError({
+      code: CofhesdkErrorCode.PublicWalletGetAddressesFailed,
+      message: 'address from wallet client is null',
+    });
+  }
+  return address;
+}
+
+/**
+ * Converts FheTypes enum to string representation for serialization
+ * Used when passing data to Web Workers or other serialization contexts
+ */
+export function fheTypeToString(utype: FheTypes): string {
+  switch (utype) {
+    case FheTypes.Bool:
+      return 'bool';
+    case FheTypes.Uint4:
+      return 'uint4';
+    case FheTypes.Uint8:
+      return 'uint8';
+    case FheTypes.Uint16:
+      return 'uint16';
+    case FheTypes.Uint32:
+      return 'uint32';
+    case FheTypes.Uint64:
+      return 'uint64';
+    case FheTypes.Uint128:
+      return 'uint128';
+    case FheTypes.Uint160:
+      return 'uint160';
+    case FheTypes.Uint256:
+      return 'uint256';
+    case FheTypes.Uint512:
+      return 'uint512';
+    case FheTypes.Uint1024:
+      return 'uint1024';
+    case FheTypes.Uint2048:
+      return 'uint2048';
+    case FheTypes.Uint2:
+      return 'uint2';
+    case FheTypes.Uint6:
+      return 'uint6';
+    case FheTypes.Uint10:
+      return 'uint10';
+    default:
+      throw new Error(`Unknown FheType: ${utype}`);
+  }
+}

package/dist/adapters.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+var viem = require('viem');
+var accounts = require('viem/accounts');
+
+// adapters/ethers5.ts
+async function Ethers5Adapter(provider, signer) {
+  const transport = provider && "send" in provider && typeof provider.send === "function" ? (
+    // @ts-ignore - ethers5 provider.send is not typed
+    viem.custom({ request: ({ method, params }) => provider.send(method, params ?? []) })
+  ) : (() => {
+    throw new Error("Provider does not support EIP-1193 interface");
+  })();
+  const address = await signer.getAddress();
+  let account;
+  if ("privateKey" in signer && typeof signer.privateKey === "string") {
+    account = accounts.privateKeyToAccount(signer.privateKey);
+  } else if (provider && typeof provider.send === "function") {
+    account = address;
+  } else {
+    throw new Error("Signer does not expose a private key and no injected wallet is available.");
+  }
+  const publicClient = viem.createPublicClient({ transport });
+  const walletClient = viem.createWalletClient({ transport, account });
+  return { publicClient, walletClient };
+}
+async function Ethers6Adapter(provider, signer) {
+  const transport = provider && "send" in provider && typeof provider.send === "function" ? (
+    // @ts-ignore - ethers6 provider.send is not typed
+    viem.custom({ request: ({ method, params }) => provider.send(method, params ?? []) })
+  ) : (() => {
+    throw new Error("Provider does not support EIP-1193 interface");
+  })();
+  const address = await signer.getAddress();
+  let account;
+  if ("privateKey" in signer && typeof signer.privateKey === "string") {
+    account = accounts.privateKeyToAccount(signer.privateKey);
+  } else if (provider && typeof provider.send === "function") {
+    account = address;
+  } else {
+    throw new Error("Signer does not expose a private key and no injected wallet is available.");
+  }
+  const publicClient = viem.createPublicClient({ transport });
+  const walletClient = viem.createWalletClient({ transport, account });
+  return { publicClient, walletClient };
+}
+async function WagmiAdapter(walletClient, publicClient) {
+  if (!walletClient) {
+    throw new Error("WalletClient is required");
+  }
+  if (!publicClient) {
+    throw new Error("PublicClient is required");
+  }
+  return {
+    publicClient,
+    walletClient
+  };
+}
+async function HardhatSignerAdapter(signer) {
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error("Signer must have a provider");
+  }
+  const transport = viem.custom({
+    request: async ({ method, params }) => {
+      if ("request" in provider && typeof provider.request === "function") {
+        return await provider.request({ method, params });
+      } else if ("send" in provider && typeof provider.send === "function") {
+        return await provider.send(
+          method,
+          params || []
+        );
+      } else {
+        throw new Error("Provider does not support EIP-1193 request method");
+      }
+    }
+  });
+  const address = await signer.getAddress();
+  const account = address;
+  const publicClient = viem.createPublicClient({ transport });
+  const walletClient = viem.createWalletClient({ transport, account });
+  return { publicClient, walletClient };
+}
+
+exports.Ethers5Adapter = Ethers5Adapter;
+exports.Ethers6Adapter = Ethers6Adapter;
+exports.HardhatSignerAdapter = HardhatSignerAdapter;
+exports.WagmiAdapter = WagmiAdapter;