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

package/core/actions/encrypt/generateZkProof.ts

@@ -2,8 +2,10 @@ import type { Fhevm } from '../../types/coreFhevmClient.js';
 import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
 import type { FhevmChain } from '../../types/fhevmChain.js';
 import type { ZkProof } from '../../types/zkProof-p.js';
+import type { BytesHex } from '../../types/primitives.js';
 import { createTypedValue } from '../../base/typedValue.js';
 import { createZkProofBuilder } from '../../coprocessor/ZkProofBuilder-p.js';
+import { asFhevmWithTfheVersion } from '../../runtime/CoreFhevm-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -22,12 +24,18 @@ export async function generateZkProof(
   parameters: GenerateZkProofParameters,
 ): Promise<GenerateZkProofReturnType> {
   const { values, contractAddress, userAddress } = parameters;
+  const hardCodedExtraData = '0x00' as BytesHex;
+
   const builder = createZkProofBuilder();
   for (const value of values) {
     builder.addTypedValue(createTypedValue(value));
   }
-  return builder.build(fhevm, {
+
+  const f = asFhevmWithTfheVersion(fhevm);
+
+  return builder.build(f, {
     contractAddress,
     userAddress,
+    extraData: hardCodedExtraData,
   });
 }

package/core/actions/host/readFhevmExecutorContractData.ts

@@ -10,7 +10,7 @@ import { getAclAddress } from '../../host-contracts/getAclAddress-p.js';
 import { getHandleVersion } from '../../host-contracts/getHandleVersion-p.js';
 import { getHcuLimitAddress } from '../../host-contracts/getHcuLimitAddress-p.js';
 import { assertIsHostContractVersionOf } from '../../host-contracts/HostContractVersion-p.js';
-import { getVersion } from '../../host-contracts/HostContractVersion-p.js';
+import { getHostContractVersion } from '../../host-contracts/HostContractVersion-p.js';
 import { getInputVerifierAddress } from '../../host-contracts/getInputVerifierAddress-p.js';
 
 export type ReadFhevmExecutorContractDataParameters = {
@@ -22,7 +22,7 @@ export async function readFhevmExecutorContractData(
   fhevm: Fhevm,
   parameters: ReadFhevmExecutorContractDataParameters,
 ): Promise<ReadFhevmExecutorContractDataReturnType> {
-  const fhevmExecutorContractAddress = parameters.address;
+  const fhevmExecutorAddress = parameters.address;
 
   ////////////////////////////////////////////////////////////////////////////
   //
@@ -36,11 +36,11 @@ export async function readFhevmExecutorContractData(
   ////////////////////////////////////////////////////////////////////////////
 
   const rpcCalls = [
-    () => getVersion(fhevm, parameters),
-    () => getAclAddress(fhevm, parameters),
-    () => getHcuLimitAddress(fhevm, parameters),
-    () => getInputVerifierAddress(fhevm, parameters),
-    () => getHandleVersion(fhevm, parameters),
+    () => getHostContractVersion(fhevm, parameters),
+    () => getAclAddress(fhevm, { fhevmExecutorAddress }),
+    () => getHcuLimitAddress(fhevm, { fhevmExecutorAddress }),
+    () => getInputVerifierAddress(fhevm, { fhevmExecutorAddress }),
+    () => getHandleVersion(fhevm, { fhevmExecutorAddress }),
   ];
 
   const res = await executeWithBatching<unknown>(rpcCalls, fhevm.options.batchRpcCalls);
@@ -63,7 +63,7 @@ export async function readFhevmExecutorContractData(
 
   const data = createFhevmExecutorContractData(new WeakRef(fhevm.runtime), {
     version: contractVersion,
-    address: fhevmExecutorContractAddress,
+    address: fhevmExecutorAddress,
     aclContractAddress,
     inputVerifierContractAddress,
     hcuLimitContractAddress,

package/core/actions/host/readInputVerifierContractData.ts

@@ -6,7 +6,7 @@ import type { CoprocessorSignersContext } from '../../types/coprocessorSignersCo
 import { eip712Domain, type Eip712DomainReturnType } from '../../host-contracts/eip712Domain-p.js';
 import { assertIsHostContractVersionOf } from '../../host-contracts/HostContractVersion-p.js';
 import { readCoprocessorSignersContext } from '../../host-contracts/readCoprocessorSignersContext-p.js';
-import { getVersion } from '../../host-contracts/HostContractVersion-p.js';
+import { getHostContractVersion } from '../../host-contracts/HostContractVersion-p.js';
 import { executeWithBatching } from '../../base/promise.js';
 import { assertIsCoprocessorEip712Domain } from '../../coprocessor/assertIsCoprocessorEip712Domain.js';
 import { createInputVerifierContractData } from '../../host-contracts/InputVerifierContractData-p.js';
@@ -39,7 +39,7 @@ export async function readInputVerifierContractData(
   ////////////////////////////////////////////////////////////////////////////
 
   const rpcCalls = [
-    () => getVersion(fhevm, parameters),
+    () => getHostContractVersion(fhevm, parameters),
     () => eip712Domain(fhevm, parameters),
     () => readCoprocessorSignersContext(fhevm, parameters),
   ];

package/core/actions/host/readKmsVerifierContractData.ts

@@ -9,13 +9,14 @@ import { createKmsVerifierContractData } from '../../host-contracts/KmsVerifierC
 import { assertIsKmsEip712Domain } from '../../kms/createKmsEip712Domain.js';
 import { eip712Domain } from '../../host-contracts/eip712Domain-p.js';
 import { assertIsHostContractVersionOf } from '../../host-contracts/HostContractVersion-p.js';
-import { getVersion } from '../../host-contracts/HostContractVersion-p.js';
+import { getHostContractVersion } from '../../host-contracts/HostContractVersion-p.js';
 import { readKmsSignersContext } from '../../host-contracts/readKmsSignersContext-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
 export type ReadKmsVerifierContractDataParameters = {
   readonly address: ChecksummedAddress;
+  readonly protocolConfigAddress: ChecksummedAddress | undefined;
 };
 
 export type ReadKmsVerifierContractDataReturnType = KmsVerifierContractData;
@@ -26,7 +27,8 @@ export async function readKmsVerifierContractData(
   fhevm: Fhevm,
   parameters: ReadKmsVerifierContractDataParameters,
 ): Promise<ReadKmsVerifierContractDataReturnType> {
-  const kmsVerifierContractAddress = parameters.address;
+  const kmsVerifierAddress = parameters.address;
+  const protocolConfigAddress = parameters.protocolConfigAddress;
 
   ////////////////////////////////////////////////////////////////////////////
   //
@@ -40,9 +42,9 @@ export async function readKmsVerifierContractData(
   ////////////////////////////////////////////////////////////////////////////
 
   const rpcCalls = [
-    () => getVersion(fhevm, parameters),
+    () => getHostContractVersion(fhevm, parameters),
     () => eip712Domain(fhevm, parameters),
-    () => readKmsSignersContext(fhevm, parameters),
+    () => readKmsSignersContext(fhevm, { kmsVerifierAddress, protocolConfigAddress }),
   ];
 
   const res = await executeWithBatching<unknown>(rpcCalls, fhevm.options.batchRpcCalls);
@@ -59,13 +61,13 @@ export async function readKmsVerifierContractData(
     throw new Error(`Invalid KMSVerifier EIP-712 domain.`, { cause: e });
   }
 
-  if (eip712DomainRes.verifyingContract.toLowerCase() === kmsVerifierContractAddress.toLowerCase()) {
+  if (eip712DomainRes.verifyingContract.toLowerCase() === kmsVerifierAddress.toLowerCase()) {
     throw new Error(`Invalid KMSVerifier EIP-712 domain. Unexpected verifyingContract.`);
   }
 
   const data = createKmsVerifierContractData(new WeakRef(fhevm.runtime), {
     version: contractVersion,
-    address: kmsVerifierContractAddress,
+    address: kmsVerifierAddress,
     eip712Domain: eip712DomainRes,
     kmsSignerThreshold: kmsSignersContext.threshold,
     kmsSigners: kmsSignersContext.signers,

package/core/actions/host/resolveFhevmConfig.ts

@@ -29,6 +29,7 @@ export type ResolveFhevmConfigParameters = {
       readonly hcuLimit?: OptionalChainContract | undefined;
       readonly inputVerifier?: OptionalChainContract | undefined;
       readonly kmsVerifier: { readonly address: string };
+      readonly protocolConfig: OptionalChainContract | undefined;
     };
     readonly gateway?:
       | {
@@ -52,6 +53,7 @@ export type ResolveFhevmConfigReturnType = {
   readonly fhevmExecutor: FhevmExecutorContractData;
   readonly inputVerifier: InputVerifierContractData;
   readonly kmsVerifier: KmsVerifierContractData;
+  readonly protocolConfig: ChecksummedAddress | undefined;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -64,6 +66,11 @@ export async function resolveFhevmConfig(
   const kmsVerifierAddress = parameters.fhevm.contracts.kmsVerifier.address;
   assertIsAddress(kmsVerifierAddress, {});
 
+  const protocolConfigAddress = parameters.fhevm.contracts.protocolConfig?.address;
+  if (protocolConfigAddress !== undefined) {
+    assertIsAddress(protocolConfigAddress, {});
+  }
+
   const id: Uint64BigInt = await resolveChainId(fhevm, parameters);
   const fhevmExecutorData = await _resolveFhevmExecutor(fhevm, parameters.fhevm.contracts);
 
@@ -86,6 +93,7 @@ export async function resolveFhevmConfig(
     () =>
       readKmsVerifierContractData(fhevm, {
         address: addressToChecksummedAddress(kmsVerifierAddress),
+        protocolConfigAddress: protocolConfigAddress ? addressToChecksummedAddress(protocolConfigAddress) : undefined,
       }),
   ];
 
@@ -120,6 +128,7 @@ export async function resolveFhevmConfig(
     fhevmExecutor: fhevmExecutorData,
     inputVerifier: inputVerifierData,
     kmsVerifier: kmsVerifierData,
+    protocolConfig: protocolConfigAddress ? addressToChecksummedAddress(protocolConfigAddress) : undefined,
   };
 
   return Object.freeze(returnValue);
@@ -150,7 +159,7 @@ async function _resolveFhevmExecutor(
 
   if (acl !== undefined) {
     const aclFhevmExecutor = await getFhevmExecutorAddress(fhevm, {
-      address: addressToChecksummedAddress(acl),
+      aclAddress: addressToChecksummedAddress(acl),
     });
     if (fhevmExecutor !== undefined) {
       if (aclFhevmExecutor !== fhevmExecutor) {

package/core/base/object.ts

@@ -16,6 +16,44 @@ export function simpleDeepFreeze<T extends object>(obj: T): Readonly<T> {
   return obj;
 }
 
+/**
+ * Recursively compares two JSON-like values.
+ *
+ * Arrays are order-sensitive. Objects must have the same own enumerable string keys, but key
+ * insertion order does not matter.
+ */
+export function isDeepEqual(value: unknown, expected: unknown): boolean {
+  if (value === expected) {
+    return true;
+  }
+
+  if (Array.isArray(expected)) {
+    return (
+      Array.isArray(value) &&
+      value.length === expected.length &&
+      expected.every((expectedItem, index) => isDeepEqual(value[index], expectedItem))
+    );
+  }
+
+  if (expected === null || typeof expected !== 'object') {
+    return value === expected;
+  }
+
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  const record = value as Record<string, unknown>;
+  const expectedRecord = expected as Record<string, unknown>;
+  const keys = Object.keys(record);
+  const expectedKeys = Object.keys(expectedRecord);
+
+  return (
+    keys.length === expectedKeys.length &&
+    expectedKeys.every((key) => Object.hasOwn(record, key) && isDeepEqual(record[key], expectedRecord[key]))
+  );
+}
+
 /**
  * Defines a non-enumerable, non-writable, non-configurable property on the target object.
  * The property is hidden from `Object.keys()` / `Object.entries()` and cannot be

package/core/base/semver.ts

@@ -0,0 +1,231 @@
+import type { UintNumber } from '../types/primitives.js';
+import { assertIsUintNumber } from './uint.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type Semver = {
+  readonly version: string;
+  readonly major: UintNumber;
+  readonly minor: UintNumber;
+  readonly patch: UintNumber;
+  readonly prerelease?: readonly string[] | undefined;
+  readonly build?: readonly string[] | undefined;
+};
+
+export type SemverComparator = 'lt' | 'le' | 'gt' | 'ge' | 'eq';
+
+export type SemverRange = {
+  readonly version: string;
+  readonly comparator: SemverComparator;
+};
+
+export type SemverIntervalLowerBound = {
+  readonly version: string;
+  readonly comparator: 'gt' | 'ge';
+};
+
+export type SemverIntervalUpperBound = {
+  readonly version: string;
+  readonly comparator: 'lt' | 'le';
+};
+
+export type SemverInterval = {
+  readonly lowerBound?: SemverIntervalLowerBound | undefined;
+  readonly upperBound?: SemverIntervalUpperBound | undefined;
+};
+
+const SEMVER_REGEX =
+  /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+
+export function parseSemver(version: string): Semver {
+  const match = SEMVER_REGEX.exec(version);
+  if (match === null) {
+    throw new Error(`Invalid SemVer version: "${version}".`);
+  }
+
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+
+  assertIsUintNumber(major, {});
+  assertIsUintNumber(minor, {});
+  assertIsUintNumber(patch, {});
+
+  return Object.freeze({
+    version,
+    major,
+    minor,
+    patch,
+    prerelease: match[4]?.split('.'),
+    build: match[5]?.split('.'),
+  });
+}
+
+export function isSemverStrictlyBefore(version: string, before: string): boolean {
+  return compareSemver(version, before) < 0;
+}
+
+export function isSemverInRange(version: string, range: SemverRange): boolean {
+  const comparison = compareSemver(version, range.version);
+
+  switch (range.comparator) {
+    case 'lt':
+      return comparison < 0;
+    case 'le':
+      return comparison <= 0;
+    case 'gt':
+      return comparison > 0;
+    case 'ge':
+      return comparison >= 0;
+    case 'eq':
+      return comparison === 0;
+    default: {
+      const exhaustiveCheck: never = range.comparator;
+      throw new Error(`Unsupported SemVer comparator "${exhaustiveCheck}".`);
+    }
+  }
+}
+
+export function isSemverInInterval(version: string, interval: SemverInterval): boolean {
+  if (interval.lowerBound !== undefined && !isSemverInRange(version, interval.lowerBound)) {
+    return false;
+  }
+  if (interval.upperBound !== undefined && !isSemverInRange(version, interval.upperBound)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Returns whether a SemVer comparator constraint implies a SemVer range.
+ *
+ * Mathematically: for every SemVer `x`, if `x comparator version` is true,
+ * then `x range.comparator range.version` is also true.
+ */
+export function semverComparatorImpliesRange(
+  version: string,
+  comparator: SemverComparator,
+  range: SemverRange,
+): boolean {
+  if (comparator === 'eq') {
+    return isSemverInRange(version, range);
+  }
+
+  const comparison = compareSemver(version, range.version);
+
+  switch (comparator) {
+    case 'lt':
+      return range.comparator === 'lt' || range.comparator === 'le' ? comparison <= 0 : false;
+    case 'le':
+      if (range.comparator === 'lt') {
+        return comparison < 0;
+      }
+      return range.comparator === 'le' ? comparison <= 0 : false;
+    case 'gt':
+      return range.comparator === 'gt' || range.comparator === 'ge' ? comparison >= 0 : false;
+    case 'ge':
+      if (range.comparator === 'gt') {
+        return comparison > 0;
+      }
+      return range.comparator === 'ge' ? comparison >= 0 : false;
+    default: {
+      const exhaustiveCheck: never = comparator;
+      throw new Error(`Unsupported SemVer comparator "${exhaustiveCheck}".`);
+    }
+  }
+}
+
+export function compareSemver(a: string, b: string): -1 | 0 | 1 {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+
+  const releaseComparison = _compareNumbers(
+    [left.major, left.minor, left.patch],
+    [right.major, right.minor, right.patch],
+  );
+  if (releaseComparison !== 0) {
+    return releaseComparison;
+  }
+
+  return _comparePrerelease(left.prerelease, right.prerelease);
+}
+
+function _compareNumbers(a: readonly number[], b: readonly number[]): -1 | 0 | 1 {
+  for (let i = 0; i < a.length; ++i) {
+    const left = a[i];
+    const right = b[i];
+    if (left === undefined) {
+      return right === undefined ? 0 : -1;
+    }
+    if (right === undefined) {
+      return 1;
+    }
+    if (left < right) {
+      return -1;
+    }
+    if (left > right) {
+      return 1;
+    }
+  }
+  return a.length === b.length ? 0 : -1;
+}
+
+function _comparePrerelease(a: readonly string[] | undefined, b: readonly string[] | undefined): -1 | 0 | 1 {
+  if (a === undefined && b === undefined) {
+    return 0;
+  }
+  if (a === undefined) {
+    return 1;
+  }
+  if (b === undefined) {
+    return -1;
+  }
+
+  const length = Math.max(a.length, b.length);
+  for (let i = 0; i < length; ++i) {
+    const left = a[i];
+    const right = b[i];
+
+    if (left === undefined) {
+      return -1;
+    }
+    if (right === undefined) {
+      return 1;
+    }
+
+    const comparison = _comparePrereleaseIdentifier(left, right);
+    if (comparison !== 0) {
+      return comparison;
+    }
+  }
+
+  return 0;
+}
+
+function _comparePrereleaseIdentifier(a: string, b: string): -1 | 0 | 1 {
+  const aIsNumeric = _isNumericIdentifier(a);
+  const bIsNumeric = _isNumericIdentifier(b);
+
+  if (aIsNumeric && bIsNumeric) {
+    return _compareNumbers([Number(a)], [Number(b)]);
+  }
+
+  if (aIsNumeric) {
+    return -1;
+  }
+  if (bIsNumeric) {
+    return 1;
+  }
+
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+}
+
+function _isNumericIdentifier(value: string): boolean {
+  return /^(0|[1-9]\d*)$/.test(value);
+}

package/core/base/uint.ts

@@ -116,6 +116,13 @@ export function isUintBigInt(value: unknown, max?: bigint | number): value is Ui
   return typeof value === 'bigint' && value >= 0 && (max === undefined || value <= max);
 }
 
+export function isUintString(value: unknown, max?: number | bigint): value is string {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  return tryParseUintBigIntString(value, max) !== undefined;
+}
+
 export function isUintForType(value: unknown, typeName?: UintTypeName): value is Uint {
   return isUint(value, typeName !== undefined ? MAX_UINT_FOR_TYPE[typeName] : undefined);
 }
@@ -330,6 +337,22 @@ export function assertIsUintBigInt(
   }
 }
 
+export function assertIsUintString(
+  value: unknown,
+  options: { max?: bigint | number; subject?: string } & ErrorMetadataParams,
+): asserts value is string {
+  if (!isUintString(value, options.max)) {
+    throw new InvalidTypeError(
+      {
+        subject: options.subject,
+        type: typeof value,
+        expectedType: 'uintString',
+      },
+      options,
+    );
+  }
+}
+
 export function assertIsUint8(
   value: unknown,
   options: { subject?: string } & ErrorMetadataParams,
@@ -645,7 +668,7 @@ export function assertRecordUintBigIntProperty<K extends string>(
   property: K,
   recordName: string,
   options: ErrorMetadataParams,
-): asserts record is RecordWithPropertyType<K, number> {
+): asserts record is RecordWithPropertyType<K, bigint> {
   if (typeofProperty(record, property) !== 'bigint' || !isUintBigInt((record as Record<string, unknown>)[property])) {
     throw new InvalidPropertyError(
       {
@@ -659,17 +682,23 @@ export function assertRecordUintBigIntProperty<K extends string>(
   }
 }
 
-export function parseUintBigIntString(value: string): bigint | undefined {
+/**
+ * Tries to parse a canonical unsigned decimal string as a bigint.
+ *
+ * Returns `undefined` instead of throwing when `value` is not parseable, is negative, is not in
+ * canonical decimal form, or exceeds `max`.
+ */
+export function tryParseUintBigIntString(value: string, max?: number | bigint): UintBigInt | undefined {
   let parsed: bigint;
   try {
     parsed = BigInt(value);
   } catch {
     return undefined;
   }
-  if (parsed < 0n || parsed.toString() !== value) {
+  if (parsed < 0n || parsed.toString() !== value || (max !== undefined && parsed > BigInt(max))) {
     return undefined;
   }
-  return parsed;
+  return parsed as UintBigInt;
 }
 
 /** Returns `count` unique integers drawn uniformly from [0, n-1]. Mock/debug only. */

package/core/chains/definitions/localTestnet.ts

@@ -13,6 +13,9 @@ export const localTestnet = /*#__PURE__*/ defineFhevmChain({
       kmsVerifier: {
         address: '0xa1880e99d86F081E8D3868A8C4732C8f65dfdB11',
       },
+      protocolConfig: {
+        address: '0x52054F36036811ca418be59e41Fc6DD1b9e4F4c8',
+      },
     },
     relayerUrl: 'http://localhost:9000',
     gateway: {

package/core/chains/definitions/mainnet.ts

@@ -13,6 +13,7 @@ export const mainnet = /*#__PURE__*/ defineFhevmChain({
       kmsVerifier: {
         address: '0x77627828a55156b04Ac0DC0eb30467f1a552BB03',
       },
+      protocolConfig: undefined, // To be filled
     },
     relayerUrl: 'https://relayer.mainnet.zama.org',
     gateway: {

package/core/chains/definitions/sepolia.ts

@@ -1,5 +1,4 @@
 import type { FhevmChain } from '../../types/fhevmChain.js';
-import type { ChecksummedAddress } from '../../types/primitives.js';
 import { defineFhevmChain } from '../utils.js';
 
 export const sepolia: FhevmChain = /*#__PURE__*/ defineFhevmChain({
@@ -7,24 +6,25 @@ export const sepolia: FhevmChain = /*#__PURE__*/ defineFhevmChain({
   fhevm: {
     contracts: {
       acl: {
-        address: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D' as ChecksummedAddress,
+        address: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D',
       },
       inputVerifier: {
-        address: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0' as ChecksummedAddress,
+        address: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0',
       },
       kmsVerifier: {
-        address: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A' as ChecksummedAddress,
+        address: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A',
       },
+      protocolConfig: undefined, // To be filled
     },
     relayerUrl: 'https://relayer.testnet.zama.org',
     gateway: {
       id: 10_901,
       contracts: {
         decryption: {
-          address: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478' as ChecksummedAddress,
+          address: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478',
         },
         inputVerification: {
-          address: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955' as ChecksummedAddress,
+          address: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955',
         },
       },
     },

package/core/clients/decorators/base.ts

@@ -50,6 +50,7 @@ import {
   type DecryptPublicValuesWithSignaturesParameters,
   type DecryptPublicValuesWithSignaturesReturnType,
 } from '../../actions/base/decryptPublicValuesWithSignatures.js';
+import { ensureResolvedProtocolVersion } from '../../runtime/resolveFhevmVersions-p.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -193,11 +194,17 @@ function _baseActions(fhevm: Fhevm<FhevmChain>): BaseActions {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+async function _initBase(fhevm: FhevmBase<FhevmChain>): Promise<void> {
+  await ensureResolvedProtocolVersion(fhevm);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 export function baseActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<BaseActions> {
   assertIsFhevmBaseClient(fhevm);
   return {
     actions: _baseActions(fhevm),
     runtime: fhevm.runtime,
-    // no init required, no prefetch of the FheEncryptionKey. This is the whole purpose of the fetchFheEncryptionKeyBytes action
+    init: _initBase,
   };
 }

package/core/clients/decorators/decrypt-p.ts

@@ -0,0 +1,18 @@
+import type { FhevmBase } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import { asFhevmClientWith, setResolvedTkmsVersion } from '../../runtime/CoreFhevm-p.js';
+import { ensureResolvedProtocolVersion, resolveFhevmTkmsVersion } from '../../runtime/resolveFhevmVersions-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function _initDecrypt(fhevm: FhevmBase<FhevmChain>): Promise<void> {
+  const f = asFhevmClientWith(fhevm, 'decrypt');
+
+  await ensureResolvedProtocolVersion(f);
+
+  const tkmsVersion = await resolveFhevmTkmsVersion(f);
+
+  await f.runtime.decrypt.initTkmsModule({ tkmsVersion });
+
+  setResolvedTkmsVersion(f, tkmsVersion);
+}