@fhevm/sdk 1.1.0-alpha.4 → 1.1.0-alpha.6

package/core/modules/decrypt/module/init-p.ts

@@ -1,86 +1,172 @@
 import type { FhevmRuntime, FhevmRuntimeConfig } from '../../../types/coreFhevmRuntime.js';
-import type { GetTkmsModuleInfoReturnType, TkmsModuleInfo } from '../types.js';
+import type {
+  GetTkmsModuleInfoParameters,
+  GetTkmsModuleInfoReturnType,
+  InitTkmsModuleParameters,
+  TkmsModuleInfo,
+} from '../types.js';
 import type { KmsLibApi, TkmsVersion } from '../../../../wasm/tkms/KmsLibApi.js';
-import type { KmsAssetMetadata } from '../../../../wasm/tkms/loadKmsLib.js';
-import { isBrowserLike } from '../../../base/isomorphicWorker.js';
+import type { KmsAssetMetadata, KmsAssets } from '../../../../wasm/tkms/loadKmsLib.js';
+import { isBrowserLike } from '../../../base/environment.js';
 import { isomorphicCompileVerifiedWasm, isomorphicCompileWasmFromBase64 } from '../../../base/wasm.js';
 import { assertIsFhevmRuntime } from '../../../runtime/CoreFhevmRuntime-p.js';
-import { resolveTkmsModuleVersion } from '../../../../wasm/tkmsModuleVersion-p.js';
-import { wasmBaseUrl } from '../../../../wasm/wasmBaseUrl.js';
 import { kmsAssetsWithVersion, loadKmsLib, loadKmsWasmBase64 } from '../../../../wasm/tkms/loadKmsLib.js';
+import { isomorphicFileUrlExists } from '../../../base/isomorphicFs.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// Pure JS file (not compiled by tsc) — provides cross-platform base URL
-// for resolving WASM paths. Uses import.meta.url in ESM, __filename in CJS.
-
 // (Node only) Path relative to src/wasm/ where wasmBaseUrl is anchored
