@fhevm/sdk 1.0.0-alpha.1 → 1.0.0-alpha.3

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

@@ -3,7 +3,7 @@ import type { FetchInputProofResult } from '../../../types/relayer.js';
 import type {
   FetchCoprocessorSignaturesParameters,
   FetchCoprocessorSignaturesReturnType,
-  RelayerClient,
+  RelayerClientWithRuntime,
 } from '../types.js';
 import { bytesToHexNo0x } from '../../../base/bytes.js';
 import { removeSuffix } from '../../../base/string.js';
@@ -15,7 +15,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 ////////////////////////////////////////////////////////////////////////////////
 
 export async function fetchCoprocessorSignatures(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchCoprocessorSignaturesParameters,
 ): Promise<FetchCoprocessorSignaturesReturnType> {
   const { options, payload } = parameters;
@@ -24,13 +24,13 @@ export async function fetchCoprocessorSignatures(
     ciphertextWithInputVerification: bytesToHexNo0x(payload.zkProof.ciphertextWithZkProof),
     contractAddress: payload.zkProof.contractAddress,
     contractChainId: uintToHex0x(payload.zkProof.chainId),
-    extraData: payload.extraData,
+    extraData: payload.zkProof.getExtraData(),
     userAddress: payload.zkProof.userAddress,
   };
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'INPUT_PROOF',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/input-proof`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/input-proof`,
     payload: inputProofPayload,
     options,
   });

package/core/modules/relayer/module/fetchDelegatedUserDecrypt.ts

@@ -3,7 +3,7 @@ import type { FetchDelegatedUserDecryptResult } from '../../../types/relayer.js'
 import type {
   FetchDelegatedUserDecryptParameters,
   FetchDelegatedUserDecryptReturnType,
-  RelayerClient,
+  RelayerClientWithRuntime,
 } from '../types.js';
 import type { KmsSigncryptedShare } from '../../../types/kms-p.js';
 import { remove0x, removeSuffix } from '../../../base/string.js';
@@ -14,7 +14,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchDelegatedUserDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchDelegatedUserDecryptParameters,
 ): Promise<FetchDelegatedUserDecryptReturnType> {
   const { options, payload } = parameters;
@@ -47,7 +47,7 @@ export async function fetchDelegatedUserDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'DELEGATED_USER_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/delegated-user-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/delegated-user-decrypt`,
     payload: relayerPayload,
     options,
   });

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

@@ -1,7 +1,7 @@
 import type { Bytes65Hex, BytesHex } from '../../../types/primitives.js';
 import type { RelayerFetchPublicDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchPublicDecryptResult } from '../../../types/relayer.js';
-import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClient } from '../types.js';
+import type { FetchPublicDecryptParameters, FetchPublicDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
 import { ensure0x, removeSuffix } from '../../../base/string.js';
 import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 
@@ -10,7 +10,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchPublicDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchPublicDecryptParameters,
 ): Promise<FetchPublicDecryptReturnType> {
   const { options, payload } = parameters;
@@ -25,7 +25,7 @@ export async function fetchPublicDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'PUBLIC_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/public-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/public-decrypt`,
     payload: p,
     options,
   });

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

@@ -2,7 +2,7 @@ import type { KmsSigncryptedShare } from '../../../types/kms-p.js';
 import type { Bytes65HexNo0x } from '../../../types/primitives.js';
 import type { FetchUserDecryptPayload } from '../../../types/relayer-p.js';
 import type { FetchUserDecryptResult } from '../../../types/relayer.js';
-import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClient } from '../types.js';
+import type { FetchUserDecryptParameters, FetchUserDecryptReturnType, RelayerClientWithRuntime } from '../types.js';
 import { remove0x, removeSuffix } from '../../../base/string.js';
 import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 
