@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/core/base/wasm.ts

@@ -0,0 +1,97 @@
+import { FetchError } from './errors/FetchError.js';
+import { isDataUrlFetchSupported } from './fetch.js';
+import { isBrowserLike } from './isomorphicWorker.js';
+
+/**
+ * Decodes a base64 string to bytes using the fastest available method.
+ *
+ * - `fetch("data:...")` — preferred, uses native base64 decoder
+ * - `Buffer.from(str, "base64")` — Node.js fallback, native C++
+ * - `atob` + loop — browser fallback when data URL fetch is blocked (e.g., CSP)
+ */
+async function isomorphicDecodeBase64(base64: string): Promise<BufferSource> {
+  if (!isBrowserLike()) {
+    const { Buffer } = await import('node:buffer');
+    return Buffer.from(base64, 'base64');
+  }
+
+  if (await isDataUrlFetchSupported()) {
+    const res = await fetch(`data:application/octet-stream;base64,${base64}`);
+    return res.arrayBuffer();
+  }
+
+  // Ugly last resort: atob returns a binary string, not bytes.
+  // No batch conversion exists — we must copy char-by-char.
+  const binaryStr = atob(base64);
+  const bytes = new Uint8Array(binaryStr.length);
+  for (let i = 0; i < binaryStr.length; i++) {
+    bytes[i] = binaryStr.charCodeAt(i);
+  }
+
+  return bytes;
+}
+
+/**
+ * Compiles a WASM module from a URL, isomorphically (browser and Node.js).
+ *
+ * - Node + `file://`: uses `readFile` (Node `fetch` doesn't support `file://`)
+ * - Browser + streaming: uses `WebAssembly.compileStreaming` (fastest path)
+ * - Fallback: `fetch` + `arrayBuffer` + `WebAssembly.compile`
+ */
+export async function isomorphicCompileWasm(wasmUrl: URL): Promise<WebAssembly.Module> {
+  const isBrowser = isBrowserLike();
+
+  let bytes: BufferSource;
+
+  if (!isBrowser && wasmUrl.protocol === 'file:') {
+    // Node + file url
+    const { readFile } = await import('node:fs/promises');
+    const { fileURLToPath } = await import('node:url');
+
+    // Node's Buffer extends Uint8Array but TS 5.7+ considers its .buffer as
+    // ArrayBufferLike (includes SharedArrayBuffer), making it incompatible with
+    // BufferSource. At runtime Buffer is always backed by ArrayBuffer, so the
+    // cast at WebAssembly.compile is safe and avoids copying.
+    bytes = (await readFile(fileURLToPath(wasmUrl))) as BufferSource;
+  } else {
+    // fetch wasm
+    const res = await fetch(wasmUrl);
+
+    if (!res.ok) {
+      throw new FetchError({
+        message: `Failed to fetch WASM: ${res.status} ${res.statusText}`,
+        url: wasmUrl.toString(),
+      });
+    }
+
+    if (isBrowser) {
+      // use compile streaming
+      if (typeof WebAssembly.compileStreaming === 'function') {
+        try {
+          return await WebAssembly.compileStreaming(res);
+        } catch (e) {
+          throw new Error(
+            'WebAssembly.compileStreaming failed. Ensure the server serves .wasm files with Content-Type: application/wasm',
+            { cause: e },
+          );
+        }
+      }
+    }
+
+    bytes = await res.arrayBuffer();
+  }
+
+  // Safe cast: Node's Buffer is always backed by ArrayBuffer at runtime.
+  return WebAssembly.compile(bytes);
+}
+
+/**
+ * Compiles a WASM module from a base64-encoded string.
+ *
+ * @param wasmAsBase64 - The WASM binary encoded as a base64 string
+ * @returns A compiled WebAssembly.Module ready to be instantiated
+ */
+export async function isomorphicCompileWasmFromBase64(wasmAsBase64: string): Promise<WebAssembly.Module> {
+  const bytes = await isomorphicDecodeBase64(wasmAsBase64);
+  return WebAssembly.compile(bytes);
+}