-const nodeDefaultLocateFile = (file: string): URL => {
+const nodeDefaultLocateFile = async (file: string): Promise<URL> => {
+  // Pure JS file (not compiled by tsc) — provides cross-platform base URL
+  // for resolving WASM paths. Uses import.meta.url in ESM, __filename in CJS.
+  const { wasmBaseUrl } = await import('../../../../wasm/wasmBaseUrl.js');
   return new URL(`./tkms/${file}`, wasmBaseUrl);
 };
 
+////////////////////////////////////////////////////////////////////////////////
+
+type KmsAssetResolution = 'user' | 'node' | 'none';
+
 type ResolvedKmsAsset = KmsAssetMetadata & {
   readonly url: URL | undefined;
+  readonly resolution: KmsAssetResolution;
+};
+
+type ResolvedKmsAssets = {
+  readonly wasm: ResolvedKmsAsset;
 };
 
-function _resolveKmsAsset(asset: KmsAssetMetadata, locateFile: FhevmRuntimeConfig['locateFile']): ResolvedKmsAsset {
+////////////////////////////////////////////////////////////////////////////////
+
+async function _resolveSingleKmsAsset(
+  asset: KmsAssetMetadata,
+  locateFile: FhevmRuntimeConfig['locateFile'],
+): Promise<ResolvedKmsAsset> {
   let url: URL | undefined;
+  let resolution: KmsAssetResolution = 'none';
 
   if (locateFile !== undefined) {
-    url = locateFile(asset.filename);
+    const located = locateFile(asset.filename) as unknown;
+    if (located === null || located === undefined) {
+      url = undefined;
+    } else if (located instanceof URL) {
+      url = located;
+    } else {
+      throw new TypeError(
+        `Invalid locateFile result for TKMS asset '${asset.filename}': expected URL, null, or undefined.`,
+      );
+    }
+    resolution = 'user';
   } else if (!isBrowserLike()) {
-    url = nodeDefaultLocateFile(asset.localRelativePath);
+    url = await nodeDefaultLocateFile(asset.localRelativePath);
+    resolution = 'node';
+  }
+
+  return Object.freeze({ ...asset, url, resolution });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+async function _resolveKmsAssets(
+  assets: KmsAssets,
+  locateFile: FhevmRuntimeConfig['locateFile'],
+): Promise<{ readonly wasm: ResolvedKmsAsset }> {
+  let wasm = await _resolveSingleKmsAsset(assets.wasm, locateFile);
+
+  // Only auto-derived ('node') file:// URLs need on-disk validation; the mode is
+  // shared across all assets, so checking one is enough to know the set's mode.
+  if (wasm.resolution === 'node') {
+    const allExist = await isomorphicFileUrlExists(wasm.url);
+    if (!allExist) {
+      wasm = Object.freeze({ ...wasm, url: undefined });
+    }
   }
 
-  return Object.freeze({ ...asset, url });
+  return { wasm };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _logResolvedKmsAssets(resolvedAssets: ResolvedKmsAssets, logger: FhevmRuntimeConfig['logger']): void {
+  const { wasm } = resolvedAssets;
+  if (wasm.resolution === 'user') {
+    logger?.debug(`resolve tkms wasm filename using 'locateFile' function: ${wasm.filename} -> url: ${wasm.url}`);
+  } else if (wasm.resolution === 'node') {
+    if (wasm.url === undefined) {
+      // Auto-derived assets were missing on disk (e.g. a bundler such as Turbopack
+      // relocated the package) and were cleared by _resolveTkmsAssets -> base64.
+      logger?.debug(
+        `tkms auto-derived assets not found on disk (bundler relocation?); using embedded base64 ` +
+          `(wasm: ${wasm.localRelativePath})`,
+      );
+    } else {
+      logger?.debug(`resolve tkms wasm local path: ${wasm.localRelativePath} -> url: ${wasm.url}`);
+    }
+  } else {
+    // 'none': browser zero-config (no 'locateFile', not Node) -> embedded base64.
+    logger?.debug(`resolve tkms assets using embedded base64 (browser, no 'locateFile')`);
+  }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 type ResolvedTkmsModuleConfig = {
   readonly version: TkmsVersion;
-  readonly wasm: ResolvedKmsAsset;
+  readonly assets: ResolvedKmsAssets;
   readonly logger: FhevmRuntimeConfig['logger'];
 };
 
-let resolvedTkmsModuleConfig: ResolvedTkmsModuleConfig | undefined = undefined;
+const resolvedTkmsModuleConfigByVersion = new Map<TkmsVersion, ResolvedTkmsModuleConfig>();
+const resolvingTkmsModuleConfigPromiseByVersion = new Map<TkmsVersion, Promise<ResolvedTkmsModuleConfig>>();
 
 /**
  * @internal
- * Returns the existing resolved config, or resolves it from the runtime config.
+ * Returns the existing resolved config for a TKMS version, or resolves it from
+ * the runtime config.
  */
-function _getOrResolveTkmsModuleConfig(runtime: FhevmRuntime): ResolvedTkmsModuleConfig {
-  if (resolvedTkmsModuleConfig !== undefined) return resolvedTkmsModuleConfig;
+async function _getOrResolveTkmsModuleConfig(
+  runtime: FhevmRuntime,
+  tkmsVersion: TkmsVersion,
+): Promise<ResolvedTkmsModuleConfig> {
+  const resolvedTkmsModuleConfig = resolvedTkmsModuleConfigByVersion.get(tkmsVersion);
+  if (resolvedTkmsModuleConfig !== undefined) {
+    return resolvedTkmsModuleConfig;
+  }
 
-  const version = resolveTkmsModuleVersion(runtime.config);
+  let resolvingTkmsModuleConfigPromise = resolvingTkmsModuleConfigPromiseByVersion.get(tkmsVersion);
+  if (resolvingTkmsModuleConfigPromise === undefined) {
+    resolvingTkmsModuleConfigPromise = _resolveTkmsModuleConfig(runtime.config, tkmsVersion)
+      .then((cfg) => {
+        resolvedTkmsModuleConfigByVersion.set(tkmsVersion, cfg);
+        return cfg;
+      })
+      .catch((error: unknown) => {
+        resolvingTkmsModuleConfigPromiseByVersion.delete(tkmsVersion);
+        throw error;
+      });
+
+    resolvingTkmsModuleConfigPromiseByVersion.set(tkmsVersion, resolvingTkmsModuleConfigPromise);
+  }
 
-  resolvedTkmsModuleConfig = _resolveTkmsModuleConfig(runtime.config, version);
-  return resolvedTkmsModuleConfig;
+  return resolvingTkmsModuleConfigPromise;
 }
 
-function _resolveTkmsModuleConfig(parameters: FhevmRuntimeConfig, version: TkmsVersion): ResolvedTkmsModuleConfig {
-  if (cachedTkmsModulePromise !== undefined) {
-    throw new Error('Cannot configure module after initialization has started');
-  }
-
+async function _resolveTkmsModuleConfig(
+  parameters: FhevmRuntimeConfig,
+  version: TkmsVersion,
+): Promise<ResolvedTkmsModuleConfig> {
   const { locateFile } = parameters;
 
   const assets = kmsAssetsWithVersion(version);
-  const wasm = _resolveKmsAsset(assets.wasm, locateFile);
 
-  if (locateFile !== undefined) {
-    parameters.logger?.debug(`resolve kms wasm filename: ${wasm.filename} -> url: ${wasm.url}`);
-  } else {
-    /*
-      if run in Node only, use defaultLocateFile!
-    */
-    if (!isBrowserLike()) {
-      parameters.logger?.debug(`resolve kms wasm local path: ${wasm.localRelativePath} -> url: ${wasm.url}`);
-    }
-  }
+  const resolvedAssets = await _resolveKmsAssets(assets, locateFile);
+
+  _logResolvedKmsAssets(resolvedAssets, parameters.logger);
 
   // if wasmUrl is undefined, use base64 code instead
   const cfg = {
     version,
-    wasm,
+    assets: resolvedAssets,
     logger: parameters.logger,
   };
 
@@ -93,72 +179,93 @@ function _resolveTkmsModuleConfig(parameters: FhevmRuntimeConfig, version: TkmsV
 // initTkmsModule
 ////////////////////////////////////////////////////////////////////////////////
 
+const ownerUidByVersion = new Map<TkmsVersion, string>();
+const cachedTkmsModulePromiseByVersion = new Map<TkmsVersion, Promise<KmsLibApi>>();
+const moduleInfoByVersion = new Map<TkmsVersion, TkmsModuleInfo>();
+
+////////////////////////////////////////////////////////////////////////////////
+
 type TkmsInitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
-type InitTkmsModuleParameters = {
+type TkmsLibInitAsyncParameters = {
   readonly module_or_path: TkmsInitInput | Promise<TkmsInitInput>;
 };
 
-let cachedTkmsModulePromise: Promise<KmsLibApi> | undefined;
-let ownerUid: string | undefined = undefined;
-
-export async function initTkmsModule(runtime: FhevmRuntime): Promise<KmsLibApi> {
+export async function initTkmsModule(runtime: FhevmRuntime, parameters: InitTkmsModuleParameters): Promise<KmsLibApi> {
   assertIsFhevmRuntime(runtime, {});
 
+  const ownerUid = ownerUidByVersion.get(parameters.tkmsVersion);
   if (ownerUid !== undefined && runtime.uid !== ownerUid) {
     throw new Error(
       `Decrypt WASM module is already owned by runtime '${ownerUid}' and cannot be shared with runtime '${runtime.uid}'`,
     );
   }
 
-  ownerUid = runtime.uid;
+  ownerUidByVersion.set(parameters.tkmsVersion, runtime.uid);
 
-  // Cache the TKMS initialization promise once and keep it cached even if it
-  // rejects.
+  // Cache the whole initialization promise before the first await. Several
+  // clients may call initTkmsModule concurrently during startup.
   //
-  // Retry is not supported:
-  // -----------------------
-  // The underlying KMS/WASM bindings
-  // keep module-level state that cannot be reset reliably after a partial
-  // initialization failure; later callers should observe the original error
-  // instead of retrying against half-initialized state.
+  // Retry is not supported
+
+  let cachedTkmsModulePromise = cachedTkmsModulePromiseByVersion.get(parameters.tkmsVersion);
   if (cachedTkmsModulePromise === undefined) {
-    // resolve is sync
-    const cfg = _getOrResolveTkmsModuleConfig(runtime);
-    cachedTkmsModulePromise = _initTkmsModule(cfg);
+    cachedTkmsModulePromise = (async () => {
+      // resolve is async
+      const cfg = await _getOrResolveTkmsModuleConfig(runtime, parameters.tkmsVersion);
+      return await _initTkmsModule(cfg);
+    })();
+
+    cachedTkmsModulePromiseByVersion.set(parameters.tkmsVersion, cachedTkmsModulePromise);
   }
 
   return cachedTkmsModulePromise;
 }
 
-let moduleInfo: TkmsModuleInfo | undefined = undefined;
+async function _compileWasmModule(cfg: ResolvedTkmsModuleConfig): Promise<WebAssembly.Module> {
+  let wasmModule;
+
+  if (cfg.assets.wasm.url !== undefined) {
+    cfg.logger?.debug(`compile tkms verified wasm at: ${cfg.assets.wasm.url}`);
+    wasmModule = await isomorphicCompileVerifiedWasm(cfg.assets.wasm.url, cfg.assets.wasm.sha256);
+  } else {
+    const { tkmsWasmBase64, tkmsWasmBase64CompressionFormat } = await loadKmsWasmBase64(cfg.version);
+    cfg.logger?.debug(
+      `compile tkms wasm from embedded base64 (compression:${tkmsWasmBase64CompressionFormat ?? 'none'})`,
+    );
+    wasmModule = await isomorphicCompileWasmFromBase64(tkmsWasmBase64, tkmsWasmBase64CompressionFormat);
+  }
+
+  return wasmModule;
+}
 
 async function _initTkmsModule(cfg: ResolvedTkmsModuleConfig): Promise<KmsLibApi> {
   const kmsLib = await loadKmsLib(cfg.version);
 
   // Compile WASM module (see matrix in types.ts)
-  let wasmModule;
-  if (cfg.wasm.url !== undefined) {
-    cfg.logger?.debug(`compile verified wasm at: ${cfg.wasm.url}`);
-    wasmModule = await isomorphicCompileVerifiedWasm(cfg.wasm.url, cfg.wasm.sha256);
-  } else {
-    const { tkmsWasmBase64, tkmsWasmBase64IsGzipped } = await loadKmsWasmBase64(cfg.version);
-    cfg.logger?.debug(`compile wasm from embedded base64 (compression:${tkmsWasmBase64IsGzipped})`);
-    wasmModule = await isomorphicCompileWasmFromBase64(tkmsWasmBase64, tkmsWasmBase64IsGzipped ? 'gzip' : undefined);
-  }
+  const wasmModule = await _compileWasmModule(cfg);
 
-  const input: InitTkmsModuleParameters = { module_or_path: wasmModule };
+  const input: TkmsLibInitAsyncParameters = { module_or_path: wasmModule };
 
   await kmsLib.initAsync(input);
 
   // Note: init_panic_hook is not exposed by kms_lib
   const wasmInfo = kmsLib.getWasmInfo();
+  const memory = { byteLength: 0, pages: 0 };
+  if (wasmInfo.memory !== undefined) {
+    memory.byteLength = wasmInfo.memory.byteLength;
+    memory.pages = wasmInfo.memory.pages;
+  }
 
-  moduleInfo = Object.freeze({
-    wasmUrl: cfg.wasm.url ? new URL(cfg.wasm.url) : undefined,
-    version: wasmInfo.version,
-    name: wasmInfo.name,
-  });
+  moduleInfoByVersion.set(
+    cfg.version,
+    Object.freeze({
+      wasmUrl: cfg.assets.wasm.url ? new URL(cfg.assets.wasm.url) : undefined,
+      version: wasmInfo.version,
+      name: wasmInfo.name,
+      memory,
+    }),
+  );
 
   return kmsLib;
 }
@@ -167,6 +274,20 @@ async function _initTkmsModule(cfg: ResolvedTkmsModuleConfig): Promise<KmsLibApi
 // getTkmsModuleInfo
 ////////////////////////////////////////////////////////////////////////////////
 
-export function getTkmsModuleInfo(): GetTkmsModuleInfoReturnType {
-  return moduleInfo;
+export async function getTkmsModuleInfo(parameters: GetTkmsModuleInfoParameters): Promise<GetTkmsModuleInfoReturnType> {
+  const tkmsLib = await loadKmsLib(parameters.tkmsVersion);
+  const stored = moduleInfoByVersion.get(parameters.tkmsVersion);
+  if (stored === undefined) {
+    throw new Error(`getTkmsModuleInfo: no module info recorded for version "${parameters.tkmsVersion}"`);
+  }
+  const memory: { byteLength: number; pages: number } = {
+    byteLength: stored.memory.byteLength,
+    pages: stored.memory.pages,
+  };
+  const wasmInfo = tkmsLib.getWasmInfo();
+  if (wasmInfo.memory !== undefined) {
+    memory.byteLength = wasmInfo.memory.byteLength;
+    memory.pages = wasmInfo.memory.pages;
+  }
+  return { ...stored, memory };
 }

package/core/modules/decrypt/types.ts

@@ -4,6 +4,7 @@ import type { Bytes, BytesHex } from '../../types/primitives.js';
 import type { Prettify } from '../../types/utils.js';
 import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 import type { ClearValue } from '../../types/encryptedTypes-p.js';
+import type { TkmsVersion } from '../../../wasm/tkms/KmsLibApi.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -22,12 +23,20 @@ WASM compilation (how to get WebAssembly.Module):
 
 */
 
+type WithTkmsVersion = {
+  readonly tkmsVersion: TkmsVersion;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // initTkmsModule
 ////////////////////////////////////////////////////////////////////////////////
 
+export type InitTkmsModuleParameters = {
+  readonly tkmsVersion: TkmsVersion;
+};
+
 export type InitTkmsModuleFunction = {
-  initTkmsModule(): Promise<void>;
+  initTkmsModule(parameters: InitTkmsModuleParameters): Promise<void>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -39,12 +48,29 @@ export type InitTkmsModuleFunction = {
  */
 export type TkmsModuleInfo = {
   /**
-   * URL used to fetch the TFHE WASM binary.
+   * URL used to fetch the TKMS WASM binary.
    * `undefined` means the base64-embedded fallback is used.
    */
   readonly wasmUrl: URL | undefined;
+
+  /**
+   * Current size of the TKMS WASM linear memory.
+   * This is the size of the underlying `WebAssembly.Memory` buffer, not live heap usage.
+   */
+  readonly memory: {
+    /**
+     * Current memory buffer size in bytes.
+     */
+    readonly byteLength: number;
+    /**
+     * Current memory buffer size in 64 KiB WASM pages.
+     */
+    readonly pages: number;
+  };
 };
 
+export type GetTkmsModuleInfoParameters = WithTkmsVersion;
+
 export type GetTkmsModuleInfoReturnType = TkmsModuleInfo | undefined;
 
 export type GetTkmsModuleInfoFunction = {
@@ -52,11 +78,12 @@ export type GetTkmsModuleInfoFunction = {
    * Returns {@link TkmsModuleInfo} when the module is initialized,
    * or `undefined` if the module has not completed initialization.
    */
-  getTkmsModuleInfo(): GetTkmsModuleInfoReturnType;
+  getTkmsModuleInfo(parameters: GetTkmsModuleInfoParameters): Promise<GetTkmsModuleInfoReturnType>;
 };
+
 ////////////////////////////////////////////////////////////////////////////////
 
-type WithTkmsPrivateKey = {
+type WithTkmsPrivateKey = WithTkmsVersion & {
   readonly tkmsPrivateKey: TkmsPrivateKey;
 };
 
@@ -75,52 +102,33 @@ export type DecryptAndReconstructModuleFunction = {
   decryptAndReconstruct(parameters: DecryptAndReconstructParameters): Promise<DecryptAndReconstructReturnType>;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// 1. (User) decryptAndReconstruct
-////////////////////////////////////////////////////////////////////////////////
-
-export type DecryptAndReconstructUserParameters = DecryptAndReconstructBaseParameters;
-
-export type DecryptAndReconstructUserModuleFunction = {
-  decryptAndReconstruct(parameters: DecryptAndReconstructUserParameters): Promise<DecryptAndReconstructReturnType>;
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 // 2. generateTkmsPrivateKey
 ////////////////////////////////////////////////////////////////////////////////
 
+export type GenerateTkmsPrivateKeyParameters = WithTkmsVersion;
 export type GenerateTkmsPrivateKeyReturnType = TkmsPrivateKey;
 
 export type GenerateTkmsPrivateKeyModuleFunction = {
-  generateTkmsPrivateKey(): Promise<GenerateTkmsPrivateKeyReturnType>;
+  generateTkmsPrivateKey(parameters: GenerateTkmsPrivateKeyParameters): Promise<GenerateTkmsPrivateKeyReturnType>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // 3 getTkmsPublicKeyHex
 ////////////////////////////////////////////////////////////////////////////////
 
-export type GetTkmsPublicKeyHexParameters = WithTkmsPrivateKey;
+export type GetTkmsPublicKeyHexParameters = WithTkmsPrivateKey & WithTkmsVersion;
 export type GetTkmsPublicKeyHexReturnType = BytesHex;
 
 export type GetTkmsPublicKeyHexModuleFunction = {
   getTkmsPublicKeyHex(parameters: GetTkmsPublicKeyHexParameters): Promise<GetTkmsPublicKeyHexReturnType>;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// 3. (User) getTkmsPublicKeyHex
-////////////////////////////////////////////////////////////////////////////////
-
-export type GetTkmsPublicKeyHexUserModuleFunction = {
-  getTkmsPublicKeyHex(): Promise<GetTkmsPublicKeyHexReturnType>;
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 // 4. serializeTkmsPrivateKey
 ////////////////////////////////////////////////////////////////////////////////
 
-export type SerializeTkmsPrivateKeyParameters = {
-  readonly tkmsPrivateKey: TkmsPrivateKey;
-};
+export type SerializeTkmsPrivateKeyParameters = WithTkmsPrivateKey;
 
 export type SerializeTkmsPrivateKeyReturnType = Bytes;
 
@@ -128,19 +136,11 @@ export type SerializeTkmsPrivateKeyModuleFunction = {
   serializeTkmsPrivateKey(parameters: SerializeTkmsPrivateKeyParameters): Promise<SerializeTkmsPrivateKeyReturnType>;
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// 4. (User) serializeTkmsPrivateKey
-////////////////////////////////////////////////////////////////////////////////
-
-export type SerializeTkmsPrivateKeyUserModuleFunction = {
-  serializeTkmsPrivateKey(): Promise<SerializeTkmsPrivateKeyReturnType>;
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 // 5. deserializeTkmsPrivateKey
 ////////////////////////////////////////////////////////////////////////////////
 
-export type DeserializeTkmsPrivateKeyParameters = {
+export type DeserializeTkmsPrivateKeyParameters = WithTkmsVersion & {
   readonly tkmsPrivateKeyBytes: Bytes;
 };
 
@@ -156,9 +156,7 @@ export type DeserializeTkmsPrivateKeyModuleFunction = {
 // 6. verifyTkmsPrivateKey
 ////////////////////////////////////////////////////////////////////////////////
 
-export type VerifyTkmsPrivateKeyParameters = {
-  readonly tkmsPrivateKey: TkmsPrivateKey;
-};
+export type VerifyTkmsPrivateKeyParameters = WithTkmsVersion & WithTkmsPrivateKey;
 
 export type VerifyTkmsPrivateKeyModuleFunction = {
   verifyTkmsPrivateKey(parameters: VerifyTkmsPrivateKeyParameters): void;
@@ -186,29 +184,3 @@ export type DecryptModule = Prettify<
 export type DecryptModuleFactory = (runtime: FhevmRuntime) => {
   readonly decrypt: DecryptModule;
 };
-
-////////////////////////////////////////////////////////////////////////////////
-// UserDecryptModule
-////////////////////////////////////////////////////////////////////////////////
-
-export type WithUserDecryptModule = {
-  readonly userDecrypt: UserDecryptModule;
-};
-
-export type UserDecryptModuleParameters = {
-  readonly privateKey: TkmsPrivateKey;
-};
-
-export type UserDecryptModule = Prettify<
-  InitTkmsModuleFunction &
-    DecryptAndReconstructUserModuleFunction &
-    GetTkmsPublicKeyHexUserModuleFunction &
-    SerializeTkmsPrivateKeyUserModuleFunction
->;
-
-export type UserDecryptModuleFactory = (
-  runtime: FhevmRuntime,
-  parameters: UserDecryptModuleParameters,
-) => {
-  readonly userDecrypt: UserDecryptModule;
-};