@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/actions/decrypt/decryptValues.ts

@@ -0,0 +1,66 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { TypedValue } from '../../types/primitives.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
+import type {
+  SignedDelegatedDecryptionPermit,
+  SignedSelfDecryptionPermit,
+} from '../../types/signedDecryptionPermit.js';
+import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
+import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import { decryptValuesFromPairs as decryptValuesFromPairs_ } from '../../kms/decryptValuesFromPairs.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+import { toFhevmHandle } from '../../handle/FhevmHandle.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type DecryptValuesParametersBase = {
+  readonly encryptedValues: readonly EncryptedValueLike[];
+  readonly contractAddress: string;
+  readonly transportKeypair: TransportKeypair;
+};
+
+export type DecryptSelfValuesParameters = DecryptValuesParametersBase & {
+  readonly signedPermit: SignedSelfDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | undefined;
+};
+
+export type DecryptDelegatedValuesParameters = DecryptValuesParametersBase & {
+  readonly signedPermit: SignedDelegatedDecryptionPermit;
+  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+};
+
+export type DecryptValuesReturnType = readonly TypedValue[];
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function decryptValues(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptSelfValuesParameters,
+): Promise<DecryptValuesReturnType>;
+
+export async function decryptValues(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptDelegatedValuesParameters,
+): Promise<DecryptValuesReturnType>;
+
+export async function decryptValues(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptSelfValuesParameters | DecryptDelegatedValuesParameters,
+): Promise<DecryptValuesReturnType> {
+  const { encryptedValues, contractAddress, ...rest } = parameters;
+
+  assertIsAddress(contractAddress, {});
+  const sanitizedContractAddress = addressToChecksummedAddress(contractAddress);
+
+  const sanitizedPairs = encryptedValues.map((ev) => {
+    return {
+      handle: toFhevmHandle(ev),
+      contractAddress: sanitizedContractAddress,
+    };
+  });
+
+  return decryptValuesFromPairs_(fhevm, { ...rest, pairs: sanitizedPairs });
+}

package/core/actions/decrypt/decryptValuesFromPairs.ts

@@ -0,0 +1,66 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { TypedValue } from '../../types/primitives.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { RelayerDelegatedUserDecryptOptions, RelayerUserDecryptOptions } from '../../types/relayer.js';
+import type {
+  SignedDelegatedDecryptionPermit,
+  SignedSelfDecryptionPermit,
+} from '../../types/signedDecryptionPermit.js';
+import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
+import type { TransportKeypair } from '../../kms/TransportKeypair-p.js';
+import type { EncryptedValueLike } from '../../types/encryptedTypes.js';
+import { decryptValuesFromPairs as decryptValuesFromPairs_ } from '../../kms/decryptValuesFromPairs.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+import { toFhevmHandle } from '../../handle/FhevmHandle.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+type DecryptValuesFromPairsParametersBase = {
+  readonly pairs: ReadonlyArray<{
+    readonly encryptedValue: EncryptedValueLike;
+    readonly contractAddress: string;
+  }>;
+  readonly transportKeypair: TransportKeypair;
+};
+
+export type DecryptSelfValuesFromPairsParameters = DecryptValuesFromPairsParametersBase & {
+  readonly signedPermit: SignedSelfDecryptionPermit;
+  readonly options?: RelayerUserDecryptOptions | undefined;
+};
+
+export type DecryptDelegatedValuesFromPairsParameters = DecryptValuesFromPairsParametersBase & {
+  readonly signedPermit: SignedDelegatedDecryptionPermit;
+  readonly options?: RelayerDelegatedUserDecryptOptions | undefined;
+};
+
+export type DecryptValuesFromPairsReturnType = readonly TypedValue[];
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function decryptValuesFromPairs(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptSelfValuesFromPairsParameters,
+): Promise<DecryptValuesFromPairsReturnType>;
+
+export async function decryptValuesFromPairs(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptDelegatedValuesFromPairsParameters,
+): Promise<DecryptValuesFromPairsReturnType>;
+
+export async function decryptValuesFromPairs(
+  fhevm: Fhevm<FhevmChain, WithDecrypt>,
+  parameters: DecryptSelfValuesFromPairsParameters | DecryptDelegatedValuesFromPairsParameters,
+): Promise<DecryptValuesFromPairsReturnType> {
+  const { pairs, ...rest } = parameters;
+
+  const sanitizedPairs = pairs.map((pair) => {
+    assertIsAddress(pair.contractAddress, {});
+    return {
+      handle: toFhevmHandle(pair.encryptedValue),
+      contractAddress: addressToChecksummedAddress(pair.contractAddress),
+    };
+  });
+
+  return decryptValuesFromPairs_(fhevm, { ...rest, pairs: sanitizedPairs });
+}