package/core/chains/definitions/localTestnet.ts

@@ -0,0 +1,30 @@
+import { defineFhevmChain } from '../utils.js';
+
+export const localTestnet = /*#__PURE__*/ defineFhevmChain({
+  id: 12_345,
+  fhevm: {
+    contracts: {
+      acl: {
+        address: '0x05fD9B5EFE0a996095f42Ed7e77c390810CF660c',
+      },
+      inputVerifier: {
+        address: '0x857Ca72A957920Fa0FB138602995839866Bd4005',
+      },
+      kmsVerifier: {
+        address: '0xa1880e99d86F081E8D3868A8C4732C8f65dfdB11',
+      },
+    },
+    relayerUrl: 'http://localhost:9000',
+    gateway: {
+      id: 54_321,
+      contracts: {
+        decryption: {
+          address: '0xF0bFB159C7381F7CB332586004d8247252C5b816',
+        },
+        inputVerification: {
+          address: '0x3b12Fc766Eb598b285998877e8E90F3e43a1F8d2',
+        },
+      },
+    },
+  },
+});

package/core/chains/definitions/mainnet.ts

@@ -0,0 +1,30 @@
+import { defineFhevmChain } from '../utils.js';
+
+export const mainnet = /*#__PURE__*/ defineFhevmChain({
+  id: 1,
+  fhevm: {
+    contracts: {
+      acl: {
+        address: '0xcA2E8f1F656CD25C01F05d0b243Ab1ecd4a8ffb6',
+      },
+      inputVerifier: {
+        address: '0xCe0FC2e05CFff1B719EFF7169f7D80Af770c8EA2',
+      },
+      kmsVerifier: {
+        address: '0x77627828a55156b04Ac0DC0eb30467f1a552BB03',
+      },
+    },
+    relayerUrl: 'https://relayer.mainnet.zama.org',
+    gateway: {
+      id: 261_131,
+      contracts: {
+        decryption: {
+          address: '0x0f6024a97684f7d90ddb0fAAD79cB15F2C888D24',
+        },
+        inputVerification: {
+          address: '0xcB1bB072f38bdAF0F328CdEf1Fc6eDa1DF029287',
+        },
+      },
+    },
+  },
+});

package/core/chains/definitions/sepolia.ts

@@ -0,0 +1,32 @@
+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({
+  id: 11_155_111,
+  fhevm: {
+    contracts: {
+      acl: {
+        address: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D' as ChecksummedAddress,
+      },
+      inputVerifier: {
+        address: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0' as ChecksummedAddress,
+      },
+      kmsVerifier: {
+        address: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A' as ChecksummedAddress,
+      },
+    },
+    relayerUrl: 'https://relayer.testnet.zama.org',
+    gateway: {
+      id: 10_901,
+      contracts: {
+        decryption: {
+          address: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478' as ChecksummedAddress,
+        },
+        inputVerification: {
+          address: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955' as ChecksummedAddress,
+        },
+      },
+    },
+  },
+});

package/core/chains/index.ts

@@ -0,0 +1,6 @@
+export type { FhevmChain } from '../types/fhevmChain.js';
+
+export { defineFhevmChain } from './utils.js';
+
+export { mainnet } from './definitions/mainnet.js';
+export { sepolia } from './definitions/sepolia.js';

package/core/chains/package.json

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

package/core/chains/utils.ts

@@ -0,0 +1,6 @@
+import type { FhevmChain } from '../types/fhevmChain.js';
+import { simpleDeepFreeze } from '../base/object.js';
+
+export function defineFhevmChain<const chain extends FhevmChain>(fhevmChain: chain): chain {
+  return simpleDeepFreeze(fhevmChain);
+}

package/core/clients/decorators/base.ts

