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

package/core/host-contracts/readKmsSignersContext-p.ts

@@ -1,5 +1,5 @@
 import type { KmsSignersContext } from '../types/kmsSignersContext.js';
-import type { BytesHex, ChecksummedAddress, Uint256BigInt, Uint8Number } from '../types/primitives.js';
+import type { BytesHex, ChecksummedAddress, Uint256BigInt } from '../types/primitives.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
 import {
   assertIsKmsSignersContext,
@@ -7,8 +7,15 @@ import {
   kmsSignersContextToExtraData,
 } from './KmsSignersContext-p.js';
 import { getCurrentKmsContextId } from './getCurrentKmsContextId-p.js';
-import { getVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
-import { assertIsKmsExtraData, fromKmsExtraData, toKmsExtraData } from '../kms/kmsExtraData.js';
+import { getCurrentKmsContextAndEpoch } from './getCurrentKmsContextAndEpoch-p.js';
+import { getHostContractVersion, isVersionStrictlyBefore } from './HostContractVersion-p.js';
+import {
+  assertIsKmsExtraData,
+  EXTRA_DATA_V1,
+  EXTRA_DATA_V2,
+  fromKmsExtraData,
+  toKmsExtraData,
+} from '../kms/kmsExtraData.js';
 import { getKmsContextSignersAndThresholdFromExtraData } from './getKmsContextSignersAndThresholdFromExtraData-p.js';
 import { getKmsSignersAndThreshold } from './getKmsContextSignersAndThreshold-p.js';
 
@@ -21,9 +28,11 @@ type Context = {
 };
 
 type Parameters = {
-  readonly address: ChecksummedAddress;
+  readonly kmsVerifierAddress: ChecksummedAddress;
+  readonly protocolConfigAddress: ChecksummedAddress | undefined;
   readonly forceRefresh?: boolean | undefined;
   readonly kmsContextId?: Uint256BigInt | undefined;
+  readonly kmsEpochId?: Uint256BigInt | undefined;
 };
 
 type ReturnType = KmsSignersContext;
@@ -31,25 +40,30 @@ type ReturnType = KmsSignersContext;
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function readKmsSignersContext(context: Context, parameters: Parameters): Promise<ReturnType> {
-  const kmsVerifierContractAddress = parameters.address;
-
   // TTL-cached
-  const version = await getVersion(context, {
-    address: kmsVerifierContractAddress,
+  const kmsVerifierVersion = await getHostContractVersion(context, {
+    address: parameters.kmsVerifierAddress,
   });
 
-  if (isVersionStrictlyBefore(version, { major: 0, minor: 2 })) {
-    return _readKmsSignersContextV1(context, parameters);
-  } else {
-    return _readKmsSignersContext(context, parameters);
+  if (isVersionStrictlyBefore(kmsVerifierVersion, { major: 0, minor: 2 })) {
+    return _readKmsSignersContext_Protocol_11(context, parameters);
   }
+
+  if (isVersionStrictlyBefore(kmsVerifierVersion, { major: 0, minor: 4 })) {
+    return _readKmsSignersContext_Protocol_12_13(context, parameters);
+  }
+
+  return _readKmsSignersContext_Protocol_14(context, parameters);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-async function _readKmsSignersContextV1(context: Context, parameters: Parameters): Promise<ReturnType> {
+// Protocol v0.11.0 (KMSVerifier < v0.2.0) had no context ID support, so the only valid
+// context ID is 0. Any other value is invalid and should throw.
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _readKmsSignersContext_Protocol_11(context: Context, parameters: Parameters): Promise<ReturnType> {
   if (parameters.kmsContextId !== undefined && parameters.kmsContextId !== 0n) {
-    throw new Error('Impossible on v1');
+    throw new Error('Impossible on protocol v0.11.0');
   }
 
   // TTL-Cached
@@ -58,6 +72,7 @@ async function _readKmsSignersContextV1(context: Context, parameters: Parameters
   const data = createKmsSignersContext(new WeakRef(context.runtime), {
     ...parameters,
     kmsContextId: 0n as Uint256BigInt,
+    kmsEpochId: 0n as Uint256BigInt,
     kmsSigners: c.signers,
     kmsSignerThreshold: c.threshold,
   });
@@ -67,32 +82,81 @@ async function _readKmsSignersContextV1(context: Context, parameters: Parameters
 
 ////////////////////////////////////////////////////////////////////////////////
 
-async function _readKmsSignersContext(context: Context, parameters: Parameters): Promise<ReturnType> {
+// Protocol v0.12.0 / v0.13.0 (KMSVerifier = v0.2.0 / v0.3.0)
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _readKmsSignersContext_Protocol_12_13(context: Context, parameters: Parameters): Promise<ReturnType> {
+  if (parameters.kmsEpochId !== undefined && parameters.kmsEpochId !== 0n) {
+    throw new Error('kmsEpochId should be 0 on protocol v0.12.0 / v0.13.0');
+  }
+
   let kmsContextId: Uint256BigInt;
-  if (parameters.kmsContextId !== undefined) {
+  if (parameters.kmsContextId === undefined) {
+    // TTL-Cached
+    kmsContextId = await getCurrentKmsContextId(context, parameters);
+  } else {
     if (parameters.kmsContextId === 0n) {
-      throw new Error('Impossible on v2');
+      throw new Error('kmsContextId cannot be 0 on protocol v0.12.0 / v0.13.0');
     }
     kmsContextId = parameters.kmsContextId;
-  } else {
-    // TTL-Cached
-    kmsContextId = await getCurrentKmsContextId(context, parameters);
   }
 
-  return _readKmsSignersContextForContextId(context, {
+  const extraData = toKmsExtraData({
+    version: EXTRA_DATA_V1,
+    kmsContextId,
+    kmsEpochId: 0n as Uint256BigInt,
+  });
+
+  // Permanent-Cached
+  const c = await getKmsContextSignersAndThresholdFromExtraData(context, {
+    ...parameters,
+    extraData,
+  });
+
+  return createKmsSignersContext(new WeakRef(context.runtime), {
     ...parameters,
     kmsContextId,
+    kmsEpochId: 0n as Uint256BigInt,
+    kmsSigners: c.signers,
+    kmsSignerThreshold: c.threshold,
   });
 }
 
-async function _readKmsSignersContextForContextId(
-  context: Context,
-  parameters: Parameters & { readonly kmsContextId: Uint256BigInt },
-): Promise<ReturnType> {
-  const { kmsContextId } = parameters;
+////////////////////////////////////////////////////////////////////////////////
+
+// Protocol v0.14.0+ (KMSVerifier = v0.4.0+)
+// eslint-disable-next-line @typescript-eslint/naming-convention
+async function _readKmsSignersContext_Protocol_14(context: Context, parameters: Parameters): Promise<ReturnType> {
+  if (parameters.protocolConfigAddress === undefined) {
+    throw new Error('protocolConfigAddress is required on protocol v0.14.0+');
+  }
+  const protocolConfigAddress = parameters.protocolConfigAddress;
+
+  let kmsContextId: Uint256BigInt;
+  if (parameters.kmsContextId === undefined) {
+    // TTL-Cached
+    ({ contextId: kmsContextId } = await getCurrentKmsContextAndEpoch(context, { protocolConfigAddress }));
+  } else {
+    if (parameters.kmsContextId === 0n) {
+      throw new Error('kmsContextId cannot be 0 on protocol v0.14.0+');
+    }
+    kmsContextId = parameters.kmsContextId;
+  }
+
+  let kmsEpochId: Uint256BigInt;
+  if (parameters.kmsEpochId === undefined) {
+    // TTL-Cached
+    ({ epochId: kmsEpochId } = await getCurrentKmsContextAndEpoch(context, { protocolConfigAddress }));
+  } else {
+    if (parameters.kmsEpochId === 0n) {
+      throw new Error('kmsEpochId cannot be 0 on protocol v0.14.0+');
+    }
+    kmsEpochId = parameters.kmsEpochId;
+  }
+
   const extraData = toKmsExtraData({
-    version: 1 as Uint8Number,
+    version: EXTRA_DATA_V2,
     kmsContextId,
+    kmsEpochId,
   });
 
   // Permanent-Cached
@@ -101,14 +165,13 @@ async function _readKmsSignersContextForContextId(
     extraData,
   });
 
-  const data = createKmsSignersContext(new WeakRef(context.runtime), {
+  return createKmsSignersContext(new WeakRef(context.runtime), {
     ...parameters,
     kmsContextId,
+    kmsEpochId,
     kmsSigners: c.signers,
     kmsSignerThreshold: c.threshold,
   });
-
-  return data;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -130,13 +193,24 @@ async function _readKmsSignersContextForContextId(
  * - `requestedExtraData` — `kmsSignersContextToExtraData(requestedKmsSignersContext)`.
  * - `relayerKmsContextId` — `fromKmsExtraData(relayerExtraData).kmsContextId`.
  *
+ * ### Host-Contract Compatibility
+ *
+ * `extraData` is versioned independently from the host-contract package. The
+ * currently supported combinations are:
+ *
+ * - host-contracts v11 support `extraData` v0.
+ * - host-contracts v12 and v13 support `extraData` v0 and v1.
+ * - host-contracts v14 support `extraData` v0, v1, and v2.
+ *
  * ### Resolution (checked in order)
  *
  * 1. `relayerExtraData === requestedExtraData` → exact byte match, return
  *    `requestedKmsSignersContext`. This is the **only** path that trusts cached data.
- * 2. Serialization version mismatch → **always throw**. The SDK and relayer must
+ * 2. In `'exact'` mode, any byte mismatch → **always throw**. This mode does
+ *    not parse, refresh, or reconcile different `extraData`.
+ * 3. Serialization version mismatch → **always throw**. The SDK and relayer must
  *    agree on the `extraData` encoding format, even if the context ID is the same.
- * 3. Context IDs differ → **full on-chain refetch**. The cached context is never
+ * 4. Context IDs differ → **full on-chain refetch**. The cached context is never
  *    reused, because any mismatch means on-chain state may have diverged
  *    (rotation, destruction, signer changes, etc.).
  *    - Context is **valid** on-chain (current or non-destroyed) → return it.
@@ -144,26 +218,31 @@ async function _readKmsSignersContextForContextId(
  *
  * ### Modes
  *
- * - `'strict'` — Accept step 1 (exact match) or `relayerKmsContextId === currentKmsContextId`.
- *   Rejects valid-but-not-current contexts.
+ * - `'exact'` — Accept only step 1 (byte-for-byte `extraData` equality).
+ *   Rejects any relayer/context drift without parsing or on-chain recovery.
+ * - `'strict'` — Accept step 1 (exact match) or both `relayerKmsContextId === currentKmsContextId`
+ *   and `relayerKmsEpochId === currentKmsEpochId`. Rejects valid-but-not-current contexts.
+ *   The epoch check is required because RFC 005 introduces same-context epoch rotations
+ *   (new shares, same party set) — a stale epoch must be rejected even if the context matches.
  * - `'loose'` — Accept any on-chain valid context (non-destroyed, in range),
  *   regardless of whether it is current. Covers context rotations in either direction.
  */
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export type ReconcileMode = 'strict' | 'loose';
+export type ReconcileMode = 'exact' | 'strict' | 'loose';
 
 export async function reconcileKmsSignersContext(
   context: Context,
   parameters: {
-    readonly address: ChecksummedAddress;
+    readonly kmsVerifierAddress: ChecksummedAddress;
+    readonly protocolConfigAddress: ChecksummedAddress | undefined;
     readonly requestedKmsSignersContext: KmsSignersContext;
     readonly relayerExtraData: BytesHex;
     readonly mode: ReconcileMode;
   },
 ): Promise<KmsSignersContext> {
-  const { address, requestedKmsSignersContext, relayerExtraData, mode } = parameters;
+  const { kmsVerifierAddress, protocolConfigAddress, requestedKmsSignersContext, relayerExtraData, mode } = parameters;
 
   assertIsKmsExtraData(relayerExtraData, {});
   assertIsKmsSignersContext(requestedKmsSignersContext, {});
@@ -175,6 +254,13 @@ export async function reconcileKmsSignersContext(
     return requestedKmsSignersContext;
   }
 
+  if (mode === 'exact') {
+    throw new Error(
+      `Exact reconciliation failed: relayer extraData ${relayerExtraData} ` +
+        `does not match requested extraData ${requestedExtraData}.`,
+    );
+  }
+
   // Bytes differ — extract and compare serialization versions.
   const relayerKmsExtraData = fromKmsExtraData(relayerExtraData);
   const requestedKmsExtraData = fromKmsExtraData(requestedExtraData);
@@ -190,17 +276,19 @@ export async function reconcileKmsSignersContext(
 
   // Versions match but context IDs differ — verify the relayer's context on-chain.
   const relayerKmsContextId = relayerKmsExtraData.kmsContextId;
+  const relayerKmsEpochId = relayerKmsExtraData.kmsEpochId;
 
   // 2. In strict mode, only accept if the relayer used the current on-chain context.
   if (mode === 'strict') {
     // `readKmsSignersContext` with `forceRefresh` fetches the current context.
     // If `relayerKmsContextId` matches current, we're good.
     const currentContext = await readKmsSignersContext(context, {
-      address,
+      kmsVerifierAddress,
+      protocolConfigAddress,
       forceRefresh: true,
     });
 
-    if (currentContext.id !== relayerKmsContextId) {
+    if (currentContext.id !== relayerKmsContextId || currentContext.epochId !== relayerKmsEpochId) {
       throw new Error(
         `Strict reconciliation failed: relayer used context ${relayerKmsContextId}, ` +
           `but the current on-chain context is ${currentContext.id}.`,
@@ -211,11 +299,13 @@ export async function reconcileKmsSignersContext(
   }
 
   // 3. Loose mode — accept any valid (non-destroyed, in-range) context.
-  //    `readKmsSignersContext` with `forceRefresh` + specific `kmsContextId` will
+  //    `readKmsSignersContext` with `forceRefresh` + specific `kmsContextId`/`kmsEpochId` will
   //    throw if the context is destroyed or out of range.
   return readKmsSignersContext(context, {
-    address,
+    kmsVerifierAddress,
+    protocolConfigAddress,
     kmsContextId: relayerKmsContextId,
+    kmsEpochId: relayerKmsEpochId,
     forceRefresh: true,
   });
 }

package/core/key/FheEncryptionKeyWasm-p.ts

@@ -1,4 +1,5 @@
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
 import type {
   FheEncryptionCrs,
   FheEncryptionKeyMetadata,
@@ -21,6 +22,7 @@ class FheEncryptionKeyWasmImpl implements FheEncryptionKeyWasm {
   readonly #crs: FheEncryptionCrs;
   readonly #publicKey: FheEncryptionPublicKey;
   readonly #metadata: FheEncryptionKeyMetadata;
+  readonly #tfheVersion: TfheVersion;
 
   constructor(
     privateToken: symbol,
@@ -29,6 +31,7 @@ class FheEncryptionKeyWasmImpl implements FheEncryptionKeyWasm {
       readonly publicKey: FheEncryptionPublicKey;
       readonly crs: FheEncryptionCrs;
       readonly metadata: FheEncryptionKeyMetadata;
+      readonly tfheVersion: TfheVersion;
     },
   ) {
     if (privateToken !== PRIVATE_TOKEN) {
@@ -38,6 +41,7 @@ class FheEncryptionKeyWasmImpl implements FheEncryptionKeyWasm {
     this.#publicKey = parameters.publicKey;
     this.#crs = parameters.crs;
     this.#metadata = Object.freeze({ ...parameters.metadata });
+    this.#tfheVersion = parameters.tfheVersion;
 
     Object.freeze(this);
   }
@@ -50,17 +54,29 @@ class FheEncryptionKeyWasmImpl implements FheEncryptionKeyWasm {
     return this.#crs;
   }
 
+  public get tfheVersion(): TfheVersion {
+    return this.#tfheVersion;
+  }
+
   public get metadata(): FheEncryptionKeyMetadata {
     return this.#metadata;
   }
 
-  public static [VERIFY_FUNC](privateToken: symbol, instance: unknown, owner: FhevmRuntime): void {
+  public static [VERIFY_FUNC](
+    privateToken: symbol,
+    instance: unknown,
+    owner: FhevmRuntime,
+    tfheVersion: TfheVersion,
+  ): void {
     if (privateToken !== PRIVATE_TOKEN) {
       throw new Error('Unauthorized');
     }
     if (!(instance instanceof FheEncryptionKeyWasmImpl)) {
       throw new Error('Invalid FheEncryptionKey instance');
     }
+    if (tfheVersion !== instance.#tfheVersion) {
+      throw new Error('TfheVersion mismatch');
+    }
     assertOwnedBy({
       actualOwner: instance.#owner,
       expectedOwner: owner,
@@ -81,6 +97,7 @@ export function createFheEncryptionKeyWasm(
     readonly publicKey: FheEncryptionPublicKey;
     readonly crs: FheEncryptionCrs;
     readonly metadata: FheEncryptionKeyMetadata;
+    readonly tfheVersion: TfheVersion;
   },
 ): FheEncryptionKeyWasm {
   return new FheEncryptionKeyWasmImpl(PRIVATE_TOKEN, owner, parameters);
@@ -92,6 +109,10 @@ export function createFheEncryptionKeyWasm(
  * Verifies that the given `FheEncryptionKeyWasm` instance is owned
  * by the given runtime. Throws if not.
  */
-export function assertFheEncryptionKeyWasmOwnedBy(data: FheEncryptionKeyWasm, owner: FhevmRuntime): void {
-  FheEncryptionKeyWasmImpl[VERIFY_FUNC](PRIVATE_TOKEN, data, owner);
+export function assertFheEncryptionKeyWasmOwnedBy(
+  data: FheEncryptionKeyWasm,
+  owner: FhevmRuntime,
+  tfheVersion: TfheVersion,
+): void {
+  FheEncryptionKeyWasmImpl[VERIFY_FUNC](PRIVATE_TOKEN, data, owner, tfheVersion);
 }

package/core/key/deserializeFheEncryptionKey.ts

@@ -1,24 +1,31 @@
 import type { WithEncrypt } from '../types/coreFhevmRuntime.js';
 import type { FheEncryptionKeyWasm, FheEncryptionKeyBytes } from '../types/fheEncryptionKey.js';
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
 import { createFheEncryptionKeyWasm } from './FheEncryptionKeyWasm-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function deserializeFheEncryptionKey(
-  context: { readonly runtime: WithEncrypt },
+  context: {
+    readonly runtime: WithEncrypt;
+    readonly tfheVersion: TfheVersion;
+  },
   parameters: FheEncryptionKeyBytes,
 ): Promise<FheEncryptionKeyWasm> {
   const publicKeyNative = await context.runtime.encrypt.deserializeFheEncryptionPublicKey({
     publicKeyBytes: parameters.publicKeyBytes,
+    tfheVersion: context.tfheVersion,
   });
 
   const crsNative = await context.runtime.encrypt.deserializeFheEncryptionCrs({
     crsBytes: parameters.crsBytes,
+    tfheVersion: context.tfheVersion,
   });
 
   return createFheEncryptionKeyWasm(new WeakRef(context.runtime), {
     publicKey: publicKeyNative,
     crs: crsNative,
     metadata: parameters.metadata,
+    tfheVersion: context.tfheVersion,
   });
 }

package/core/key/fetchFheEncryptionKey.ts

@@ -2,12 +2,17 @@ import type { RelayerKeyUrlOptions } from '../types/relayer.js';
 import type { WithEncrypt } from '../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../types/fhevmChain.js';
 import type { FheEncryptionKeyWasm } from '../types/fheEncryptionKey.js';
+import type { TfheVersion } from '../../wasm/tfhe/TfheApi.js';
 import { deserializeFheEncryptionKey } from './deserializeFheEncryptionKey.js';
 import { globalFheEncryptionKeyCache } from './FheEncryptionKeyCache-p.js';
 
 export async function fetchFheEncryptionKeyWasm(
-  context: { readonly chain: FhevmChain; readonly runtime: WithEncrypt },
-  parameters?: {
+  context: {
+    readonly chain: FhevmChain;
+    readonly runtime: WithEncrypt;
+    readonly tfheVersion: TfheVersion;
+  },
+  parameters: {
     readonly options?: RelayerKeyUrlOptions | undefined;
     readonly ignoreCache?: boolean | undefined;
   },
@@ -19,8 +24,7 @@ export async function fetchFheEncryptionKeyWasm(
   globalFheEncryptionKeyCache.ensureBytes({
     owner: runtime,
     relayerUrl,
-    fetcher: () =>
-      runtime.relayer.fetchFheEncryptionKeyBytes({ relayerUrl, chainId: context.chain.id }, parameters ?? {}),
+    fetcher: () => runtime.relayer.fetchFheEncryptionKeyBytes({ relayerUrl, chainId: context.chain.id }, parameters),
     metadata: { chainId: context.chain.id, relayerUrl },
   });
 

package/core/key/fetchFheEncryptionKeyBytes.ts

@@ -10,7 +10,10 @@ import { asFhevmRuntimeWith } from '../runtime/CoreFhevmRuntime-p.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function fetchFheEncryptionKeyBytes(
-  context: { readonly chain: FhevmChain; readonly runtime: FhevmRuntime },
+  context: {
+    readonly chain: FhevmChain;
+    readonly runtime: FhevmRuntime;
+  },
   parameters?: {
     readonly options?: RelayerKeyUrlOptions | undefined;
     readonly ignoreCache?: boolean | undefined;
@@ -51,7 +54,6 @@ export async function fetchFheEncryptionKeyBytes(
  * or `undefined` if the encrypt module is not available on the runtime.
  */
 function _getSerializeFn(context: {
-  readonly chain: FhevmChain;
   readonly runtime: FhevmRuntime;
 }): ((args: FheEncryptionKeyWasm) => Promise<FheEncryptionKeyBytes>) | undefined {
   // Try to get a serialize fn if the encrypt module is available

package/core/key/serializeFheEncryptionKey.ts

@@ -11,17 +11,23 @@ import {
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function serializeFheEncryptionKeyWasm(
-  context: { readonly runtime: WithEncrypt },
+  context: {
+    readonly runtime: WithEncrypt;
+  },
   parameters: FheEncryptionKeyWasm,
 ): Promise<FheEncryptionKeyBytes> {
-  assertFheEncryptionKeyWasmOwnedBy(parameters, context.runtime);
+  const tfheVersion = parameters.tfheVersion;
+
+  assertFheEncryptionKeyWasmOwnedBy(parameters, context.runtime, tfheVersion);
 
   const publicKeyBytes: FheEncryptionPublicKeyBytes = await context.runtime.encrypt.serializeFheEncryptionPublicKey({
     publicKey: parameters.publicKey,
+    tfheVersion,
   });
 
   const crsBytes: FheEncryptionCrsBytes = await context.runtime.encrypt.serializeFheEncryptionCrs({
     crs: parameters.crs,
+    tfheVersion,
   });
 
   const metadata: FheEncryptionKeyMetadata = Object.freeze({

package/core/kms/KmsSigncryptedShares-p.ts

@@ -4,6 +4,7 @@ import type { BytesHex, BytesHexNo0x, ChecksummedAddress } from '../types/primit
 import type { KmsSignersContext } from '../types/kmsSignersContext.js';
 import type { FhevmRuntime } from '../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../types/fhevmChain.js';
+import type { TkmsVersion } from '../../wasm/tkms/KmsLibApi.js';
 import { assertIsKmsSignersContext } from '../host-contracts/KmsSignersContext-p.js';
 import { ensure0x } from '../base/string.js';
 import { assertIsKmsExtraData } from './kmsExtraData.js';
@@ -40,6 +41,7 @@ class KmsSigncryptedSharesImpl implements KmsSigncryptedShares {
       eip712Signature: metadata.eip712Signature,
       eip712SignerAddress: metadata.eip712SignerAddress,
       handles: [...metadata.handles],
+      tkmsVersion: metadata.tkmsVersion,
     };
     Object.freeze(this.#metadata);
     Object.freeze(this.#metadata.handles);
@@ -47,6 +49,13 @@ class KmsSigncryptedSharesImpl implements KmsSigncryptedShares {
     this.#shares = [...shares];
     Object.freeze(this.#shares);
     this.#shares.forEach((share) => Object.freeze(share));
+    if (this.#shares.length === 0) {
+      throw new Error('Expected at least one signcrypted share.');
+    }
+  }
+
+  public get tkmsVersion(): TkmsVersion {
+    return this.#metadata.tkmsVersion;
   }
 
   public [GET_SHARES_FUNC](token: symbol): readonly KmsSigncryptedShare[] {
@@ -136,7 +145,8 @@ export async function createKmsSigncryptedShares(
 
   // Reconcile KMS signer context using 'loose' mode.
   const reconciledKmsSignersContext: KmsSignersContext = await reconcileKmsSignersContext(context, {
-    address: context.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    kmsVerifierAddress: context.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    protocolConfigAddress: context.chain.fhevm.contracts.protocolConfig?.address as ChecksummedAddress | undefined,
     relayerExtraData,
     requestedKmsSignersContext: metadata.kmsSignersContext,
     mode: 'loose',

package/core/kms/SignedDecryptionPermit-p.ts

@@ -132,6 +132,10 @@ abstract class SignedDecryptionPermitBaseImpl {
   public get kmsContextId(): Uint256BigInt {
     return fromKmsExtraData(this.#eip712.message.extraData).kmsContextId;
   }
+
+  public get kmsEpochId(): Uint256BigInt {
+    return fromKmsExtraData(this.#eip712.message.extraData).kmsEpochId;
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -343,7 +347,8 @@ export async function signDecryptionPermit(
   parameters: SignDecryptionPermitParameters,
 ): Promise<SignedDecryptionPermit> {
   const kmsSignersContext = await readKmsSignersContext(context, {
-    address: context.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    kmsVerifierAddress: context.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    protocolConfigAddress: context.chain.fhevm.contracts.protocolConfig?.address as ChecksummedAddress | undefined,
   });
 
   const extraData: BytesHex = kmsSignersContextToExtraData(kmsSignersContext);