package/core/actions/decrypt/generateTransportKeypair.ts

@@ -0,0 +1,19 @@
+import type { Fhevm, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { WithDecrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import {
+  generateTransportKeypair as generateTransportKeypair_,
+  type TransportKeypair,
+} from '../../kms/TransportKeypair-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type GenerateTransportKeypairReturnType = TransportKeypair;
+
+export async function generateTransportKeypair(
+  fhevm: Fhevm<FhevmChain | undefined, WithDecrypt, OptionalNativeClient>,
+): Promise<GenerateTransportKeypairReturnType> {
+  return await generateTransportKeypair_(fhevm);
+}
+
+////////////////////////////////////////////////////////////////////////////////

package/core/actions/decrypt/index.ts

@@ -0,0 +1,58 @@
+export type { RelayerUserDecryptOptions, RelayerUserDecryptProgressArgs } from '../../types/relayer.js';
+export type {
+  RelayerDelegatedUserDecryptOptions,
+  RelayerDelegatedUserDecryptProgressArgs,
+} from '../../types/relayer.js';
+
+export {
+  type GenerateTransportKeypairReturnType as GenerateE2eTransportKeypairReturnType,
+  generateTransportKeypair as generateE2eTransportKeypair,
+} from './generateTransportKeypair.js';
+
+export {
+  type DecryptSelfValuesFromPairsParameters,
+  type DecryptDelegatedValuesFromPairsParameters,
+  type DecryptValuesFromPairsReturnType,
+  decryptValuesFromPairs,
+} from './decryptValuesFromPairs.js';
+
+export {
+  type DecryptSelfValueParameters,
+  type DecryptDelegatedValueParameters,
+  type DecryptValueReturnType,
+  decryptValue,
+} from './decryptValue.js';
+
+export {
+  type DecryptSelfValuesParameters,
+  type DecryptDelegatedValuesParameters,
+  type DecryptValuesReturnType,
+  decryptValues,
+} from './decryptValues.js';
+
+export {
+  type DecryptKmsSignedcryptedSharesParameters,
+  type DecryptKmsSignedcryptedSharesReturnType,
+  decryptKmsSignedcryptedShares,
+} from './decryptKmsSignedcryptedShares.js';
+
+export {
+  type CanDecryptValuesFromPairsWithUserAddressParameters,
+  type CanDecryptValuesFromPairsWithPermitParameters,
+  type CanDecryptValuesFromPairsReturnType,
+  canDecryptValuesFromPairs,
+} from './canDecryptValuesFromPairs.js';
+
+export {
+  type CanDecryptValuesWithUserAddressParameters,
+  type CanDecryptValuesWithPermitParameters,
+  type CanDecryptValuesReturnType,
+  canDecryptValues,
+} from './canDecryptValues.js';
+
+export {
+  type CanDecryptValueWithUserAddressParameters,
+  type CanDecryptValueWithPermitParameters,
+  type CanDecryptValueReturnType,
+  canDecryptValue,
+} from './canDecryptValue.js';

package/core/actions/decrypt/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../../_types/core/actions/decrypt/index.d.ts",
+  "module": "../../../_esm/core/actions/decrypt/index.js",
+  "main": "../../../_cjs/core/actions/decrypt/index.js"
+}

package/core/actions/encrypt/encryptValue.ts

@@ -0,0 +1,52 @@
+import type { RelayerInputProofOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { BytesHex, TypedValueLike } from '../../types/primitives.js';
+import type { EncryptedValue } from '../../types/encryptedTypes.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+import { toArray } from '../../base/object.js';
+import { createTypedValue } from '../../base/typedValue.js';
+import { encrypt as encrypt_ } from '../../coprocessor/encrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type EncryptValueParameters = {
+  readonly value: TypedValueLike;
+  readonly contractAddress: string;
+  readonly userAddress: string;
+  readonly options?: RelayerInputProofOptions | undefined;
+};
+
+export type EncryptValueReturnType = {
+  readonly encryptedValue: EncryptedValue;
+  readonly inputProof: BytesHex;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function encryptValue(
+  fhevm: Fhevm<FhevmChain, WithEncrypt>,
+  parameters: EncryptValueParameters,
+): Promise<EncryptValueReturnType> {
+  const { contractAddress, userAddress, options } = parameters;
+
+  // Validates `value`
+  const values = toArray(parameters.value).map(createTypedValue);
+
+  assertIsAddress(contractAddress, {});
+  assertIsAddress(userAddress, {});
+
+  const result = await encrypt_(fhevm, {
+    contractAddress: addressToChecksummedAddress(contractAddress),
+    userAddress: addressToChecksummedAddress(userAddress),
+    values,
+    options,
+  });
+
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    encryptedValue: result.inputHandles[0]!.bytes32Hex as unknown as EncryptedValue,
+    inputProof: result.inputProof,
+  };
+}

package/core/actions/encrypt/encryptValues.ts

@@ -0,0 +1,51 @@
+import type { RelayerInputProofOptions } from '../../types/relayer.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { BytesHex, TypedValueLike } from '../../types/primitives.js';
+import type { EncryptedValue } from '../../types/encryptedTypes.js';
+import { addressToChecksummedAddress, assertIsAddress } from '../../base/address.js';
+import { createTypedValue } from '../../base/typedValue.js';
+import { encrypt as encrypt_ } from '../../coprocessor/encrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type EncryptValuesParameters = {
+  readonly values: readonly TypedValueLike[];
+  readonly contractAddress: string;
+  readonly userAddress: string;
+  readonly options?: RelayerInputProofOptions | undefined;
+};
+
+export type EncryptValuesReturnType = {
+  readonly encryptedValues: readonly EncryptedValue[];
+  readonly inputProof: BytesHex;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function encryptValues(
+  fhevm: Fhevm<FhevmChain, WithEncrypt>,
+  parameters: EncryptValuesParameters,
+): Promise<EncryptValuesReturnType> {
+  const { contractAddress, userAddress, options } = parameters;
+  // Validates `values`
+  const values = parameters.values.map(createTypedValue);
+
+  assertIsAddress(contractAddress, {});
+  assertIsAddress(userAddress, {});
+
+  const result = await encrypt_(fhevm, {
+    contractAddress: addressToChecksummedAddress(contractAddress),
+    userAddress: addressToChecksummedAddress(userAddress),
+    values,
+    options,
+  });
+
+  return {
+    encryptedValues: result.inputHandles.map(
+      (encryptedValue) => encryptedValue.bytes32Hex as unknown as EncryptedValue,
+    ),
+    inputProof: result.inputProof,
+  };
+}

package/core/actions/encrypt/generateZkProof.ts

@@ -0,0 +1,34 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { TypedValueLike } from '../../types/primitives.js';
+import type { ZkProof } from '../../types/zkProof-p.js';
+import { createTypedValue } from '../../base/typedValue.js';
+import { createZkProofBuilder } from '../../coprocessor/ZkProofBuilder-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type GenerateZkProofParameters = {
+  readonly contractAddress: string;
+  readonly userAddress: string;
+  readonly values: readonly TypedValueLike[];
+};
+
+export type GenerateZkProofReturnType = ZkProof;
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function generateZkProof(
+  fhevm: Fhevm<FhevmChain, WithEncrypt>,
+  parameters: GenerateZkProofParameters,
+): Promise<GenerateZkProofReturnType> {
+  const { values, contractAddress, userAddress } = parameters;
+  const builder = createZkProofBuilder();
+  for (const value of values) {
+    builder.addTypedValue(createTypedValue(value));
+  }
+  return builder.build(fhevm, {
+    contractAddress,
+    userAddress,
+  });
+}

