@fhevm/sdk 1.0.0-alpha.4 → 1.0.0-alpha.5

package/core/modules/encrypt/module/index.ts

@@ -1,6 +1,6 @@
 import type { FhevmRuntime } from '../../../types/coreFhevmRuntime.js';
 import type {
-  BuildWithProofPackedReturnTypeParameters,
+  BuildWithProofPackedParameters,
   DeserializeFheEncryptionCrsParameters,
   DeserializeFheEncryptionPublicKeyParameters,
   EncryptModuleFactory,
@@ -31,7 +31,7 @@ export const encryptModule: EncryptModuleFactory = (runtime: FhevmRuntime) => {
       getTfheModuleInfo: () => getTfheModuleInfo(),
       parseTFHEProvenCompactCiphertextList: (args: ParseTFHEProvenCompactCiphertextListParameters) =>
         parseTFHEProvenCompactCiphertextList(runtime, args),
-      buildWithProofPacked: (args: BuildWithProofPackedReturnTypeParameters) => buildWithProofPacked(runtime, args),
+      buildWithProofPacked: (args: BuildWithProofPackedParameters) => buildWithProofPacked(runtime, args),
       serializeFheEncryptionKey: (args: SerializeFheEncryptionKeyParameters) =>
         serializeFheEncryptionKey(runtime, args),
       serializeFheEncryptionPublicKey: (args: SerializeFheEncryptionPublicKeyParameters) =>

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

@@ -63,16 +63,28 @@ type ResolvedTfheModuleConfig = {
 };
 
 let resolvedTfheModuleConfig: ResolvedTfheModuleConfig | undefined = undefined;
+let resolvingTfheModuleConfigPromise: Promise<ResolvedTfheModuleConfig> | undefined;
 
 /**
  * @internal
  * Returns the existing resolved config, or resolves it from the runtime config.
  */
 async function _getOrResolveTfheModuleConfig(runtime: FhevmRuntime): Promise<ResolvedTfheModuleConfig> {
-  if (resolvedTfheModuleConfig !== undefined) return resolvedTfheModuleConfig;
+  if (resolvedTfheModuleConfig !== undefined) {
+    return resolvedTfheModuleConfig;
+  }
 
-  resolvedTfheModuleConfig = await _resolveTfheModuleConfig(runtime.config);
-  return resolvedTfheModuleConfig;
+  resolvingTfheModuleConfigPromise ??= _resolveTfheModuleConfig(runtime.config)
+    .then((cfg) => {
+      resolvedTfheModuleConfig = cfg;
+      return cfg;
+    })
+    .catch((error: unknown) => {
+      resolvingTfheModuleConfigPromise = undefined;
+      throw error;
+    });
+
+  return resolvingTfheModuleConfigPromise;
 }
 
 /**
@@ -81,10 +93,6 @@ async function _getOrResolveTfheModuleConfig(runtime: FhevmRuntime): Promise<Res
  * (thread count, worker URL, WASM URL). Must be called before WASM initialization.
  */
 async function _resolveTfheModuleConfig(parameters: FhevmRuntimeConfig): Promise<ResolvedTfheModuleConfig> {
-  if (cachedTfheModulePromise !== undefined) {
-    throw new Error('Cannot configure module after initialization has started');
-  }
-
   const { locateFile, singleThread: singleThreadConfig, numberOfThreads: numberOfThreadsConfig } = parameters;
 
   let singleThread = false;
@@ -181,22 +189,30 @@ export async function initTfheModule(runtime: FhevmRuntime): Promise<void> {
 
   ownerUid = runtime.uid;
 
-  if (cachedTfheModulePromise !== undefined) {
-    return cachedTfheModulePromise;
+  // Cache the whole initialization promise before the first await. Several
+  // clients may call initTfheModule concurrently during startup; if the promise
+  // were assigned after resolving the config, each caller could enter
+  // _initTfheModule and try to start the global TFHE worker pool independently.
+  // The worker pool is process-wide and startWorkers() is intentionally
+  // one-shot, so every concurrent caller must await this same promise.
+  //
+  // Retry is not supported:
+  // -----------------------
+  // TFHE/WASM initialization and worker startup mutate
+  // lower-level module globals that cannot be reset reliably after a partial
+  // failure. Keep even a rejected promise cached so later callers observe the
+  // original initialization error instead of retrying against half-initialized
+  // state and producing secondary errors such as "Already started".
+
+  // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+  if (cachedTfheModulePromise === undefined) {
+    cachedTfheModulePromise = (async () => {
+      // resolve is async
+      const cfg = await _getOrResolveTfheModuleConfig(runtime);
+      await _initTfheModule(cfg);
+    })();
   }
 
-  // Use existing config if already set, otherwise resolve from runtime
-  const cfg = await _getOrResolveTfheModuleConfig(runtime);
-
-  cachedTfheModulePromise = _initTfheModule(cfg);
-
-  // This is purely theoretical. Retry is not yet possible since the `_initTfheModule`
-  // does not support retry (see tfhe lib internal global variables).
-  cachedTfheModulePromise.catch(() => {
-    // Clear cache on failure so retry is possible
-    cachedTfheModulePromise = undefined;
-  });
-
   return cachedTfheModulePromise;
 }
 

package/core/modules/encrypt/types.ts

@@ -108,7 +108,7 @@ export type ParseTFHEProvenCompactCiphertextListModuleFunction = {
 // 2. buildWithProofPacked
 ////////////////////////////////////////////////////////////////////////////////
 
-export type BuildWithProofPackedReturnTypeParameters = {
+export type BuildWithProofPackedParameters = {
   readonly fheEncryptionKey: FheEncryptionKeyWasm;
   readonly typedValues: TypedValue[];
   readonly metaData: Uint8Array;
@@ -121,7 +121,7 @@ export type BuildWithProofPackedReturnType = {
 };
 
 export type BuildWithProofPackedModuleFunction = {
-  buildWithProofPacked(parameters: BuildWithProofPackedReturnTypeParameters): Promise<BuildWithProofPackedReturnType>;
+  buildWithProofPacked(parameters: BuildWithProofPackedParameters): Promise<BuildWithProofPackedReturnType>;
 };
 
 ////////////////////////////////////////////////////////////////////////////////

package/core/modules/relayer/module/fetchPublicDecrypt.ts

@@ -1,4 +1,4 @@
-import type { Bytes65Hex, BytesHex } from '../../../types/primitives.js';
+import type { Bytes65Hex } from '../../../types/primitives.js';
 import type { RelayerFetchPublicDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchPublicDecryptResult } from '../../../types/relayer.js';
 import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
@@ -33,7 +33,7 @@ export async function fetchPublicDecrypt(
   const result = (await request.run()) as FetchPublicDecryptResult;
 
   return {
-    orderedAbiEncodedClearValues: ensure0x(result.decryptedValue) as BytesHex,
+    orderedAbiEncodedClearValues: ensure0x(result.decryptedValue),
     kmsPublicDecryptEIP712Signatures: result.signatures.map(ensure0x) as Bytes65Hex[],
     extraData: result.extraData,
   };

package/core/modules/relayer/module/fetchUserDecrypt.ts

@@ -1,5 +1,4 @@
 import type { KmsSigncryptedShare } from '../../../types/kms-p.js';
-import type { Bytes65HexNo0x } from '../../../types/primitives.js';
 import type { FetchUserDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchUserDecryptResult } from '../../../types/relayer.js';
 import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
@@ -38,7 +37,7 @@ export async function fetchUserDecrypt(
     contractsChainId,
     contractAddresses: payload.kmsDecryptEip712Message.contractAddresses,
     userAddress: payload.kmsDecryptEip712Signer,
-    signature: remove0x(payload.kmsDecryptEip712Signature) as Bytes65HexNo0x,
+    signature: remove0x(payload.kmsDecryptEip712Signature),
     extraData: payload.kmsDecryptEip712Message.extraData,
     publicKey: remove0x(payload.kmsDecryptEip712Message.publicKey),
   };

package/core/modules/relayer/module/guards/RelayerErrorBody.ts

@@ -0,0 +1,33 @@
+type RelayerErrorBody = {
+  error: {
+    label: string;
+    message: string;
+    details?: ReadonlyArray<{ field: string; issue: string }>;
+  };
+};
+
+export function isRelayerErrorBody(bodyJson: Record<string, unknown>): bodyJson is RelayerErrorBody {
+  const error = bodyJson.error as Record<string, unknown> | undefined;
+  if (!error || typeof error !== 'object' || Array.isArray(error)) {
+    return false;
+  }
+  if (typeof error.label !== 'string' || typeof error.message !== 'string') {
+    return false;
+  }
+  if (error.details !== undefined) {
+    if (!Array.isArray(error.details)) {
+      return false;
+    }
+    for (const d of error.details) {
+      if (
+        d === undefined ||
+        typeof d !== 'object' ||
+        typeof (d as { field: unknown }).field !== 'string' ||
+        typeof (d as { issue: unknown }).issue !== 'string'
+      ) {
+        return false;
+      }
+    }
+  }
+  return true;
+}

package/core/types/index.ts

@@ -1,3 +1,5 @@
 export type { TypedValue } from './primitives.js';
 export type { EncryptedValue, EncryptedValueLike } from './encryptedTypes.js';
 export type { KmsDecryptEip712Like } from './kms.js';
+export type { FhevmEncryptClient, FhevmDecryptClient } from './fhevmClient.js';
+export { asEncryptedValue, isEncryptedValue } from '../handle/EncryptedValue.js';

package/core/utils-p/decrypt/{assertPermitMatchesKeypair.ts → assertPermitMatchesKeyPair.ts}

@@ -1,27 +1,27 @@
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { TransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
-import { assertIsTransportKeypair } from '../../kms/TransportKeypair-p.js';
+import { assertIsTransportKeyPair } from '../../kms/TransportKeyPair-p.js';
 import { assertIsSignedDecryptionPermit } from '../../kms/SignedDecryptionPermit-p.js';
 
 /**
- * Asserts that the permit's publicKey matches the keypair's publicKey.
+ * Asserts that the permit's publicKey matches the key pair's publicKey.
  *
  * Both values are validated via `instanceof` before comparison.
  *
  * @throws {InvalidTypeError} If either value is not the expected type.
  * @throws If the public keys do not match.
  */
-export function assertPermitMatchesKeypair(
+export function assertPermitMatchesKeyPair(
   signedPermit: SignedDecryptionPermit,
-  transportKeypair: TransportKeypair,
+  transportKeyPair: TransportKeyPair,
 ): void {
   assertIsSignedDecryptionPermit(signedPermit, {});
-  assertIsTransportKeypair(transportKeypair, {});
+  assertIsTransportKeyPair(transportKeyPair, {});
 
-  if (signedPermit.e2eTransportPublicKey.toLowerCase() !== transportKeypair.publicKey.toLowerCase()) {
+  if (signedPermit.e2eTransportPublicKey.toLowerCase() !== transportKeyPair.publicKey.toLowerCase()) {
     throw new Error(
-      "The permit's publicKey does not match the E2eTransportKeypair's publicKey. " +
-        'Ensure the permit was signed with the same keypair.',
+      "The permit's publicKey does not match the E2eTransportKeyPair's publicKey. " +
+        'Ensure the permit was signed with the same key pair.',
     );
   }
 }

package/core/utils-p/decrypt/verifyTkmsPublicKey.ts

@@ -22,6 +22,6 @@ export async function verifyTkmsPublicKey(
   });
 
   if (expectedTkmsPublicKeyBytesHex !== tkmsPublicKeyBytesHex) {
-    throw new Error('invalid E2eTransportKeypair');
+    throw new Error('invalid E2eTransportKeyPair');
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fhevm/sdk",
   "description": "TypeScript Interface for FHEVM",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.5",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
@@ -13,7 +13,8 @@
     "!**/*.test.ts",
     "!**/*.template",
     "!**/*.tsbuildinfo",
-    "!tsconfig.build.json"
+    "!vitest.config.ts",
+    "!tsconfig.json"
   ],
   "exports": {
     ".": {

package/_cjs/core/actions/chain/parseTransportKeypair.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTransportKeypair = parseTransportKeypair;
-const TransportKeypair_p_js_1 = require("../../kms/TransportKeypair-p.js");
-async function parseTransportKeypair(fhevm, parameters) {
-    return (0, TransportKeypair_p_js_1.toTransportKeypair)(fhevm, parameters);
-}
-//# sourceMappingURL=parseTransportKeypair.js.map

package/_cjs/core/actions/chain/parseTransportKeypair.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseTransportKeypair.js","sourceRoot":"","sources":["../../../../core/actions/chain/parseTransportKeypair.ts"],"names":[],"mappings":";;AAcA,sDAKC;AAhBD,2EAA4F;AAWrF,KAAK,UAAU,qBAAqB,CACzC,KAA4D,EAC5D,UAA2C;IAE3C,OAAO,IAAA,0CAAkB,EAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AAC/C,CAAC"}

package/_cjs/core/actions/chain/serializeTransportKeypair.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeTransportKeypair = serializeTransportKeypair;
-const TransportKeypair_p_js_1 = require("../../kms/TransportKeypair-p.js");
-function serializeTransportKeypair(_fhevm, parameters) {
-    return (0, TransportKeypair_p_js_1.serializeTransportKeypair)(parameters.transportKeypair);
-}
-//# sourceMappingURL=serializeTransportKeypair.js.map

package/_cjs/core/actions/chain/serializeTransportKeypair.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializeTransportKeypair.js","sourceRoot":"","sources":["../../../../core/actions/chain/serializeTransportKeypair.ts"],"names":[],"mappings":";;AAoBA,8DAKC;AArBD,2EAGyC;AAazC,SAAgB,yBAAyB,CACvC,MAA6D,EAC7D,UAA+C;IAE/C,OAAO,IAAA,iDAA0B,EAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;AACjE,CAAC"}

package/_cjs/core/actions/decrypt/generateTransportKeypair.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateTransportKeypair = generateTransportKeypair;
-const TransportKeypair_p_js_1 = require("../../kms/TransportKeypair-p.js");
-async function generateTransportKeypair(fhevm) {
-    return await (0, TransportKeypair_p_js_1.generateTransportKeypair)(fhevm);
-}
-//# sourceMappingURL=generateTransportKeypair.js.map

package/_cjs/core/actions/decrypt/generateTransportKeypair.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateTransportKeypair.js","sourceRoot":"","sources":["../../../../core/actions/decrypt/generateTransportKeypair.ts"],"names":[],"mappings":";;AAYA,4DAIC;AAbD,2EAGyC;AAMlC,KAAK,UAAU,wBAAwB,CAC5C,KAAuE;IAEvE,OAAO,MAAM,IAAA,gDAAyB,EAAC,KAAK,CAAC,CAAC;AAChD,CAAC"}

package/_cjs/core/utils-p/decrypt/assertPermitMatchesKeypair.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertPermitMatchesKeypair = assertPermitMatchesKeypair;
-const TransportKeypair_p_js_1 = require("../../kms/TransportKeypair-p.js");
-const SignedDecryptionPermit_p_js_1 = require("../../kms/SignedDecryptionPermit-p.js");
-function assertPermitMatchesKeypair(signedPermit, transportKeypair) {
-    (0, SignedDecryptionPermit_p_js_1.assertIsSignedDecryptionPermit)(signedPermit, {});
-    (0, TransportKeypair_p_js_1.assertIsTransportKeypair)(transportKeypair, {});
-    if (signedPermit.e2eTransportPublicKey.toLowerCase() !== transportKeypair.publicKey.toLowerCase()) {
-        throw new Error("The permit's publicKey does not match the E2eTransportKeypair's publicKey. " +
-            'Ensure the permit was signed with the same keypair.');
-    }
-}
-//# sourceMappingURL=assertPermitMatchesKeypair.js.map

package/_esm/core/actions/chain/parseTransportKeypair.js

@@ -1,5 +0,0 @@
-import { toTransportKeypair } from '../../kms/TransportKeypair-p.js';
-export async function parseTransportKeypair(fhevm, parameters) {
-    return toTransportKeypair(fhevm, parameters);
-}
-//# sourceMappingURL=parseTransportKeypair.js.map

package/_esm/core/actions/chain/parseTransportKeypair.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseTransportKeypair.js","sourceRoot":"","sources":["../../../../core/actions/chain/parseTransportKeypair.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAyB,MAAM,iCAAiC,CAAC;AAW5F,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,KAA4D,EAC5D,UAA2C;IAE3C,OAAO,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;AAC/C,CAAC"}

package/_esm/core/actions/chain/serializeTransportKeypair.js

@@ -1,5 +0,0 @@
-import { serializeTransportKeypair as serializeTransportKeypair_, } from '../../kms/TransportKeypair-p.js';
-export function serializeTransportKeypair(_fhevm, parameters) {
-    return serializeTransportKeypair_(parameters.transportKeypair);
-}
-//# sourceMappingURL=serializeTransportKeypair.js.map

package/_esm/core/actions/decrypt/generateTransportKeypair.js

@@ -1,6 +0,0 @@
-import { generateTransportKeypair as generateTransportKeypair_, } from '../../kms/TransportKeypair-p.js';
-export async function generateTransportKeypair(fhevm) {
-    return await generateTransportKeypair_(fhevm);
-}
-////////////////////////////////////////////////////////////////////////////////
-//# sourceMappingURL=generateTransportKeypair.js.map

package/_esm/core/utils-p/decrypt/assertPermitMatchesKeypair.js

@@ -1,19 +0,0 @@
-import { assertIsTransportKeypair } from '../../kms/TransportKeypair-p.js';
-import { assertIsSignedDecryptionPermit } from '../../kms/SignedDecryptionPermit-p.js';
-/**
- * Asserts that the permit's publicKey matches the keypair's publicKey.
- *
- * Both values are validated via `instanceof` before comparison.
- *
- * @throws {InvalidTypeError} If either value is not the expected type.
- * @throws If the public keys do not match.
- */
-export function assertPermitMatchesKeypair(signedPermit, transportKeypair) {
-    assertIsSignedDecryptionPermit(signedPermit, {});
-    assertIsTransportKeypair(transportKeypair, {});
-    if (signedPermit.e2eTransportPublicKey.toLowerCase() !== transportKeypair.publicKey.toLowerCase()) {
-        throw new Error("The permit's publicKey does not match the E2eTransportKeypair's publicKey. " +
-            'Ensure the permit was signed with the same keypair.');
-    }
-}
-//# sourceMappingURL=assertPermitMatchesKeypair.js.map

package/_types/core/utils-p/decrypt/assertPermitMatchesKeypair.d.ts

@@ -1,12 +0,0 @@
-import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
-import type { SignedDecryptionPermit } from '../../types/signedDecryptionPermit.js';
-/**
- * Asserts that the permit's publicKey matches the keypair's publicKey.
- *
- * Both values are validated via `instanceof` before comparison.
- *
- * @throws {InvalidTypeError} If either value is not the expected type.
- * @throws If the public keys do not match.
- */
-export declare function assertPermitMatchesKeypair(signedPermit: SignedDecryptionPermit, transportKeypair: TransportKeypair): void;
-//# sourceMappingURL=assertPermitMatchesKeypair.d.ts.map

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "include": ["./**/*.ts"],
-  "exclude": ["./**/*.test.ts", "./**/*.test-d.ts", "./**/*.bench.ts", "./**/*.bench-d.ts", "./vitest.config.ts"],
-  "compilerOptions": {
-    "composite": true,
-    "noEmit": true
-  }
-}

package/vitest.config.ts

@@ -1,17 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['src/**/*.test.ts'],
-    exclude: ['src/index.hello.test.ts'],
-    reporters: ['verbose'],
-    passWithNoTests: false,
-    typecheck: { enabled: true },
-    coverage: {
-      provider: 'v8',
-      reporter: ['text'],
-      //include: ['src/**/*.ts'],
-      //exclude: ['src/**/*.test.ts', 'src/**/*.test-d.ts', 'src/vitest.config.ts'],
-    },
-  },
-});