@@ -0,0 +1,203 @@
+import type { Fhevm, FhevmBase, FhevmExtension } from '../../types/coreFhevmClient.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type {
+  SignedSelfDecryptionPermit,
+  SignedDelegatedDecryptionPermit,
+} from '../../types/signedDecryptionPermit.js';
+import type {
+  SerializeTransportKeypairParameters,
+  SerializeTransportKeypairReturnType,
+} from '../../actions/chain/serializeTransportKeypair.js';
+import { assertIsFhevmBaseClient } from '../../runtime/CoreFhevm-p.js';
+import {
+  signDecryptionPermit,
+  type SignSelfDecryptionPermitParameters,
+  type SignDelegatedDecryptionPermitParameters,
+} from '../../actions/base/signDecryptionPermit.js';
+import {
+  parseTransportKeypair,
+  type ParseTransportKeypairParameters,
+  type ParseTransportKeypairReturnType,
+} from '../../actions/chain/parseTransportKeypair.js';
+import {
+  fetchFheEncryptionKeyBytes,
+  type FetchFheEncryptionKeyBytesParameters,
+  type FetchFheEncryptionKeyBytesReturnType,
+} from '../../actions/chain/fetchFheEncryptionKeyBytes.js';
+import { serializeTransportKeypair } from '../../actions/chain/serializeTransportKeypair.js';
+import {
+  serializeSignedDecryptionPermit,
+  type SerializeSignedDecryptionPermitParameters,
+  type SerializeSignedDecryptionPermitReturnType,
+} from '../../actions/chain/serializeSignedDecryptionPermit.js';
+import {
+  parseSignedDecryptionPermit,
+  type ParseSignedDecryptionPermitParameters,
+  type ParseSignedDecryptionPermitReturnType,
+} from '../../actions/chain/parseSignedDecryptionPermit.js';
+import {
+  readPublicValue,
+  type ReadPublicValueParameters,
+  type ReadPublicValueReturnType,
+} from '../../actions/base/readPublicValue.js';
+import {
+  readPublicValues,
+  type ReadPublicValuesParameters,
+  type ReadPublicValuesReturnType,
+} from '../../actions/base/readPublicValues.js';
+import {
+  readPublicValuesWithSignatures,
+  type ReadPublicValuesWithSignaturesParameters,
+  type ReadPublicValuesWithSignaturesReturnType,
+} from '../../actions/base/readPublicValuesWithSignatures.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type BaseActions = {
+  /**
+   * Reads the decrypted (clear) value of an encrypted value that was made public.
+   *
+   * By default, encrypted values on-chain can only be decrypted by their owner.
+   * When a contract calls `TFHE.allowForDecryption(encryptedValue)` in Solidity,
+   * the value becomes publicly readable. Anyone can then call `readPublicValue`
+   * to get the clear value — no permit or private key needed.
+   *
+   * @example
+   * ```ts
+   * const result = await client.readPublicValue({
+   *   encryptedValue: "0xabcd..."
+   * });
+   * console.log(result.value); // e.g. 42
+   * console.log(result.type); // e.g. 'uint8'
+   * ```
+   */
+  readonly readPublicValue: (parameters: ReadPublicValueParameters) => Promise<ReadPublicValueReturnType>;
+  /**
+   * Reads the decrypted (clear) values of encrypted values that were made public.
+   *
+   * By default, encrypted values on-chain can only be decrypted by their owner.
+   * When a contract calls `TFHE.allowForDecryption(encryptedValue)` in Solidity,
+   * a value becomes publicly readable. Anyone can then call `readPublicValues`
+   * to get the clear values — no permit or private key needed.
+   *
+   * @example
+   * ```ts
+   * const results = await client.readPublicValues({
+   *   encryptedValues: ["0xabcd...", "0xef..."]
+   * });
+   * console.log(results[0].value); // e.g. 42
+   * console.log(results[0].type); // e.g. 'uint8'
+   * console.log(results[1].value); // e.g. 123456789
+   * console.log(results[1].type); // e.g. 'uint32'
+   * ```
+   */
+  readonly readPublicValues: (parameters: ReadPublicValuesParameters) => Promise<ReadPublicValuesReturnType>;
+  /**
+   * Reads the decrypted (clear) value of an encrypted value that was made public.
+   *
+   * By default, encrypted values on-chain can only be decrypted by their owner.
+   * When a contract calls `TFHE.allowForDecryption(encryptedValue)` in Solidity,
+   * the value becomes publicly readable. Anyone can then call `readPublicValue`
+   * to get the clear value — no permit or private key needed.
+   *
+   * Returns both the clear values and a decryption proof. The proof can be
+   * forwarded on-chain so a smart contract can verify that an encrypted value
+   * decrypts to a specific clear value (e.g. "handle X is actually 123").
+   *
+   * @example
+   * ```ts
+   * const result = await client.readPublicValuesWithSignatures({
+   *   encryptedValues: ["0xabcd...", "0xef..."]
+   * });
+   * console.log(results.clearValues[0].value); // e.g. 42
+   * console.log(results.clearValues[0].type); // e.g. 'uint8'
+   * console.log(results.clearValues[1].value); // e.g. 123456789
+   * console.log(results.clearValues[1].type); // e.g. 'uint32'
+   *
+   * // Forward the proof on-chain for smart contract verification
+   * // Solidity side:
+   * //   function verify(bytes32[] calldata handlesList, bytes memory cleartexts, bytes memory decryptionProof) external {
+   * //       FHE.checkSignatures(handlesList, cleartexts, decryptionProof);
+   * //   }
+   * const args = result.checkSignaturesArgs;
+   * await contract.verify(args.handlesList, args.abiEncodedCleartexts, args.decryptionProof);
+   * ```
+   */
+  readonly readPublicValuesWithSignatures: (
+    parameters: ReadPublicValuesWithSignaturesParameters,
+  ) => Promise<ReadPublicValuesWithSignaturesReturnType>;
+  readonly signDecryptionPermit: {
+    /**
+     * Signs a self decryption permit — Alice decrypts her own encrypted values.
+     *
+     * 1. Alice signs a permit saying "I, Alice, want to decrypt my own handles."
+     * 2. Alice calls `decrypt` with this permit.
+     * 3. The KMS verifies Alice's signature and releases decrypted shares to her.
+     *
+     * No `delegatorAddress` needed — the signer is the owner.
+     */
+    (parameters: SignSelfDecryptionPermitParameters): Promise<SignedSelfDecryptionPermit>;
+    /**
+     * Signs a delegated decryption permit — Bob decrypts Alice's (`delegatorAddress`) encrypted values.
+     *
+     * 1. Alice calls `FHE.delegateUserDecryption()` on-chain, giving Bob permission to decrypt her handles.
+     * 2. Bob signs a permit with `delegatorAddress: Alice`, saying "I, Bob, want to decrypt Alice's handles."
+     * 3. Bob calls `decrypt` with this permit.
+     * 4. The KMS authenticates Bob via his signature, then checks the on-chain ACL to verify Alice delegated to Bob.
+     */
+    (parameters: SignDelegatedDecryptionPermitParameters): Promise<SignedDelegatedDecryptionPermit>;
+  };
+  /** Deserializes a previously serialized e2e transport keypair back into a usable keypair. */
+  readonly parseTransportKeypair: (
+    parameters: ParseTransportKeypairParameters,
+  ) => Promise<ParseTransportKeypairReturnType>;
+  /** Serializes an e2e transport keypair to hex strings for storage. */
+  readonly serializeTransportKeypair: (
+    parameters: SerializeTransportKeypairParameters,
+  ) => SerializeTransportKeypairReturnType;
+  /** Serializes a signed decryption permit to a plain object for storage or transmission. */
+  readonly serializeSignedDecryptionPermit: (
+    parameters: SerializeSignedDecryptionPermitParameters,
+  ) => SerializeSignedDecryptionPermitReturnType;
+  /** Parses and verifies a previously serialized signed decryption permit. */
+  readonly parseSignedDecryptionPermit: (
+    parameters: ParseSignedDecryptionPermitParameters,
+  ) => Promise<ParseSignedDecryptionPermitReturnType>;
+  /** Fetches the ~50MB FHE public encryption key from the relayer and caches it. */
+  readonly fetchFheEncryptionKeyBytes: (
+    parameters?: FetchFheEncryptionKeyBytesParameters,
+  ) => Promise<FetchFheEncryptionKeyBytesReturnType>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _baseActions(fhevm: Fhevm<FhevmChain>): BaseActions {
+  return {
+    readPublicValue: (parameters) => readPublicValue(fhevm, parameters),
+    readPublicValues: (parameters) => readPublicValues(fhevm, parameters),
+    readPublicValuesWithSignatures: (parameters) => readPublicValuesWithSignatures(fhevm, parameters),
+    // Preserve the original action overloads on the decorated client API.
+    // Runtime behavior is unchanged: this is a direct pass-through wrapper.
+    signDecryptionPermit: ((parameters: SignSelfDecryptionPermitParameters | SignDelegatedDecryptionPermitParameters) =>
+      signDecryptionPermit(
+        fhevm,
+        parameters as SignSelfDecryptionPermitParameters,
+      )) as BaseActions['signDecryptionPermit'],
+    parseTransportKeypair: (parameters) => parseTransportKeypair(fhevm, parameters),
+    serializeTransportKeypair: (parameters) => serializeTransportKeypair(fhevm, parameters),
+    serializeSignedDecryptionPermit: (parameters) => serializeSignedDecryptionPermit(fhevm, parameters),
+    parseSignedDecryptionPermit: (parameters) => parseSignedDecryptionPermit(fhevm, parameters),
+    fetchFheEncryptionKeyBytes: (parameters) => fetchFheEncryptionKeyBytes(fhevm, parameters),
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+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
+  };
+}