package/core/actions/encrypt/index.ts

@@ -0,0 +1,12 @@
+export type { RelayerInputProofOptions, RelayerInputProofProgressArgs } from '../../types/relayer.js';
+
+export type {
+  RelayerDelegatedUserDecryptOptions,
+  RelayerDelegatedUserDecryptProgressArgs,
+} from '../../types/relayer.js';
+
+export { type GenerateZkProofParameters, type GenerateZkProofReturnType, generateZkProof } from './generateZkProof.js';
+
+export { type EncryptValueParameters, type EncryptValueReturnType, encryptValue } from './encryptValue.js';
+
+export { type EncryptValuesParameters, type EncryptValuesReturnType, encryptValues } from './encryptValues.js';

package/core/actions/encrypt/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../../_types/core/actions/encrypt/index.d.ts",
+  "module": "../../../_esm/core/actions/encrypt/index.js",
+  "main": "../../../_cjs/core/actions/encrypt/index.js"
+}

package/core/actions/host/getUserDecryptionDelegationExpirationDate.ts

@@ -0,0 +1,32 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { ChecksummedAddress, Uint64BigInt } from '../../types/primitives.js';
+import { isUint64 } from '../../base/uint.js';
+import { getUserDecryptionDelegationExpirationDateAbi } from '../../host-contracts/abi-fragments/fragments.js';
+import { getTrustedClient } from '../../runtime/CoreFhevm-p.js';
+
+export type GetUserDecryptionDelegationExpirationDateParameters = {
+  readonly address: ChecksummedAddress;
+};
+
+export type GetUserDecryptionDelegationExpirationDateReturnType = Uint64BigInt;
+
+export async function getUserDecryptionDelegationExpirationDate(
+  fhevm: Fhevm,
+  parameters: GetUserDecryptionDelegationExpirationDateParameters,
+): Promise<GetUserDecryptionDelegationExpirationDateReturnType> {
+  const trustedClient = getTrustedClient(fhevm);
+  const address = parameters.address;
+
+  const res = await fhevm.runtime.ethereum.readContract(trustedClient, {
+    address: address,
+    abi: getUserDecryptionDelegationExpirationDateAbi,
+    args: [],
+    functionName: getUserDecryptionDelegationExpirationDateAbi[0].name,
+  });
+
+  if (!isUint64(res)) {
+    throw new Error(`Invalid expiration date.`);
+  }
+
+  return BigInt(res) as Uint64BigInt;
+}