@@ -11,7 +11,7 @@ import { RelayerAsyncRequest } from './RelayerAsyncRequest.js';
 //////////////////////////////////////////////////////////////////////////////
 
 export async function fetchUserDecrypt(
-  relayerClient: RelayerClient,
+  relayerClient: RelayerClientWithRuntime,
   parameters: FetchUserDecryptParameters,
 ): Promise<FetchUserDecryptReturnType> {
   const { options, payload } = parameters;
@@ -45,7 +45,7 @@ export async function fetchUserDecrypt(
 
   const request = new RelayerAsyncRequest({
     relayerOperation: 'USER_DECRYPT',
-    url: `${removeSuffix(relayerClient.relayerUrl, '/')}/v2/user-decrypt`,
+    url: `${removeSuffix(relayerClient.chain.fhevm.relayerUrl, '/')}/v2/user-decrypt`,
     payload: relayerPayload,
     options,
   });

package/core/modules/relayer/types.ts

@@ -12,6 +12,8 @@ import type { Bytes65Hex, BytesHex, ChecksummedAddress } from '../../types/primi
 import type { Prettify } from '../../types/utils.js';
 import type { ZkProof } from '../../types/zkProof-p.js';
 import type { Handle, InputHandle } from '../../types/encryptedTypes-p.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -24,6 +26,13 @@ export type RelayerClient = {
   readonly chainId: number;
 };
 
+export type RelayerClientWithRuntime = {
+  readonly chain: FhevmChain;
+  readonly runtime: FhevmRuntime;
+  readonly client: NonNullable<object>;
+  readonly options: { readonly batchRpcCalls: boolean };
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // 1.1 fetchFheEncryptionKeySource
 ////////////////////////////////////////////////////////////////////////////////
@@ -65,7 +74,6 @@ export type FetchFheEncryptionKeyBytesModuleFunction = {
 export type FetchCoprocessorSignaturesParameters = {
   readonly payload: {
     readonly zkProof: ZkProof;
-    readonly extraData: BytesHex;
   };
   readonly options?: RelayerInputProofOptions | undefined;
 };
@@ -78,7 +86,7 @@ export type FetchCoprocessorSignaturesReturnType = {
 
 export type FetchCoprocessorSignaturesModuleFunction = {
   fetchCoprocessorSignatures(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchCoprocessorSignaturesParameters,
   ): Promise<FetchCoprocessorSignaturesReturnType>;
 };
@@ -103,7 +111,7 @@ export type FetchPublicDecryptReturnType = {
 
 export type FetchPublicDecryptModuleFunction = {
   fetchPublicDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchPublicDecryptParameters,
   ): Promise<FetchPublicDecryptReturnType>;
 };
@@ -129,7 +137,7 @@ export type FetchUserDecryptReturnType = readonly KmsSigncryptedShare[];
 
 export type FetchUserDecryptModuleFunction = {
   fetchUserDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchUserDecryptParameters,
   ): Promise<FetchUserDecryptReturnType>;
 };
@@ -155,7 +163,7 @@ export type FetchDelegatedUserDecryptReturnType = readonly KmsSigncryptedShare[]
 
 export type FetchDelegatedUserDecryptModuleFunction = {
   fetchDelegatedUserDecrypt(
-    relayerClient: RelayerClient,
+    relayerClient: RelayerClientWithRuntime,
     parameters: FetchDelegatedUserDecryptParameters,
   ): Promise<FetchDelegatedUserDecryptReturnType>;
 };

package/core/modules/relayer/utils.ts

@@ -0,0 +1,17 @@
+import type { KmsSigncryptedShare } from '../../types/kms-p.js';
+import type { FetchUserDecryptResult } from '../../types/relayer.js';
+import { remove0x } from '../../base/string.js';
+
+export function userDecryptResultToKmsSigncryptedShares(
+  result: FetchUserDecryptResult,
+): readonly KmsSigncryptedShare[] {
+  const shares: KmsSigncryptedShare[] = result.map((r) => {
+    const share: KmsSigncryptedShare = {
+      signature: r.signature,
+      payload: r.payload,
+      extraData: remove0x(r.extraData),
+    };
+    return share;
+  });
+  return shares;
+}

package/core/types/index.ts

@@ -1,2 +1,3 @@
 export type { TypedValue } from './primitives.js';
 export type { EncryptedValue, EncryptedValueLike } from './encryptedTypes.js';
+export type { KmsDecryptEip712Like } from './kms.js';

package/core/types/kms.ts

@@ -99,6 +99,25 @@ export type KmsPublicDecryptEip712Message = Readonly<{
   extraData: BytesHex;
 }>;
 
+export type KmsDecryptEip712Like = {
+  readonly domain: {
+    readonly name: string;
+    readonly version: string;
+    readonly chainId: number | bigint;
+    readonly verifyingContract: string;
+  };
+  readonly primaryType?: string | undefined;
+  readonly types: Record<string, ReadonlyArray<{ readonly name: string; readonly type: string }>>;
+  readonly message: {
+    readonly publicKey: string | Uint8Array;
+    readonly contractAddresses: string[];
+    readonly startTimestamp: number;
+    readonly durationDays: number;
+    readonly extraData: string | Uint8Array;
+    readonly delegatorAddress?: string | undefined;
+  };
+};
+
 export type KmsUserDecryptEip712 = Prettify<{
   readonly domain: KmsEip712Domain;
   readonly types: KmsUserDecryptEip712Types;

package/core/types/zkProof-p.ts

@@ -1,6 +1,6 @@
 import type { InputHandle } from './encryptedTypes-p.js';
 import type { EncryptionBits } from './fheType.js';
-import type { Bytes, ChecksummedAddress, Uint64BigInt } from './primitives.js';
+import type { Bytes, BytesHex, ChecksummedAddress, Uint64BigInt } from './primitives.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -25,5 +25,7 @@ export interface ZkProof {
   readonly ciphertextWithZkProof: Bytes;
   readonly encryptionBits: readonly EncryptionBits[];
 
+  // Private functions
   getInputHandles(): readonly InputHandle[];
+  getExtraData(): BytesHex;
 }

package/ethers/cleartext/createFhevmCleartextBaseClient.ts

@@ -0,0 +1,25 @@
+import type { Provider } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { FhevmRuntime } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmBaseClient } from '../../core/types/fhevmClient.js';
+import { createCoreFhevm } from '../../core/runtime/CoreFhevm-p.js';
+import { baseActions } from '../../core/clients/decorators/base.js';
+import { PRIVATE_ETHERS_TOKEN } from '../internal/ethers-p.js';
+import { getCleartextEthersRuntime } from '../internal/runtime-ct.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmCleartextBaseClient<chain extends FhevmChain, provider extends Provider>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmBaseClient<chain, FhevmRuntime, provider> {
+  const c = createCoreFhevm(PRIVATE_ETHERS_TOKEN, {
+    chain: parameters.chain,
+    runtime: getCleartextEthersRuntime(),
+    client: parameters.provider,
+    options: parameters.options,
+  });
+  return c.extend(baseActions);
+}

package/ethers/cleartext/createFhevmCleartextClient.ts

@@ -0,0 +1,20 @@
+import type { Provider } from 'ethers';
+import type { FhevmChain } from '../../core/types/fhevmChain.js';
+import type { WithAll } from '../../core/types/coreFhevmRuntime.js';
+import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
+import type { FhevmClient } from '../../core/types/fhevmClient.js';
+import { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
+import { encryptActions } from './decorators/encrypt.js';
+import { decryptActions } from './decorators/decrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmCleartextClient<chain extends FhevmChain, provider extends Provider>(parameters: {
+  readonly provider: provider;
+  readonly chain: chain;
+  readonly options?: FhevmOptions | undefined;
+}): FhevmClient<chain, WithAll, provider> {
+  const c = createFhevmCleartextBaseClient(parameters);
+
+  return c.extend(decryptActions).extend(encryptActions);
+}

