@fhevm/sdk 1.1.0-alpha.7 → 1.1.0-alpha.8

package/core/modules/relayer/cleartext/fetchCoprocessorSignatures.ts

@@ -1,22 +1,23 @@
-import type { Bytes65Hex, BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { Bytes65Hex, BytesHex, ChecksummedAddress, Uint32BigInt } from '../../../types/primitives.js';
 import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
 import type {
   FetchCoprocessorSignaturesParameters,
   FetchCoprocessorSignaturesReturnType,
   RelayerClientWithRuntime,
 } from '../types.js';
-import { asUint32BigInt, randomUniqueUints } from '../../../base/uint.js';
+import type { CoprocessorSignersContext } from '../../../types/coprocessorSignersContext.js';
+import { asUint32BigInt, asUint64BigInt, randomUniqueUints } from '../../../base/uint.js';
 import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
 import { getCoprocessorSignersPrivateKeyMap } from './signers.js';
+import { isForgeFhevmV1 } from './forgeFhevmV1.js';
+import { createCoprocessorEip712Domain } from '../../../coprocessor/createCoprocessorEip712Domain.js';
+import { coprocessorEip712PrimaryType, coprocessorEip712Types } from '../../../coprocessor/coprocessorEip712Types.js';
+import { readCoprocessorSignersContext } from '../../../host-contracts/readCoprocessorSignersContext-p.js';
 
-/*
-export type FetchCoprocessorSignaturesReturnType = {
-  readonly handles: readonly InputHandle[];
-  readonly coprocessorEip712Signatures: readonly Bytes65Hex[];
-  readonly extraData: BytesHex;
-};
+////////////////////////////////////////////////////////////////////////////////
+// runInputProofOnChain
+////////////////////////////////////////////////////////////////////////////////
 
-*/
 const inputProofAbi = [
   {
     type: 'function',
@@ -44,13 +45,14 @@ const inputProofAbi = [
   },
 ] as const;
 
-export async function fetchCoprocessorSignatures(
+async function runInputProofOnChain(
   relayerClient: RelayerClientWithRuntime,
-  parameters: FetchCoprocessorSignaturesParameters,
-): Promise<FetchCoprocessorSignaturesReturnType> {
-  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
-  const { payload } = parameters;
-
+  payload: FetchCoprocessorSignaturesParameters['payload'],
+): Promise<{
+  readonly digest: BytesHex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly threshold: Uint32BigInt;
+}> {
   const trustedClient = getTrustedClient(relayerClient);
   const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
     abi: inputProofAbi,
@@ -67,6 +69,87 @@ export async function fetchCoprocessorSignatures(
   const digest = res[0] as BytesHex;
   const signersAddress = res[1] as ChecksummedAddress[];
   const threshold = asUint32BigInt(res[2]);
+
+  return {
+    digest,
+    signersAddress,
+    threshold,
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// runInputProofOffChain
+////////////////////////////////////////////////////////////////////////////////
+
+async function runInputProofOffChain(
+  relayerClient: RelayerClientWithRuntime,
+  payload: FetchCoprocessorSignaturesParameters['payload'],
+): Promise<{
+  readonly digest: BytesHex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly threshold: Uint32BigInt;
+}> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { zkProof } = payload;
+
+  // Read the coprocessor signer set + threshold from the InputVerifier's on-chain
+  // storage. In the forge-fhevm-v1 setup only the `inputProof` view is missing;
+  // the signers/threshold and the EIP-712 material are still readable, so we
+  // recompute the digest off-chain below (mirroring CleartextInputVerifier.inputProof).
+  const coprocessorSignersContext: CoprocessorSignersContext = await readCoprocessorSignersContext(relayerClient, {
+    address: relayerClient.chain.fhevm.contracts.inputVerifier.address as ChecksummedAddress,
+  });
+
+  // The 'InputVerification' domain uses the gateway chainId + gateway
+  // inputVerification address (same as verifyHandlesCoprocessorSignatures).
+  const domain = createCoprocessorEip712Domain({
+    gatewayChainId: relayerClient.chain.fhevm.gateway.id,
+    verifyingContractAddressInputVerification: relayerClient.chain.fhevm.gateway.contracts.inputVerification.address,
+  });
+
+  // Mirror CleartextInputVerifier.inputProof: hash the CiphertextVerification
+  // struct with contractChainId = block.chainid (the host chain), and extraData
+  // taken verbatim from the ZK proof (as the on-chain view would receive it).
+  const digest: BytesHex = cleartextEthereumModule.hashTypedData({
+    domain,
+    types: coprocessorEip712Types,
+    primaryType: coprocessorEip712PrimaryType,
+    message: {
+      ctHandles: zkProof.getInputHandles().map((h) => h.bytes32Hex),
+      userAddress: zkProof.userAddress,
+      contractAddress: zkProof.contractAddress,
+      contractChainId: asUint64BigInt(BigInt(relayerClient.chain.id)),
+      extraData: zkProof.getExtraData(),
+    },
+  });
+
+  return {
+    digest,
+    signersAddress: coprocessorSignersContext.signers,
+    threshold: asUint32BigInt(BigInt(coprocessorSignersContext.threshold)),
+  };
+}
+
+export async function fetchCoprocessorSignatures(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchCoprocessorSignaturesParameters,
+): Promise<FetchCoprocessorSignaturesReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { payload } = parameters;
+
+  const offChain = await isForgeFhevmV1(relayerClient);
+
+  let res;
+  if (offChain) {
+    res = await runInputProofOffChain(relayerClient, payload);
+  } else {
+    res = await runInputProofOnChain(relayerClient, payload);
+  }
+
+  const digest = res.digest;
+  const signersAddress = res.signersAddress;
+  const threshold = res.threshold;
+
   const signers = getCoprocessorSignersPrivateKeyMap(relayerClient);
 
   const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(

package/core/modules/relayer/cleartext/{fetchDelegatedUserDecrypt.ts → fetchDelegatedUserDecryptV1.ts}

@@ -1,4 +1,4 @@
-import type { BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
+import type { BytesHex, ChecksummedAddress, Uint32BigInt } from '../../../types/primitives.js';
 import type { FetchUserDecryptResultItem } from '../../../types/relayer.js';
 import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
 import type {
@@ -6,12 +6,69 @@ import type {
   FetchUserDecryptReturnType,
   RelayerClientWithRuntime,
 } from '../types.js';
+import type { KmsSignersContext } from '../../../types/kmsSignersContext.js';
 import { remove0x } from '../../../base/string.js';
 import { asUint32BigInt, tryParseUintBigIntString, randomUniqueUints } from '../../../base/uint.js';
 import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
 import { userDecryptResultToKmsSigncryptedShares } from '../utils.js';
 import { getKmsSignersPrivateKeyMap } from './signers.js';
+import { isForgeFhevmV1, readPlaintexts, xorMaskWithPublicKey } from './forgeFhevmV1.js';
+import { readCurrentKmsSignersContext } from '../../../host-contracts/readKmsSignersContext-p.js';
 
+////////////////////////////////////////////////////////////////////////////////
+// runDelegatedUserDecryptOffChain
+////////////////////////////////////////////////////////////////////////////////
+
+async function runDelegatedUserDecryptOffChain(
+  relayerClient: RelayerClientWithRuntime,
+  payload: FetchDelegatedUserDecryptParameters['payload'],
+): Promise<{
+  readonly commonKmsSigncryptedSharePayload: BytesHex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly threshold: Uint32BigInt;
+  readonly extraData: BytesHex;
+}> {
+  const { kmsDecryptEip712Message } = payload;
+  const pairs = payload.handleContractPairs;
+  const trustedClient = getTrustedClient(relayerClient);
+
+  const rawCleartexts = await readPlaintexts(
+    relayerClient,
+    trustedClient,
+    pairs.map((p) => p.handle),
+  );
+
+  const currentKmsSignersContext: KmsSignersContext = await readCurrentKmsSignersContext(relayerClient, {
+    kmsVerifierAddress: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    protocolConfigAddress: relayerClient.chain.fhevm.contracts.protocolConfig?.address as
+      | ChecksummedAddress
+      | undefined,
+  });
+  const signersAddress = currentKmsSignersContext.signers;
+  const threshold = currentKmsSignersContext.threshold;
+
+  const maskedCleartexts = xorMaskWithPublicKey(kmsDecryptEip712Message.publicKey, rawCleartexts);
+
+  // extraData: the permit's message.extraData is already asserted equal to the
+  // current KmsSignersContext extraData by the caller (fetchKmsSigncryptedSharesV1
+  // step 9), so reusing it keeps the shares consistent with that context.
+  const extraData = kmsDecryptEip712Message.extraData;
+
+  const commonKmsSigncryptedSharePayload = relayerClient.runtime.ethereum.encode({
+    types: ['uint256[]', 'bytes'],
+    values: [maskedCleartexts, extraData],
+  });
+
+  return {
+    signersAddress,
+    threshold: BigInt(threshold) as Uint32BigInt,
+    commonKmsSigncryptedSharePayload,
+    extraData,
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// runDelegatedUserDecryptOnChain
 ////////////////////////////////////////////////////////////////////////////////
 
 const delegatedUserDecryptAbi = [
@@ -62,32 +119,17 @@ const delegatedUserDecryptAbi = [
   },
 ] as const;
 
-////////////////////////////////////////////////////////////////////////////////
-
-export async function fetchDelegatedUserDecrypt(
+async function runDelegatedUserDecryptOnChain(
   relayerClient: RelayerClientWithRuntime,
-  parameters: FetchDelegatedUserDecryptParameters,
-): Promise<FetchUserDecryptReturnType> {
-  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
-  const { payload } = parameters;
-  const pairs = payload.handleContractPairs;
-  const contractAddresses = payload.kmsDecryptEip712Message.contractAddresses;
-
-  const authCount = contractAddresses.length;
-  for (const { contractAddress: c } of pairs) {
-    let authorized: boolean = false;
-    for (let i = 0; i < authCount; ++i) {
-      if (contractAddresses[i] == c) {
-        authorized = true;
-        break;
-      }
-    }
-    if (!authorized) {
-      throw new Error(`ContractAddressNotAuthorized: ${c} is not in the EIP-712 authorized contractAddresses list.`);
-    }
-  }
-
+  payload: FetchDelegatedUserDecryptParameters['payload'],
+): Promise<{
+  readonly commonKmsSigncryptedSharePayload: BytesHex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly threshold: Uint32BigInt;
+  readonly extraData: BytesHex;
+}> {
   const { kmsDecryptEip712Message, kmsDecryptEip712Signer, kmsDecryptEip712Signature } = payload;
+  const pairs = payload.handleContractPairs;
   const trustedClient = getTrustedClient(relayerClient);
   const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
     abi: delegatedUserDecryptAbi,
@@ -109,11 +151,57 @@ export async function fetchDelegatedUserDecrypt(
   })) as unknown[];
 
   const commonKmsSigncryptedSharePayload = res[0] as BytesHex;
-  const commonKmsSigncryptedSharePayloadNo0x = remove0x(commonKmsSigncryptedSharePayload);
   const signersAddress = res[1] as readonly ChecksummedAddress[];
   const threshold = asUint32BigInt(res[2]);
   const extraData = res[3] as BytesHex;
 
+  return {
+    commonKmsSigncryptedSharePayload,
+    signersAddress,
+    threshold,
+    extraData,
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchDelegatedUserDecrypt(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchDelegatedUserDecryptParameters,
+): Promise<FetchUserDecryptReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { payload } = parameters;
+  const pairs = payload.handleContractPairs;
+  const contractAddresses = payload.kmsDecryptEip712Message.contractAddresses;
+
+  const authCount = contractAddresses.length;
+  for (const { contractAddress: c } of pairs) {
+    let authorized: boolean = false;
+    for (let i = 0; i < authCount; ++i) {
+      if (contractAddresses[i] == c) {
+        authorized = true;
+        break;
+      }
+    }
+    if (!authorized) {
+      throw new Error(`ContractAddressNotAuthorized: ${c} is not in the EIP-712 authorized contractAddresses list.`);
+    }
+  }
+
+  const offChain = await isForgeFhevmV1(relayerClient);
+
+  let res;
+  if (offChain) {
+    res = await runDelegatedUserDecryptOffChain(relayerClient, payload);
+  } else {
+    res = await runDelegatedUserDecryptOnChain(relayerClient, payload);
+  }
+
+  const commonKmsSigncryptedSharePayload = res.commonKmsSigncryptedSharePayload;
+  const extraData = res.extraData;
+  const threshold = res.threshold;
+  const signersAddress = res.signersAddress;
+
   const signers = getKmsSignersPrivateKeyMap(relayerClient);
 
   const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(
@@ -130,7 +218,7 @@ export async function fetchDelegatedUserDecrypt(
     }
 
     const signature = await cleartextEthereumModule.sign({ hash: commonKmsSigncryptedSharePayload, privateKey });
-    result.push({ signature: remove0x(signature), payload: commonKmsSigncryptedSharePayloadNo0x, extraData });
+    result.push({ signature: remove0x(signature), payload: remove0x(commonKmsSigncryptedSharePayload), extraData });
   }
 
   return userDecryptResultToKmsSigncryptedShares(result);

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

@@ -1,8 +1,13 @@
 import type { Bytes32Hex, Bytes65Hex, BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
 import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
 import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
+import type { KmsSignersContext } from '../../../types/kmsSignersContext.js';
 import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
 import { getKmsSignersPrivateKeyMap } from './signers.js';
+import { encodeTypedCleartexts, isForgeFhevmV1, readPlaintexts } from './forgeFhevmV1.js';
+import { createKmsEip712Domain } from '../../../kms/createKmsEip712Domain.js';
+import { readCurrentKmsSignersContext } from '../../../host-contracts/readKmsSignersContext-p.js';
+import { kmsPublicDecryptEip712Types } from '../../../kms/kmsPublicDecryptEip712Types.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -28,22 +33,123 @@ const publicDecryptAbi = [
 
 ////////////////////////////////////////////////////////////////////////////////
 
-export async function fetchPublicDecrypt(
+async function runPublicDecryptOffChain(
   relayerClient: RelayerClientWithRuntime,
-  parameters: FetchPublicDecryptParameters,
-): Promise<FetchPublicDecryptReturnType> {
+  payload: FetchPublicDecryptParameters['payload'],
+): Promise<{
+  readonly orderedAbiEncodedClearValues: BytesHex;
+  readonly digest: Bytes32Hex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly extraData: BytesHex;
+}> {
   const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+  const { orderedHandles } = payload;
 
+  // Option B: read cleartexts from CleartextFHEVMExecutor.plaintexts and rebuild
+  // the public-decrypt result off-chain instead of reading the CleartextKMSVerifier
+  // view. ACL `isAllowedForDecryption` gating is enforced by the caller
+  // (publicDecrypt step 4, checkAllowedForDecryption).
+  const trustedClient = getTrustedClient(relayerClient);
+  const cleartexts = await readPlaintexts(relayerClient, trustedClient, orderedHandles);
+
+  const orderedAbiEncodedClearValues = encodeTypedCleartexts(cleartextEthereumModule, orderedHandles, cleartexts);
+
+  // The caller passes the requested extraData (= current KmsSignersContext
+  // extraData). Reuse it verbatim so the returned extraData reconciles exactly
+  // (publicDecrypt step 6) and the signed digest matches the verifier's.
+  const extraData = payload.extraData;
+
+  ////////////////////////////////////////////////////////////////////////////
+  // Warning!!!! Do not sign over '0x00' — only '0x' is permitted (matches
+  // verifyKmsPublicDecryptEip712 / createPublicDecryptionProof).
+  ////////////////////////////////////////////////////////////////////////////
+  const signedExtraData: BytesHex = extraData === ('0x00' as BytesHex) ? ('0x' as BytesHex) : extraData;
+
+  // A 'PublicDecryptVerification' domain uses the gateway chainId.
+  const domain = createKmsEip712Domain({
+    chainId: relayerClient.chain.fhevm.gateway.id,
+    verifyingContractAddressDecryption: relayerClient.chain.fhevm.gateway.contracts.decryption.address,
+  });
+
+  const currentKmsSignersContext: KmsSignersContext = await readCurrentKmsSignersContext(relayerClient, {
+    kmsVerifierAddress: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
+    protocolConfigAddress: relayerClient.chain.fhevm.contracts.protocolConfig?.address as
+      | ChecksummedAddress
+      | undefined,
+  });
+
+  const digest: Bytes32Hex = cleartextEthereumModule.hashTypedData({
+    domain,
+    types: kmsPublicDecryptEip712Types,
+    primaryType: 'PublicDecryptVerification',
+    message: {
+      ctHandles: orderedHandles.map((h) => h.bytes32Hex),
+      decryptedResult: orderedAbiEncodedClearValues,
+      extraData: signedExtraData,
+    },
+  });
+
+  return {
+    orderedAbiEncodedClearValues,
+    digest,
+    signersAddress: currentKmsSignersContext.signers,
+    extraData,
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// runPublicDecryptOnChain
+////////////////////////////////////////////////////////////////////////////////
+
+async function runPublicDecryptOnChain(
+  relayerClient: RelayerClientWithRuntime,
+  payload: FetchPublicDecryptParameters['payload'],
+): Promise<{
+  readonly orderedAbiEncodedClearValues: BytesHex;
+  readonly digest: Bytes32Hex;
+  readonly signersAddress: readonly ChecksummedAddress[];
+  readonly extraData: BytesHex;
+}> {
   const trustedClient = getTrustedClient(relayerClient);
   const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
     abi: publicDecryptAbi,
     address: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
-    args: [parameters.payload.orderedHandles.map((h) => h.bytes32Hex)],
+    args: [payload.orderedHandles.map((h) => h.bytes32Hex)],
     functionName: publicDecryptAbi[0].name,
   })) as unknown[];
 
+  const orderedAbiEncodedClearValues = res[0] as BytesHex;
   const digest = res[1] as Bytes32Hex;
   const signersAddress = res[2] as readonly ChecksummedAddress[];
+  const extraData = res[4] as BytesHex;
+
+  return {
+    orderedAbiEncodedClearValues,
+    digest,
+    signersAddress,
+    extraData,
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function fetchPublicDecrypt(
+  relayerClient: RelayerClientWithRuntime,
+  parameters: FetchPublicDecryptParameters,
+): Promise<FetchPublicDecryptReturnType> {
+  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
+
+  const offChain = await isForgeFhevmV1(relayerClient);
+
+  let res;
+  if (offChain) {
+    res = await runPublicDecryptOffChain(relayerClient, parameters.payload);
+  } else {
+    res = await runPublicDecryptOnChain(relayerClient, parameters.payload);
+  }
+
+  const digest = res.digest;
+  const signersAddress = res.signersAddress;
   const signers = getKmsSignersPrivateKeyMap(relayerClient);
 
   const kmsPublicDecryptEip712Signatures: Bytes65Hex[] = [];
@@ -60,8 +166,8 @@ export async function fetchPublicDecrypt(
   }
 
   return {
-    orderedAbiEncodedClearValues: res[0] as BytesHex,
+    orderedAbiEncodedClearValues: res.orderedAbiEncodedClearValues,
     kmsPublicDecryptEip712Signatures,
-    extraData: res[4] as BytesHex,
+    extraData: res.extraData,
   };
 }

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

@@ -1,141 +1,33 @@
-import type { BytesHex, ChecksummedAddress } from '../../../types/primitives.js';
-import type { FetchUserDecryptResultItem } from '../../../types/relayer.js';
-import type { CleartextEthereumModule } from '../../ethereum/types-ct.js';
-import type { FetchUserDecryptParametersV1, FetchUserDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
-import { remove0x } from '../../../base/string.js';
-import { asUint32BigInt, tryParseUintBigIntString, randomUniqueUints } from '../../../base/uint.js';
-import { getTrustedClient } from '../../../runtime/CoreFhevm-p.js';
-import { userDecryptResultToKmsSigncryptedShares } from '../utils.js';
-import { getKmsSignersPrivateKeyMap } from './signers.js';
-
-////////////////////////////////////////////////////////////////////////////////
-
-const userDecryptAbi = [
-  {
-    type: 'function',
-    name: 'userDecrypt',
-    inputs: [
-      {
-        name: 'pairs',
-        type: 'tuple[]',
-        internalType: 'struct HandleContractPair[]',
-        components: [
-          { name: 'handle', type: 'bytes32', internalType: 'bytes32' },
-          {
-            name: 'contractAddress',
-            type: 'address',
-            internalType: 'address',
-          },
-        ],
-      },
-      { name: 'userAddress', type: 'address', internalType: 'address' },
-      { name: 'publicKey', type: 'bytes', internalType: 'bytes' },
-      {
-        name: 'contractAddresses',
-        type: 'address[]',
-        internalType: 'address[]',
-      },
-      {
-        name: 'startTimestamp',
-        type: 'uint256',
-        internalType: 'uint256',
-      },
-      {
-        name: 'durationDays',
-        type: 'uint256',
-        internalType: 'uint256',
-      },
-      { name: 'userSignature', type: 'bytes', internalType: 'bytes' },
-    ],
-    outputs: [
-      { name: 'payload', type: 'bytes', internalType: 'bytes' },
-      { name: 'signers', type: 'address[]', internalType: 'address[]' },
-      { name: 'threshold', type: 'uint256', internalType: 'uint256' },
-      { name: 'extraData', type: 'bytes', internalType: 'bytes' },
-    ],
-    stateMutability: 'view',
-  },
-] as const;
-
-////////////////////////////////////////////////////////////////////////////////
+import type {
+  FetchUserDecryptParameters,
+  FetchUserDecryptParametersV1,
+  FetchUserDecryptParametersV2,
+  FetchUserDecryptReturnType,
+  RelayerClientWithRuntime,
+} from '../types.js';
+import { getResolvedProtocolVersion } from '../../../runtime/CoreFhevm-p.js';
+import { isSemverStrictlyBefore } from '../../../base/semver.js';
+import { fetchUserDecryptV1 } from './fetchUserDecryptV1.js';
+import { fetchUserDecryptV2 } from './fetchUserDecryptV2.js';
+
+//////////////////////////////////////////////////////////////////////////////
+// fetchUserDecrypt
+//////////////////////////////////////////////////////////////////////////////
 
 export async function fetchUserDecrypt(
   relayerClient: RelayerClientWithRuntime,
-  parameters: FetchUserDecryptParametersV1,
+  parameters: FetchUserDecryptParameters,
 ): Promise<FetchUserDecryptReturnType> {
-  const cleartextEthereumModule = relayerClient.runtime.ethereum as CleartextEthereumModule;
-  const { payload } = parameters;
-  const pairs = payload.handleContractPairs;
-  const contractAddresses = payload.kmsDecryptEip712Message.contractAddresses;
-
-  const authCount = contractAddresses.length;
-  for (const { contractAddress: c } of pairs) {
-    let authorized: boolean = false;
-    for (let i = 0; i < authCount; ++i) {
-      if (contractAddresses[i] == c) {
-        authorized = true;
-        break;
-      }
-    }
-    if (!authorized) {
-      throw new Error(`ContractAddressNotAuthorized: ${c} is not in the EIP-712 authorized contractAddresses list.`);
-    }
+  const protocolVersion = getResolvedProtocolVersion(relayerClient);
+  if (protocolVersion === undefined) {
+    throw new Error(
+      'Unable to resolve protocol version from context, ensure proper initialization of the FhevmRuntime and FhevmChain.',
+    );
   }
 
-  const { kmsDecryptEip712Message, kmsDecryptEip712Signer, kmsDecryptEip712Signature } = payload;
-  const trustedClient = getTrustedClient(relayerClient);
-  const res = (await relayerClient.runtime.ethereum.readContract(trustedClient, {
-    abi: userDecryptAbi,
-    address: relayerClient.chain.fhevm.contracts.kmsVerifier.address as ChecksummedAddress,
-    args: [
-      pairs.map((p) => ({
-        handle: p.handle.bytes32Hex,
-        contractAddress: p.contractAddress,
-      })),
-      kmsDecryptEip712Signer,
-      kmsDecryptEip712Message.publicKey,
-      kmsDecryptEip712Message.contractAddresses,
-      _parseUintBigIntString('kmsDecryptEip712Message.startTimestamp', kmsDecryptEip712Message.startTimestamp),
-      _parseUintBigIntString('kmsDecryptEip712Message.durationDays', kmsDecryptEip712Message.durationDays),
-      kmsDecryptEip712Signature,
-    ],
-    functionName: userDecryptAbi[0].name,
-  })) as unknown[];
-
-  const commonKmsSigncryptedSharePayload = res[0] as BytesHex;
-  const commonKmsSigncryptedSharePayloadNo0x = remove0x(commonKmsSigncryptedSharePayload);
-  const signersAddress = res[1] as readonly ChecksummedAddress[];
-  const threshold = asUint32BigInt(res[2]);
-  const extraData = res[3] as BytesHex;
-
-  const signers = getKmsSignersPrivateKeyMap(relayerClient);
-
-  const randomSignersAddress = randomUniqueUints(signersAddress.length, Number(threshold)).map(
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    (i) => signersAddress[i]!,
-  );
-
-  const result: FetchUserDecryptResultItem[] = [];
-
-  for (const signerAddress of randomSignersAddress) {
-    const privateKey = signers.get(signerAddress);
-    if (privateKey === undefined) {
-      throw new Error(`Unable to find KMS signer for address ${signerAddress}`);
-    }
-
-    const signature = await cleartextEthereumModule.sign({ hash: commonKmsSigncryptedSharePayload, privateKey });
-    result.push({ signature: remove0x(signature), payload: commonKmsSigncryptedSharePayloadNo0x, extraData });
+  if (isSemverStrictlyBefore(protocolVersion.version, '0.14.0')) {
+    return await fetchUserDecryptV1(relayerClient, parameters as FetchUserDecryptParametersV1);
   }
 
-  return userDecryptResultToKmsSigncryptedShares(result);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-function _parseUintBigIntString(label: string, value: string): bigint {
-  const bn = tryParseUintBigIntString(value);
-  if (bn === undefined) {
-    throw new Error(`${label} is not a valid uint string, got ${JSON.stringify(value)}`);
-  }
-  return bn;
+  return await fetchUserDecryptV2(relayerClient, parameters as FetchUserDecryptParametersV2);
 }