package/core/actions/host/index.ts

@@ -0,0 +1,33 @@
+export {
+  type ResolveFhevmConfigParameters,
+  type ResolveFhevmConfigReturnType,
+  resolveFhevmConfig,
+} from './resolveFhevmConfig.js';
+
+export {
+  type IsAllowedForDecryptionParameters,
+  type IsAllowedForDecryptionReturnType,
+  isAllowedForDecryption,
+} from './isAllowedForDecryption.js';
+
+export { type ResolveChainIdParameters, type ResolveChainIdReturnType, resolveChainId } from './resolveChainId.js';
+
+export {
+  type ReadFhevmExecutorContractDataParameters,
+  type ReadFhevmExecutorContractDataReturnType,
+  readFhevmExecutorContractData,
+} from './readFhevmExecutorContractData.js';
+
+export {
+  type ReadKmsVerifierContractDataParameters,
+  type ReadKmsVerifierContractDataReturnType,
+  readKmsVerifierContractData,
+} from './readKmsVerifierContractData.js';
+
+export { type PersistAllowedParameters, type PersistAllowedReturnType, persistAllowed } from './persistAllowed.js';
+
+export {
+  type ReadInputVerifierContractDataParameters,
+  type ReadInputVerifierContractDataReturnType,
+  readInputVerifierContractData,
+} from './readInputVerifierContractData.js';

package/core/actions/host/isAllowedForDecryption.ts

@@ -0,0 +1,35 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { Bytes32Hex, ChecksummedAddress } from '../../types/primitives.js';
+import { isAllowedForDecryptionAbi } from '../../host-contracts/abi-fragments/fragments.js';
+import { getTrustedClient } from '../../runtime/CoreFhevm-p.js';
+
+export type IsAllowedForDecryptionParameters = {
+  readonly address: ChecksummedAddress;
+  readonly args: {
+    readonly handle: Bytes32Hex;
+  };
+};
+
+export type IsAllowedForDecryptionReturnType = boolean;
+
+// to be removed from core/actions
+export async function isAllowedForDecryption(
+  fhevm: Fhevm,
+  parameters: IsAllowedForDecryptionParameters,
+): Promise<IsAllowedForDecryptionReturnType> {
+  const trustedClient = getTrustedClient(fhevm);
+  const address = parameters.address;
+
+  const res = await fhevm.runtime.ethereum.readContract(trustedClient, {
+    address: address,
+    abi: isAllowedForDecryptionAbi,
+    args: [parameters.args.handle],
+    functionName: isAllowedForDecryptionAbi[0].name,
+  });
+
+  if (typeof res !== 'boolean') {
+    throw new Error(`Invalid isAllowedForDecryption result.`);
+  }
+
+  return res;
+}

package/core/actions/host/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../../_types/core/actions/host/index.d.ts",
+  "module": "../../../_esm/core/actions/host/index.js",
+  "main": "../../../_cjs/core/actions/host/index.js"
+}