package/ethers/cleartext/createFhevmCleartextDecryptClient.ts

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

package/ethers/cleartext/createFhevmCleartextEncryptClient.ts

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

package/ethers/cleartext/decorators/decrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../../core/types/fhevmChain.js';
+import type { WithDecrypt } from '../../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../../core/types/coreFhevmClient.js';
+import type { DecryptActions } from '../../../core/clients/decorators/decrypt.js';
+import { decryptModule } from '../../../core/modules/decrypt/mock.js';
+import { decryptActionsWithModule } from '../../../core/clients/decorators/decrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function decryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<DecryptActions, WithDecrypt> {
+  return decryptActionsWithModule(fhevm, decryptModule);
+}

package/ethers/cleartext/decorators/encrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../../core/types/fhevmChain.js';
+import type { WithEncrypt } from '../../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../../core/types/coreFhevmClient.js';
+import type { EncryptActions } from '../../../core/clients/decorators/encrypt.js';
+import { encryptModule } from '../../../core/modules/encrypt/mock.js';
+import { encryptActionsWithModule } from '../../../core/clients/decorators/encrypt.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function encryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<EncryptActions, WithEncrypt> {
+  return encryptActionsWithModule(fhevm, encryptModule);
+}

package/ethers/cleartext/index.ts

@@ -0,0 +1,4 @@
+export { createFhevmCleartextBaseClient } from './createFhevmCleartextBaseClient.js';
+export { createFhevmCleartextDecryptClient } from './createFhevmCleartextDecryptClient.js';
+export { createFhevmCleartextEncryptClient } from './createFhevmCleartextEncryptClient.js';
+export { createFhevmCleartextClient } from './createFhevmCleartextClient.js';