package/core/clients/decorators/decrypt.ts

@@ -0,0 +1,85 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { Fhevm, FhevmBase, FhevmExtension, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { FhevmRuntime, WithDecrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { GenerateTransportKeypairReturnType } from '../../actions/decrypt/generateTransportKeypair.js';
+import type { DecryptModuleFactory } from '../../modules/decrypt/types.js';
+import { asFhevmClientWith, assertIsFhevmClientWith } from '../../runtime/CoreFhevm-p.js';
+import { generateTransportKeypair } from '../../kms/TransportKeypair-p.js';
+import {
+  decryptValue,
+  type DecryptSelfValueParameters,
+  type DecryptDelegatedValueParameters,
+  type DecryptValueReturnType,
+} from '../../actions/decrypt/decryptValue.js';
+import {
+  decryptValues,
+  type DecryptDelegatedValuesParameters,
+  type DecryptSelfValuesParameters,
+  type DecryptValuesReturnType,
+} from '../../actions/decrypt/decryptValues.js';
+import {
+  decryptValuesFromPairs,
+  type DecryptSelfValuesFromPairsParameters,
+  type DecryptDelegatedValuesFromPairsParameters,
+  type DecryptValuesFromPairsReturnType,
+} from '../../actions/decrypt/decryptValuesFromPairs.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type DecryptActions = {
+  readonly decryptValue: {
+    (parameters: DecryptSelfValueParameters): Promise<DecryptValueReturnType>;
+    (parameters: DecryptDelegatedValueParameters): Promise<DecryptValueReturnType>;
+  };
+  readonly decryptValues: {
+    (parameters: DecryptSelfValuesParameters): Promise<DecryptValuesReturnType>;
+    (parameters: DecryptDelegatedValuesParameters): Promise<DecryptValuesReturnType>;
+  };
+  readonly decryptValuesFromPairs: {
+    (parameters: DecryptSelfValuesFromPairsParameters): Promise<DecryptValuesFromPairsReturnType>;
+    (parameters: DecryptDelegatedValuesFromPairsParameters): Promise<DecryptValuesFromPairsReturnType>;
+  };
+  readonly generateTransportKeypair: () => Promise<GenerateTransportKeypairReturnType>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _decryptActions(fhevm: Fhevm<FhevmChain, WithDecrypt>): DecryptActions {
+  // Preserve the original action overloads on the decorated client API.
+  // Runtime behavior is unchanged: this is a direct pass-through wrapper.
+  return {
+    decryptValue: ((parameters) =>
+      decryptValue(fhevm, parameters as DecryptSelfValueParameters)) as DecryptActions['decryptValue'],
+    decryptValues: ((parameters) =>
+      decryptValues(fhevm, parameters as DecryptSelfValuesParameters)) as DecryptActions['decryptValues'],
+    decryptValuesFromPairs: ((parameters) =>
+      decryptValuesFromPairs(
+        fhevm,
+        parameters as DecryptSelfValuesFromPairsParameters,
+      )) as DecryptActions['decryptValuesFromPairs'],
+    generateTransportKeypair: () => generateTransportKeypair(fhevm),
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _initDecrypt(fhevm: FhevmBase<FhevmChain | undefined, FhevmRuntime, OptionalNativeClient>): Promise<void> {
+  const f = asFhevmClientWith(fhevm, 'decrypt');
+  return f.runtime.decrypt.initTkmsModule();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function decryptActionsWithModule(
+  fhevm: FhevmBase<FhevmChain>,
+  factory: DecryptModuleFactory,
+): FhevmExtension<DecryptActions, WithDecrypt> {
+  const runtime = fhevm.runtime.extend(factory);
+  assertIsFhevmClientWith(fhevm, 'decrypt');
+  return {
+    actions: _decryptActions(fhevm),
+    runtime,
+    init: _initDecrypt,
+  };
+}

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

@@ -0,0 +1,18 @@
+import type { FhevmBase, OptionalNativeClient } from '../../types/coreFhevmClient.js';
+import type { FhevmRuntime } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import { asFhevmClientWith } from '../../runtime/CoreFhevm-p.js';
+import { fetchFheEncryptionKeyBytes } from '../../key/fetchFheEncryptionKeyBytes.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export async function _initEncrypt(
+  fhevm: FhevmBase<FhevmChain | undefined, FhevmRuntime, OptionalNativeClient>,
+): Promise<void> {
+  const f = asFhevmClientWith(fhevm, 'encrypt');
+  await Promise.all([
+    // Prefetch the global FheEncryptionKey in bytes format
+    fetchFheEncryptionKeyBytes(f, {}),
+    f.runtime.encrypt.initTfheModule(),
+  ]);
+}

package/core/clients/decorators/encrypt.ts

@@ -0,0 +1,47 @@
+import type { Fhevm, FhevmBase, FhevmExtension } from '../../types/coreFhevmClient.js';
+import type { WithEncrypt } from '../../types/coreFhevmRuntime.js';
+import type { FhevmChain } from '../../types/fhevmChain.js';
+import type { EncryptModuleFactory } from '../../modules/encrypt/types.js';
+import {
+  encryptValue,
+  type EncryptValueParameters,
+  type EncryptValueReturnType,
+} from '../../actions/encrypt/encryptValue.js';
+import {
+  encryptValues,
+  type EncryptValuesParameters,
+  type EncryptValuesReturnType,
+} from '../../actions/encrypt/encryptValues.js';
+import { assertIsFhevmClientWith } from '../../runtime/CoreFhevm-p.js';
+import { _initEncrypt } from './encrypt-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export type EncryptActions = {
+  readonly encryptValue: (parameters: EncryptValueParameters) => Promise<EncryptValueReturnType>;
+  readonly encryptValues: (parameters: EncryptValuesParameters) => Promise<EncryptValuesReturnType>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _encryptActions(fhevm: Fhevm<FhevmChain, WithEncrypt>): EncryptActions {
+  return {
+    encryptValue: (parameters) => encryptValue(fhevm, parameters),
+    encryptValues: (parameters) => encryptValues(fhevm, parameters),
+  };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function encryptActionsWithModule(
+  fhevm: FhevmBase<FhevmChain>,
+  factory: EncryptModuleFactory,
+): FhevmExtension<EncryptActions, WithEncrypt> {
+  const runtime = fhevm.runtime.extend(factory);
+  assertIsFhevmClientWith(fhevm, 'encrypt');
+  return {
+    actions: _encryptActions(fhevm),
+    runtime,
+    init: _initEncrypt,
+  };
+}