package/core/actions/host/persistAllowed.ts

@@ -0,0 +1,35 @@
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { Bytes32Hex, ChecksummedAddress } from '../../types/primitives.js';
+import { persistAllowedAbi } from '../../host-contracts/abi-fragments/fragments.js';
+import { getTrustedClient } from '../../runtime/CoreFhevm-p.js';
+
+export type PersistAllowedParameters = {
+  readonly address: ChecksummedAddress;
+  readonly args: {
+    readonly handle: Bytes32Hex;
+    readonly account: ChecksummedAddress;
+  };
+};
+
+export type PersistAllowedReturnType = boolean;
+
+export async function persistAllowed(
+  fhevm: Fhevm,
+  parameters: PersistAllowedParameters,
+): Promise<PersistAllowedReturnType> {
+  const trustedClient = getTrustedClient(fhevm);
+  const address = parameters.address;
+
+  const res = await fhevm.runtime.ethereum.readContract(trustedClient, {
+    address: address,
+    abi: persistAllowedAbi,
+    args: [parameters.args.handle, parameters.args.account],
+    functionName: persistAllowedAbi[0].name,
+  });
+
+  if (typeof res !== 'boolean') {
+    throw new Error(`Invalid persistAllowed result.`);
+  }
+
+  return res;
+}

package/core/actions/host/readFhevmExecutorContractData.ts

@@ -0,0 +1,74 @@
+import type { HostContractVersion } from '../../types/hostContract.js';
+import type { FhevmExecutorContractData } from '../../types/coprocessor.js';
+import type { Fhevm } from '../../types/coreFhevmClient.js';
+import type { ChecksummedAddress, Uint8Number } from '../../types/primitives.js';
+import { assertIsChecksummedAddress } from '../../base/address.js';
+import { executeWithBatching } from '../../base/promise.js';
+import { isUint8 } from '../../base/uint.js';
+import { createFhevmExecutorContractData } from '../../host-contracts/FhevmExecutorContractData-p.js';
+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 { getInputVerifierAddress } from '../../host-contracts/getInputVerifierAddress-p.js';
+
+export type ReadFhevmExecutorContractDataParameters = {
+  readonly address: ChecksummedAddress;
+};
+export type ReadFhevmExecutorContractDataReturnType = FhevmExecutorContractData;
+
+export async function readFhevmExecutorContractData(
+  fhevm: Fhevm,
+  parameters: ReadFhevmExecutorContractDataParameters,
+): Promise<ReadFhevmExecutorContractDataReturnType> {
+  const fhevmExecutorContractAddress = parameters.address;
+
+  ////////////////////////////////////////////////////////////////////////////
+  //
+  // Important remark:
+  // =================
+  // Do NOTE USE `Promise.all` here!
+  // You may get a server response 500 Internal Server Error
+  // "Batch of more than 3 requests are not allowed on free tier, to use this
+  // feature register paid account at drpc.org"
+  //
+  ////////////////////////////////////////////////////////////////////////////
+
+  const rpcCalls = [
+    () => getVersion(fhevm, parameters),
+    () => getAclAddress(fhevm, parameters),
+    () => getHcuLimitAddress(fhevm, parameters),
+    () => getInputVerifierAddress(fhevm, parameters),
+    () => getHandleVersion(fhevm, parameters),
+  ];
+
+  const res = await executeWithBatching<unknown>(rpcCalls, fhevm.options.batchRpcCalls);
+
+  const contractVersion = res[0] as HostContractVersion;
+  const aclContractAddress = res[1];
+  const hcuLimitContractAddress = res[2];
+  const inputVerifierContractAddress = res[3];
+  const handleVersion = res[4];
+
+  assertIsHostContractVersionOf(contractVersion, 'FHEVMExecutor');
+
+  if (!isUint8(handleVersion)) {
+    throw new Error(`Invalid handle version.`);
+  }
+
+  assertIsChecksummedAddress(aclContractAddress, {});
+  assertIsChecksummedAddress(hcuLimitContractAddress, {});
+  assertIsChecksummedAddress(inputVerifierContractAddress, {});
+
+  const data = createFhevmExecutorContractData(new WeakRef(fhevm.runtime), {
+    version: contractVersion,
+    address: fhevmExecutorContractAddress,
+    aclContractAddress,
+    inputVerifierContractAddress,
+    hcuLimitContractAddress,
+    handleVersion: Number(handleVersion) as Uint8Number,
+  });
+
+  return data;
+}