package/ethers/cleartext/package.json

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

package/ethers/clients/createFhevmBaseClient.ts

@@ -3,9 +3,10 @@ import type { FhevmChain } from '../../core/types/fhevmChain.js';
 import type { FhevmRuntime } from '../../core/types/coreFhevmRuntime.js';
 import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmBaseClient } from '../../core/types/fhevmClient.js';
-import { getEthersRuntime, PRIVATE_ETHERS_TOKEN } from '../internal/ethers-p.js';
+import { PRIVATE_ETHERS_TOKEN } from '../internal/ethers-p.js';
 import { createCoreFhevm } from '../../core/runtime/CoreFhevm-p.js';
 import { baseActions } from '../../core/clients/decorators/base.js';
+import { getEthersRuntime } from '../internal/runtime.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 

package/ethers/clients/createFhevmClient.ts

@@ -4,8 +4,8 @@ import type { WithAll } from '../../core/types/coreFhevmRuntime.js';
 import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmClient } from '../../core/types/fhevmClient.js';
 import { createFhevmBaseClient } from './createFhevmBaseClient.js';
-import { encryptActions } from '../decorators/encrypt.js';
-import { decryptActions } from '../decorators/decrypt.js';
+import { encryptActions } from './decorators/encrypt.js';
+import { decryptActions } from './decorators/decrypt.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 

package/ethers/clients/createFhevmDecryptClient.ts

@@ -4,7 +4,7 @@ import type { WithDecrypt } from '../../core/types/coreFhevmRuntime.js';
 import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmDecryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmBaseClient } from './createFhevmBaseClient.js';
-import { decryptActions } from '../decorators/decrypt.js';
+import { decryptActions } from './decorators/decrypt.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 

package/ethers/clients/createFhevmEncryptClient.ts

@@ -4,7 +4,7 @@ import type { WithEncrypt } from '../../core/types/coreFhevmRuntime.js';
 import type { FhevmOptions } from '../../core/types/coreFhevmClient.js';
 import type { FhevmEncryptClient } from '../../core/types/fhevmClient.js';
 import { createFhevmBaseClient } from './createFhevmBaseClient.js';
-import { encryptActions } from '../decorators/encrypt.js';
+import { encryptActions } from './decorators/encrypt.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 

package/ethers/clients/decorators/decrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../../core/types/fhevmChain.js';
+import type { WithDecrypt } from '../../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../../core/types/coreFhevmClient.js';
+import type { DecryptActions } from '../../../core/clients/decorators/decrypt.js';
+import { decryptActionsWithModule } from '../../../core/clients/decorators/decrypt.js';
+import { decryptModule } from '../../../core/modules/decrypt/module/index.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function decryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<DecryptActions, WithDecrypt> {
+  return decryptActionsWithModule(fhevm, decryptModule);
+}

package/ethers/clients/decorators/encrypt.ts

@@ -0,0 +1,12 @@
+import type { FhevmChain } from '../../../core/types/fhevmChain.js';
+import type { WithEncrypt } from '../../../core/types/coreFhevmRuntime.js';
+import type { FhevmBase, FhevmExtension } from '../../../core/types/coreFhevmClient.js';
+import type { EncryptActions } from '../../../core/clients/decorators/encrypt.js';
+import { encryptActionsWithModule } from '../../../core/clients/decorators/encrypt.js';
+import { encryptModule } from '../../../core/modules/encrypt/module/index.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function encryptActions(fhevm: FhevmBase<FhevmChain>): FhevmExtension<EncryptActions, WithEncrypt> {
+  return encryptActionsWithModule(fhevm, encryptModule);
+}

package/ethers/index.ts

@@ -1,4 +1,4 @@
-export { setFhevmRuntimeConfig } from './internal/ethers-p.js';
+export { setFhevmRuntimeConfig, hasFhevmRuntimeConfig } from './internal/config.js';
 
 export { createFhevmBaseClient } from './clients/createFhevmBaseClient.js';
 export { createFhevmClient } from './clients/createFhevmClient.js';

package/ethers/internal/config.ts

