@fhevm/sdk 1.1.0-alpha.3 → 1.1.0-alpha.5

package/core/types/coreFhevmClient.ts

@@ -1,16 +1,37 @@
 import type { FhevmChain } from './fhevmChain.js';
 import type { FhevmRuntime } from './coreFhevmRuntime.js';
 import type { FheEncryptionKeyBytes } from './fheEncryptionKey.js';
+import type {
+  FhevmDecryptModuleVersions,
+  FhevmEncryptModuleVersions,
+  FhevmModuleVersions,
+  TfheVersion,
+  TkmsVersion,
+} from './moduleVersions.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type FhevmOptions = {
+export type FhevmBaseOptions = {
   readonly batchRpcCalls?: boolean | undefined;
+};
+
+export type FhevmEncryptOptions = FhevmBaseOptions & {
+  readonly fheEncryptionKey?: FheEncryptionKeyBytes | undefined;
+  readonly moduleVersions?: FhevmEncryptModuleVersions | undefined;
+};
+
+export type FhevmDecryptOptions = FhevmBaseOptions & {
+  readonly moduleVersions?: FhevmDecryptModuleVersions | undefined;
+};
+
+export type FhevmOptions = FhevmBaseOptions & {
   readonly fheEncryptionKey?: FheEncryptionKeyBytes | undefined;
+  readonly moduleVersions?: FhevmModuleVersions | undefined;
 };
 
 export type ResolvedFhevmOptions = {
   readonly batchRpcCalls: boolean;
+  readonly moduleVersions?: FhevmModuleVersions | undefined;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -19,15 +40,78 @@ export type NativeClient = NonNullable<object>;
 export type OptionalNativeClient = NativeClient | undefined;
 export type OptionalFhevmChain = FhevmChain | undefined;
 
+/**
+ * Semver-compatible FHEVM protocol version.
+ *
+ * The protocol version describes the on-chain FHEVM protocol used by a given
+ * chain.
+ *
+ * Example: `'0.14.0'`.
+ */
+export type ProtocolVersion = string;
+export type PubKeyCrsVersion = string;
+
+/**
+ * Comparator between an actual resolved version and the version known by this
+ * SDK.
+ *
+ * - `'eq'`: actual version equals the returned version.
+ * - `'gt'`: actual version is strictly greater than the returned version.
+ * - `'lt'`: actual version is strictly lower than the returned version.
+ */
+export type VersionResolutionComparator = 'eq' | 'lt' | 'gt';
+
+/**
+ * Result of resolving a version that may be exact or bounded by this SDK's
+ * compatibility table.
+ *
+ * This structure is deliberately "honest": when the SDK cannot identify the
+ * exact version, it returns a bounded relationship instead of
+ * pretending that the version string is exact. Consumers that only need feature
+ * gating should inspect both `version` and `comparator`.
+ */
+export type VersionResolution<version extends string> = {
+  /**
+   * The version known by this SDK.
+   *
+   * Interpret this value through {@link VersionResolution.comparator}; it may
+   * be exact, a lower bound, or an upper bound.
+   */
+  readonly version: version;
+  /**
+   * Describes how the actual resolved version compares to
+   * {@link VersionResolution.version}.
+   */
+  readonly comparator: VersionResolutionComparator;
+};
+
+export type ProtocolVersionResolution = VersionResolution<ProtocolVersion>;
+export type PubKeyCrsVersionResolution = VersionResolution<PubKeyCrsVersion>;
+
+export type FhevmProtocolContext = {
+  readonly protocolVersion: ProtocolVersionResolution;
+  readonly pubKeyCrsVersion: PubKeyCrsVersionResolution;
+};
+
+export type WithProtocolVersion = {
+  readonly protocolVersion: ProtocolVersionResolution;
+};
+
+export type WithTfheVersion = WithProtocolVersion & {
+  readonly tfheVersion: TfheVersion;
+};
+
+export type WithTkmsVersion = WithProtocolVersion & {
+  readonly tkmsVersion: TkmsVersion;
+};
+
 export type FhevmExtension<
   actions extends Record<string, unknown> = Record<string, unknown>,
   runtime extends FhevmRuntime = FhevmRuntime,
 > = {
   readonly actions: actions;
   readonly runtime: runtime;
-  readonly init?:
-    | ((client: FhevmBase<FhevmChain | undefined, FhevmRuntime, OptionalNativeClient>) => Promise<void>)
-    | undefined;
+  readonly init?: ((client: FhevmBase<FhevmChain>) => Promise<void>) | undefined;
 };
 
 export interface FhevmBase<
@@ -47,6 +131,7 @@ export interface Fhevm<
   runtime extends FhevmRuntime = FhevmRuntime,
   client extends OptionalNativeClient = NativeClient,
 > extends FhevmBase<chain, runtime, client> {
+  readonly protocolVersion: ProtocolVersionResolution;
   readonly extend: <const actions extends Record<string, unknown>, extendedRuntime extends FhevmRuntime>(
     actionsFactory: (client: FhevmBase<chain, FhevmRuntime, client>) => FhevmExtension<actions, extendedRuntime>,
   ) => this & actions & { readonly runtime: extendedRuntime };

package/core/types/coreFhevmRuntime.ts

@@ -4,30 +4,15 @@ import type { EncryptModule, EncryptModuleFactory, WithEncryptModule } from '../
 import type { DecryptModule, DecryptModuleFactory, WithDecryptModule } from '../modules/decrypt/types.js';
 import type { Logger } from './logger.js';
 import type { Auth } from './auth.js';
-import type { TfheVersion } from '../../wasm/tfhe/loadTfheLib.js';
-import type { TkmsVersion } from '../../wasm/tkms/loadKmsLib.js';
+import type { FhevmModuleVersions } from './moduleVersions.js';
+import type { WasmAssetLoadMode } from './wasmAssets.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type WasmAssetLoadMode =
-  | 'embedded-base64'
-  | 'verified-blob'
-  | 'precheck-direct-url'
-  | 'trusted-direct-url'
-  | 'auto';
-
-export type WasmModuleVersions =
-  | 'auto'
-  | {
-      readonly tfhe?: TfheVersion | 'auto';
-      readonly kms?: TkmsVersion | 'auto';
-      readonly checkCompatibility?: 'throw' | 'warn' | 'off';
-    };
-
 export type FhevmRuntimeConfig = {
   readonly locateFile?: ((file: string) => URL) | undefined;
   readonly wasmAssetLoadMode?: WasmAssetLoadMode | undefined;
-  readonly moduleVersions?: WasmModuleVersions | undefined;
+  readonly moduleVersions?: FhevmModuleVersions | undefined;
   readonly logger?: Logger | undefined;
   readonly singleThread?: boolean | undefined;
   readonly numberOfThreads?: number | undefined;

package/core/types/fheEncryptionKey.ts

@@ -1,3 +1,4 @@
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
 import type { Bytes, UintNumber } from './primitives.js';
 import type { Prettify } from './utils.js';
 
@@ -87,6 +88,7 @@ export type FheEncryptionKeyWasm = {
   readonly publicKey: FheEncryptionPublicKey;
   readonly crs: FheEncryptionCrs;
   readonly metadata: FheEncryptionKeyMetadata;
+  readonly tfheVersion: TfheVersion;
 };
 
 ////////////////////////////////////////////////////////////////////////////////

package/core/types/fhevmChain.ts

@@ -12,6 +12,7 @@ export type FhevmChain = {
  *       acl: "0xdeadbeef..."
  *       inputVerifier: "0xdeadbeef..."
  *       kmsVerifier: "0xdeadbeef..."
+ *       protocolConfig: "0xdeadbeef..."
  *     },
  *     relayerUrl: "http://foo",
  *     gateway?: {
@@ -42,6 +43,7 @@ export type FhevmChainContracts = {
   readonly acl: ChainContract;
   readonly inputVerifier: ChainContract;
   readonly kmsVerifier: ChainContract;
+  readonly protocolConfig: ChainContract | undefined;
 };
 
 export type FhevmGatewayChain = {
@@ -75,6 +77,7 @@ type ResolvedFhevmChainContracts = {
   readonly acl: ResolvedChainContract;
   readonly inputVerifier: ResolvedChainContract;
   readonly kmsVerifier: ResolvedChainContract;
+  readonly protocolConfig?: ResolvedChainContract | undefined;
 };
 
 type ResolvedFhevmGatewayChain = {

package/core/types/hostContract.ts

@@ -6,6 +6,7 @@ export type HostContractNameMap = {
   readonly HCULimit: 'HCULimit';
   readonly InputVerifier: 'InputVerifier';
   readonly KMSVerifier: 'KMSVerifier';
+  readonly ProtocolConfig: 'ProtocolConfig';
 };
 
 // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents

package/core/types/index.ts

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

package/core/types/kms-p.ts

@@ -1,3 +1,4 @@
+import type { TkmsVersion } from '../../wasm/tkms/KmsLibApi.js';
 import type { Handle } from './encryptedTypes-p.js';
 import type { KmsEip712Domain } from './kms.js';
 import type { KmsSignersContext } from './kmsSignersContext.js';
@@ -9,6 +10,7 @@ export interface KmsSigncryptedSharesMetadata {
   readonly eip712Signature: Bytes65Hex;
   readonly eip712SignerAddress: ChecksummedAddress;
   readonly handles: readonly Handle[];
+  readonly tkmsVersion: TkmsVersion;
 }
 
 export interface KmsSigncryptedShare {

package/core/types/kms.ts

@@ -1,3 +1,4 @@
+import type { TkmsVersion } from '../../wasm/tkms/KmsLibApi.js';
 import type { HostContractData } from './hostContract.js';
 import type { Bytes32Hex, BytesHex, ChecksummedAddress, Uint64BigInt } from './primitives.js';
 import type { Prettify } from './utils.js';
@@ -65,6 +66,24 @@ export type KmsDelegateUserDecryptEip712Types = {
   ];
 };
 
+export type KmsUserDecryptEip712V2Types = {
+  readonly EIP712Domain: readonly [
+    { readonly name: 'name'; readonly type: 'string' },
+    { readonly name: 'version'; readonly type: 'string' },
+    { readonly name: 'chainId'; readonly type: 'uint256' },
+    { readonly name: 'verifyingContract'; readonly type: 'address' },
+  ];
+  // CRITICAL: Field order is authoritative — determines the EIP-712 type hash.
+  readonly UserDecryptRequestVerification: readonly [
+    { readonly name: 'userAddress'; readonly type: 'address' },
+    { readonly name: 'publicKey'; readonly type: 'bytes' },
+    { readonly name: 'allowedContracts'; readonly type: 'address[]' },
+    { readonly name: 'startTimestamp'; readonly type: 'uint256' },
+    { readonly name: 'durationSeconds'; readonly type: 'uint256' },
+    { readonly name: 'extraData'; readonly type: 'bytes' },
+  ];
+};
+
 export type KmsPublicDecryptEip712Types = {
   readonly EIP712Domain: readonly [
     { readonly name: 'name'; readonly type: 'string' },
@@ -99,24 +118,14 @@ export type KmsPublicDecryptEip712Message = Readonly<{
   extraData: BytesHex;
 }>;
 
-export type KmsDecryptEip712Like = {
-  readonly domain: {
-    readonly name: string;
-    readonly version: string;
-    readonly chainId: number | bigint;
-    readonly verifyingContract: string;
-  };
-  readonly primaryType?: string | undefined;
-  readonly types: Record<string, ReadonlyArray<{ readonly name: string; readonly type: string }>>;
-  readonly message: {
-    readonly publicKey: string | Uint8Array;
-    readonly contractAddresses: string[];
-    readonly startTimestamp: number;
-    readonly durationDays: number;
-    readonly extraData: string | Uint8Array;
-    readonly delegatorAddress?: string | undefined;
-  };
-};
+export type KmsUserDecryptEip712V2Message = Readonly<{
+  userAddress: ChecksummedAddress;
+  publicKey: BytesHex;
+  allowedContracts: readonly ChecksummedAddress[];
+  startTimestamp: string;
+  durationSeconds: string;
+  extraData: BytesHex;
+}>;
 
 export type KmsUserDecryptEip712 = Prettify<{
   readonly domain: KmsEip712Domain;
@@ -139,6 +148,13 @@ export type KmsPublicDecryptEip712 = Prettify<{
   readonly message: KmsPublicDecryptEip712Message;
 }>;
 
+export type KmsUserDecryptEip712V2 = Prettify<{
+  readonly domain: KmsEip712Domain;
+  readonly types: KmsUserDecryptEip712V2Types;
+  readonly primaryType: 'UserDecryptRequestVerification';
+  readonly message: KmsUserDecryptEip712V2Message;
+}>;
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // KmsSigncryptedShares
@@ -147,5 +163,19 @@ export type KmsPublicDecryptEip712 = Prettify<{
 
 export declare const KmsSigncryptedSharesBrand: unique symbol;
 export interface KmsSigncryptedShares {
+  readonly tkmsVersion: TkmsVersion;
   readonly [KmsSigncryptedSharesBrand]: never;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Eip712Like
+//
+////////////////////////////////////////////////////////////////////////////////
+
+export type Eip712Like = {
+  readonly domain: Record<string, unknown>;
+  readonly primaryType?: string | undefined;
+  readonly types: Record<string, ReadonlyArray<{ readonly name: string; readonly type: string }>>;
+  readonly message: Record<string, unknown>;
+};

package/core/types/kmsSignersContext.ts

@@ -12,6 +12,12 @@ import type { ChecksummedAddress, Uint256BigInt, Uint8Number } from './primitive
  *   sequential (each new context = previous ID + 1). The valid range is
  *   `[MIN_ID, currentKmsContextId]`. Two different contexts can never
  *   share the same ID.
+ * - `epoch_id` — The epoch identifier linked to this context. Created together
+ *   with `id` by `defineNewKmsContextAndEpoch()`. Becomes **active** only after
+ *   Phase 2 of the context-switch protocol (key resharing MPC) completes and
+ *   all KMS signers call `confirmEpochActivation`. Until then,
+ *   `getCurrentKmsContextAndEpoch()` still returns the previous
+ *   `(contextId, epochId)` pair.
  * - `signers` — The ordered list of KMS node addresses responsible for
  *   decrypting encrypted values under this context. No duplicates or null
  *   addresses are allowed (enforced on-chain).
@@ -39,6 +45,8 @@ export type KmsSignersContext = {
   readonly address: ChecksummedAddress;
   /** The unique, immutable context identifier. See {@link KmsSignersContext} for valid range. */
   readonly id: Uint256BigInt;
+  /** Epoch identifier linked to this context. Active only after Phase 2 key resharing completes. See {@link KmsSignersContext}. */
+  readonly epochId: Uint256BigInt;
   /** Ordered list of KMS node addresses for this context. No duplicates or null addresses. */
   readonly signers: readonly ChecksummedAddress[];
   /** Minimum number of KMS decryption shares required. Non-zero, at most `signers.length`. */

package/core/types/logger.ts

@@ -1,4 +1,5 @@
 export type Logger = {
   readonly debug: (message: string) => void;
+  readonly warn?: ((message: string) => void) | undefined;
   readonly error: (message: string, cause: unknown) => void;
 };

package/core/types/moduleVersions.ts

@@ -0,0 +1,35 @@
+import type { TkmsVersion } from '../../wasm/tkms/KmsLibApi.js';
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
+
+export type { TkmsVersion, TfheVersion };
+
+/**
+ * Controls how explicit WASM module-version overrides are checked against the
+ * resolved protocol compatibility table.
+ *
+ * This option only applies when a concrete `tfhe` or `kms` version is provided.
+ * It does not affect auto-resolution.
+ */
+export type ModuleVersionCompatibilityCheck = 'throw' | 'warn' | 'off';
+
+export type FhevmEncryptModuleVersions =
+  | 'auto'
+  | {
+      readonly tfhe?: TfheVersion | undefined;
+      readonly checkCompatibility?: ModuleVersionCompatibilityCheck | undefined;
+    };
+
+export type FhevmDecryptModuleVersions =
+  | 'auto'
+  | {
+      readonly kms?: TkmsVersion | undefined;
+      readonly checkCompatibility?: ModuleVersionCompatibilityCheck | undefined;
+    };
+
+export type FhevmModuleVersions =
+  | 'auto'
+  | {
+      readonly tfhe?: TfheVersion | undefined;
+      readonly kms?: TkmsVersion | undefined;
+      readonly checkCompatibility?: ModuleVersionCompatibilityCheck | undefined;
+    };

package/core/types/relayer.ts

@@ -34,6 +34,7 @@ export type FetchDelegatedUserDecryptResult = readonly FetchUserDecryptResultIte
 
 export type RelayerCommonOptions = {
   auth?: Auth | undefined;
+  headers?: Record<string, string>;
   debug?: boolean | undefined;
   fetchRetries?: number | undefined;
   fetchRetryDelayInMilliseconds?: number | undefined;

package/core/types/tkms-p.ts

@@ -1,5 +1,8 @@
+import type { TkmsVersion } from '../../wasm/tkms/KmsLibApi.js';
+
 export declare const TkmsPrivateKeyBrand: unique symbol;
 
 export type TkmsPrivateKey = {
+  readonly tkmsVersion: TkmsVersion;
   readonly [TkmsPrivateKeyBrand]: never;
 };

package/core/types/wasmAssets.ts

@@ -0,0 +1,6 @@
+export type WasmAssetLoadMode =
+  | 'embedded-base64'
+  | 'verified-blob'
+  | 'precheck-direct-url'
+  | 'trusted-direct-url'
+  | 'auto';

package/core/types/{zkProofBuilder.ts → zkProofBuilder-p.ts}

@@ -1,5 +1,4 @@
 import type { EncryptionBits } from './fheType.js';
-import type { Fhevm } from './coreFhevmClient.js';
 import type {
   AddressValueLike,
   BoolValueLike,
@@ -14,6 +13,7 @@ import type {
 import type { ZkProof } from './zkProof-p.js';
 import type { WithEncrypt } from './coreFhevmRuntime.js';
 import type { FhevmChain } from './fhevmChain.js';
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
 
 export interface ZkProofBuilder {
   addBool(value: boolean | number | bigint | BoolValueLike): this;
@@ -27,10 +27,11 @@ export interface ZkProofBuilder {
   addTypedValue(typedValue: TypedValue): this;
   getBits(): EncryptionBits[];
   build(
-    fhevm: Fhevm<FhevmChain, WithEncrypt>,
+    context: { readonly chain: FhevmChain; readonly runtime: WithEncrypt; readonly tfheVersion: TfheVersion },
     parameters: {
       readonly contractAddress: string;
       readonly userAddress: string;
+      readonly extraData: string;
     },
   ): Promise<ZkProof>;
 }

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

@@ -1,6 +1,7 @@
 import type { TkmsPrivateKey } from '../../types/tkms-p.js';
 import type { FhevmRuntime, WithDecrypt } from '../../types/coreFhevmRuntime.js';
 import type { BytesHex } from '../../types/primitives.js';
+import type { TkmsVersion } from '../../../wasm/tkms/KmsLibApi.js';
 
 /**
  * Verifies that a TKMS public key matches the given private key
@@ -9,7 +10,7 @@ import type { BytesHex } from '../../types/primitives.js';
  * @throws If the derived public key does not match `tkmsPublicKeyBytesHex`.
  */
 export async function verifyTkmsPublicKey(
-  context: { readonly runtime: FhevmRuntime<WithDecrypt> },
+  context: { readonly runtime: FhevmRuntime<WithDecrypt>; readonly tkmsVersion: TkmsVersion },
   parameters: {
     readonly tkmsPrivateKey: TkmsPrivateKey;
     readonly tkmsPublicKeyBytesHex: BytesHex;
@@ -19,6 +20,7 @@ export async function verifyTkmsPublicKey(
 
   const expectedTkmsPublicKeyBytesHex = await context.runtime.decrypt.getTkmsPublicKeyHex({
     tkmsPrivateKey,
+    tkmsVersion: context.tkmsVersion,
   });
 
   if (expectedTkmsPublicKeyBytesHex !== tkmsPublicKeyBytesHex) {

package/ethers/cleartext/createFhevmCleartextDecryptClient.ts

@@ -1,7 +1,7 @@
 import type { ethers as EthersT } from 'ethers';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmDecryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmDecryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
 import { decryptActions } from './decorators/decrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmCleartextDecryptClient<
 >(parameters: {
   readonly provider: provider;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmDecryptOptions | undefined;
 }): FhevmDecryptClient<chain, WithDecrypt, provider> {
   const c = createFhevmCleartextBaseClient(parameters);
   return c.extend(decryptActions);

package/ethers/cleartext/createFhevmCleartextEncryptClient.ts

@@ -1,7 +1,7 @@
 import type { ethers as EthersT } from 'ethers';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmEncryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmEncryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
 import { encryptActions } from './decorators/encrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmCleartextEncryptClient<
 >(parameters: {
   readonly provider: provider;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmEncryptOptions | undefined;
 }): FhevmEncryptClient<chain, WithEncrypt, provider> {
   const c = createFhevmCleartextBaseClient(parameters);
 

package/ethers/clients/createFhevmDecryptClient.ts

@@ -1,7 +1,7 @@
 import type { ethers as EthersT } from 'ethers';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmDecryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmDecryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmBaseClient } from './createFhevmBaseClient.js';
 import { decryptActions } from './decorators/decrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmDecryptClient<
 >(parameters: {
   readonly provider: provider;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmDecryptOptions | undefined;
 }): FhevmDecryptClient<chain, WithDecrypt, provider> {
   const c = createFhevmBaseClient(parameters);
   return c.extend(decryptActions);

package/ethers/clients/createFhevmEncryptClient.ts

@@ -1,7 +1,7 @@
 import type { ethers as EthersT } from 'ethers';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmEncryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmEncryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmBaseClient } from './createFhevmBaseClient.js';
 import { encryptActions } from './decorators/encrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmEncryptClient<
 >(parameters: {
   readonly provider: provider;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmEncryptOptions | undefined;
 }): FhevmEncryptClient<chain, WithEncrypt, provider> {
   const c = createFhevmBaseClient(parameters);
 

package/ethers/internal/config.ts

@@ -1,5 +1,5 @@
 import type { FhevmRuntimeConfig } from '../../core/types/coreFhevmRuntime.js';
-import { cloneModuleVersions } from '../../core/runtimeConfig-p.js';
+import { cloneModuleVersions, moduleVersionsAreEqual } from '../../core/runtimeConfig-p.js';
 
 let ethersFhevmRuntimeConfig: FhevmRuntimeConfig | undefined;
 
@@ -17,7 +17,7 @@ let ethersFhevmRuntimeConfig: FhevmRuntimeConfig | undefined;
  */
 export function setFhevmRuntimeConfig(config: FhevmRuntimeConfig): void {
   if (ethersFhevmRuntimeConfig === undefined) {
-    ethersFhevmRuntimeConfig = Object.freeze({
+    ethersFhevmRuntimeConfig = Object.freeze<FhevmRuntimeConfig>({
       ...config,
       logger: config.logger ? Object.freeze({ ...config.logger }) : undefined,
       moduleVersions: cloneModuleVersions(config.moduleVersions),
@@ -52,31 +52,3 @@ export function getFhevmRuntimeConfig(): FhevmRuntimeConfig {
   }
   return ethersFhevmRuntimeConfig;
 }
-
-function moduleVersionsAreEqual(
-  a: FhevmRuntimeConfig['moduleVersions'],
-  b: FhevmRuntimeConfig['moduleVersions'],
-): boolean {
-  const normalizedA = normalizeModuleVersions(a);
-  const normalizedB = normalizeModuleVersions(b);
-  return (
-    normalizedA.tfhe === normalizedB.tfhe &&
-    normalizedA.kms === normalizedB.kms &&
-    normalizedA.checkCompatibility === normalizedB.checkCompatibility
-  );
-}
-
-function normalizeModuleVersions(moduleVersions: FhevmRuntimeConfig['moduleVersions']): {
-  readonly tfhe: 'auto' | NonNullable<Exclude<FhevmRuntimeConfig['moduleVersions'], 'auto'>>['tfhe'];
-  readonly kms: 'auto' | NonNullable<Exclude<FhevmRuntimeConfig['moduleVersions'], 'auto'>>['kms'];
-  readonly checkCompatibility: NonNullable<Exclude<FhevmRuntimeConfig['moduleVersions'], 'auto'>>['checkCompatibility'];
-} {
-  if (moduleVersions === undefined || moduleVersions === 'auto') {
-    return { tfhe: 'auto', kms: 'auto', checkCompatibility: undefined };
-  }
-  return {
-    tfhe: moduleVersions.tfhe ?? 'auto',
-    kms: moduleVersions.kms ?? 'auto',
-    checkCompatibility: moduleVersions.checkCompatibility,
-  };
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fhevm/sdk",
   "description": "TypeScript Interface for FHEVM",
-  "version": "1.1.0-alpha.3",
+  "version": "1.1.0-alpha.5",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/viem/cleartext/createFhevmCleartextDecryptClient.ts

@@ -1,7 +1,7 @@
 import type { PublicClient } from 'viem';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmDecryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmDecryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
 import { decryptActions } from './decorators/decrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmCleartextDecryptClient<
 >(parameters: {
   readonly publicClient: publicClient;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmDecryptOptions | undefined;
 }): FhevmDecryptClient<chain, WithDecrypt, publicClient> {
   const c = createFhevmCleartextBaseClient(parameters);
   return c.extend(decryptActions);

package/viem/cleartext/createFhevmCleartextEncryptClient.ts

@@ -1,7 +1,7 @@
 import type { PublicClient } from 'viem';
 import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
-import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmEncryptOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmEncryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
 import { encryptActions } from './decorators/encrypt.js';
@@ -14,7 +14,7 @@ export function createFhevmCleartextEncryptClient<
 >(parameters: {
   readonly publicClient: publicClient;
   readonly chain: chain;
-  readonly options?: FhevmOptions | undefined;
+  readonly options?: FhevmEncryptOptions | undefined;
 }): FhevmEncryptClient<chain, WithEncrypt, publicClient> {
   const c = createFhevmCleartextBaseClient(parameters);