@@ -0,0 +1,50 @@
+import type { FhevmRuntimeConfig } from '../../core/types/coreFhevmRuntime.js';
+
+let ethersFhevmRuntimeConfig: FhevmRuntimeConfig | undefined;
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Sets the global {@link FhevmRuntimeConfig} used by the viem adapter.
+ *
+ * Must be called before any runtime or client is created.
+ * May be called multiple times with identical parameters (idempotent).
+ * Throws if called again with different parameters.
+ *
+ * @param config - The runtime configuration.
+ * @throws If a different config has already been set.
+ */
+export function setFhevmRuntimeConfig(config: FhevmRuntimeConfig): void {
+  if (ethersFhevmRuntimeConfig === undefined) {
+    ethersFhevmRuntimeConfig = Object.freeze({
+      ...config,
+      logger: config.logger ? Object.freeze({ ...config.logger }) : undefined,
+    });
+    return;
+  }
+
+  if (
+    ethersFhevmRuntimeConfig.logger !== config.logger ||
+    ethersFhevmRuntimeConfig.locateFile !== config.locateFile ||
+    ethersFhevmRuntimeConfig.singleThread !== config.singleThread ||
+    ethersFhevmRuntimeConfig.numberOfThreads !== config.numberOfThreads
+  ) {
+    throw new Error(
+      'FhevmRuntime config has already been set and cannot be changed. ' +
+        'Ensure setFhevmRuntimeConfig is called only once, or with identical parameters.',
+    );
+  }
+}
+
+export function hasFhevmRuntimeConfig(): boolean {
+  return ethersFhevmRuntimeConfig !== undefined;
+}
+
+export function getFhevmRuntimeConfig(): FhevmRuntimeConfig {
+  if (ethersFhevmRuntimeConfig === undefined) {
+    throw new Error(
+      'FhevmRuntime config has not been set. ' + 'Call setFhevmRuntimeConfig before creating any runtime or client.',
+    );
+  }
+  return ethersFhevmRuntimeConfig;
+}

package/ethers/internal/ethereum-ct.ts

@@ -0,0 +1,61 @@
+import type {
+  CleartextEthereumModuleFactory,
+  GeneratePrivateKeyReturnType,
+  GetPublicKeyParameters,
+  GetPublicKeyReturnType,
+  MnemonicToAccountParameters,
+  MnemonicToAccountReturnType,
+  RecoverAddressParameters,
+  RecoverAddressReturnType,
+  SignParameters,
+  SignReturnType,
+} from '../../core/modules/ethereum/types-ct.js';
+import type { BytesHex, ChecksummedAddress } from '../../core/types/primitives.js';
+import {
+  decode,
+  encode,
+  encodePacked,
+  getChainId,
+  readContract,
+  recoverTypedDataAddress,
+  signTypedData,
+} from './ethereum.js';
+import { SigningKey, HDNodeWallet, Wallet } from 'ethers';
+import { sign, recoverAddress } from '../../core/base/sign.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export const cleartextEthereumModule: CleartextEthereumModuleFactory = () => {
+  return Object.freeze({
+    ethereum: Object.freeze({
+      decode,
+      encode,
+      encodePacked,
+      recoverTypedDataAddress,
+      signTypedData,
+      getChainId,
+      readContract,
+      mnemonicToAccount: (parameters: MnemonicToAccountParameters): MnemonicToAccountReturnType => {
+        const signer = HDNodeWallet.fromPhrase(parameters.mnemonic, undefined, parameters.path);
+        return {
+          privateKey: signer.privateKey as BytesHex,
+          address: signer.address as ChecksummedAddress,
+        };
+      },
+      sign: (parameters: SignParameters): Promise<SignReturnType> => {
+        const signature = sign(parameters);
+        return Promise.resolve(signature);
+      },
+      generatePrivateKey: (): GeneratePrivateKeyReturnType => {
+        return Wallet.createRandom().privateKey as BytesHex;
+      },
+      getPublicKey: (parameters: GetPublicKeyParameters): GetPublicKeyReturnType => {
+        return SigningKey.computePublicKey(parameters.privateKey, false) as BytesHex;
+      },
+      recoverAddress: (parameters: RecoverAddressParameters): Promise<RecoverAddressReturnType> => {
+        const recoveredAddress = recoverAddress(parameters);
+        return Promise.resolve(recoveredAddress);
+      },
+    }),
+  });
+};