@zama-fhe/relayer-sdk 0.1.0-6 → 0.1.0-8

package/bundle.d.ts

@@ -13,4 +13,5 @@ export {
   ENCRYPTION_TYPES,
   DecryptedResults,
   initFhevm,
+  SepoliaConfig,
 } from './lib/web';

package/bundle.js

@@ -1,12 +1,3 @@
-const waitForFunction =
-  (functionName) =>
-  async (...params) => {
-    if (window && window.fhevm) {
-      return window.fhevm[functionName](...params);
-    }
-  };
-
-const initFhevm = waitForFunction('initFhevm');
-const createInstance = waitForFunction('createInstance');
-
-export { initFhevm, createInstance };
+export const initFhevm = window.fhevm.initFhevm;
+export const createInstance = window.fhevm.createInstance;
+export const SepoliaConfig = window.fhevm.SepoliaConfig;

package/lib/node.cjs

@@ -1,11 +1,31 @@
 'use strict';
 
+var TFHEPkg = require('node-tfhe');
+var TKMSPkg = require('node-tkms');
 var ethers = require('ethers');
-var nodeTfhe = require('node-tfhe');
-var nodeTkms = require('node-tkms');
 var createHash = require('keccak');
 var fetchRetry = require('fetch-retry');
 
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var TFHEPkg__namespace = /*#__PURE__*/_interopNamespaceDefault(TFHEPkg);
+var TKMSPkg__namespace = /*#__PURE__*/_interopNamespaceDefault(TKMSPkg);
+
 const SERIALIZED_SIZE_LIMIT_CIPHERTEXT = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_PK = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_CRS = BigInt(1024 * 1024 * 512);
@@ -82,10 +102,17 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
             if (!publicParams2048Response.ok) {
                 throw new Error(`HTTP error! status: ${publicParams2048Response.status} on ${publicParams2048Response.url}`);
             }
-            const publicParams2048 = await publicParams2048Response.bytes();
+            let publicParams2048;
+            if (typeof publicParams2048Response.bytes === 'function') {
+                // bytes is not widely supported yet
+                publicParams2048 = await publicParams2048Response.bytes();
+            }
+            else {
+                publicParams2048 = new Uint8Array(await publicParams2048Response.arrayBuffer());
+            }
             let pub_key;
             try {
-                pub_key = nodeTfhe.TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
+                pub_key = TFHE.TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
             }
             catch (e) {
                 throw new Error('Invalid public key (deserialization failed)', {
@@ -94,7 +121,7 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
             }
             let crs;
             try {
-                crs = nodeTfhe.CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
+                crs = TFHE.CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
             }
             catch (e) {
                 throw new Error('Invalid crs (deserialization failed)', {
@@ -163,7 +190,7 @@ const getTfheCompactPublicKey = async (config) => {
         const buff = config.publicKey.data;
         try {
             return {
-                publicKey: nodeTfhe.TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
+                publicKey: TFHE.TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
                 publicKeyId: config.publicKey.id,
             };
         }
@@ -187,7 +214,7 @@ const getPublicParams = async (config) => {
         try {
             return {
                 2048: {
-                    publicParams: nodeTfhe.CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
+                    publicParams: TFHE.CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
                     publicParamsId: config.publicParams['2048'].publicParamsId,
                 },
             };
@@ -370,8 +397,8 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
     let pubKey;
     let privKey;
     try {
-        pubKey = nodeTkms.u8vec_to_ml_kem_pke_pk(fromHexString(publicKey));
-        privKey = nodeTkms.u8vec_to_ml_kem_pke_sk(fromHexString(privateKey));
+        pubKey = TKMS.u8vec_to_ml_kem_pke_pk(fromHexString(publicKey));
+        privKey = TKMS.u8vec_to_ml_kem_pke_sk(fromHexString(privateKey));
     }
     catch (e) {
         throw new Error('Invalid public or private key', { cause: e });
@@ -402,9 +429,9 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
     }
     // assume the KMS Signers have the correct order
     let indexedKmsSigners = kmsSigners.map((signer, index) => {
-        return nodeTkms.new_server_id_addr(index + 1, signer);
+        return TKMS.new_server_id_addr(index + 1, signer);
     });
-    const client = nodeTkms.new_client(indexedKmsSigners, userAddress, 'default');
+    const client = TKMS.new_client(indexedKmsSigners, userAddress, 'default');
     try {
         const buffer = new ArrayBuffer(32);
         const view = new DataView(buffer);
@@ -424,7 +451,7 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
             ciphertext_handles: handles.map((h) => h.handle.replace(/^0x/, '')),
             eip712_verifying_contract: verifyingContractAddress,
         };
-        const decryption = nodeTkms.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
+        const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
         const results = buildUserDecryptedResult(handles.map((h) => h.handle), listBigIntDecryptions);
         return results;
@@ -459,7 +486,7 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
     }
     const publicKey = tfheCompactPublicKey;
     const bits = [];
-    const builder = nodeTfhe.CompactCiphertextList.builder(publicKey);
+    const builder = TFHE.CompactCiphertextList.builder(publicKey);
     let ciphertextWithZKProof = new Uint8Array(); // updated in `_prove`
     const checkLimit = (added) => {
         if (bits.reduce((acc, val) => acc + Math.max(2, val), 0) + added > 2048) {
@@ -590,7 +617,7 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
             auxData.set(buffUser, 20);
             auxData.set(buffAcl, 40);
             auxData.set(buffChainId, auxData.length - buffChainId.length);
-            const encrypted = builder.build_with_proof_packed(pp, auxData, nodeTfhe.ZkComputeLoad.Verify);
+            const encrypted = builder.build_with_proof_packed(pp, auxData, TFHE.ZkComputeLoad.Verify);
             ciphertextWithZKProof = encrypted.safe_serialize(SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
             return ciphertextWithZKProof;
         },
@@ -636,9 +663,9 @@ const computeHandles = (ciphertextWithZKProof, bitwidths, aclContractAddress, ch
         if (BigInt(chainId) > MAX_UINT64) {
             throw new Error('ChainId exceeds maximum allowed value (8 bytes)'); // fhevm assumes chainID is only taking up to 8 bytes
         }
-        const chainId8Bytes = chainId32Bytes.slice(24, 32);
+        const chainId8Bytes = fromHexString(hex).slice(24, 32);
         dataInput[21] = encryptionIndex;
-        chainId8Bytes.copy(dataInput, 22);
+        dataInput.set(chainId8Bytes, 22);
         dataInput[30] = encryptionType;
         dataInput[31] = ciphertextVersion;
         return dataInput;
@@ -990,7 +1017,7 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
  * @param durationDays - How many days the decryption permission remains valid
  * @returns EIP712 typed data structure for user decryption
  */
-const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
+const createEIP712 = (verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
     if (delegatedAccount && !ethers.isAddress(delegatedAccount))
         throw new Error('Invalid delegated account.');
     if (!ethers.isAddress(verifyingContract)) {
@@ -1019,7 +1046,7 @@ const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (p
     const domain = {
         name: 'Decryption',
         version: '1',
-        chainId: gatewayChainId,
+        chainId: contractsChainId,
         verifyingContract,
     };
     if (delegatedAccount) {
@@ -1073,10 +1100,10 @@ const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (p
     };
 };
 const generateKeypair = () => {
-    const keypair = nodeTkms.ml_kem_pke_keygen();
+    const keypair = TKMS.ml_kem_pke_keygen();
     return {
-        publicKey: toHexString(nodeTkms.ml_kem_pke_pk_to_u8vec(nodeTkms.ml_kem_pke_get_pk(keypair))),
-        privateKey: toHexString(nodeTkms.ml_kem_pke_sk_to_u8vec(keypair)),
+        publicKey: toHexString(TKMS.ml_kem_pke_pk_to_u8vec(TKMS.ml_kem_pke_get_pk(keypair))),
+        privateKey: toHexString(TKMS.ml_kem_pke_sk_to_u8vec(keypair)),
     };
 };
 
@@ -1133,7 +1160,7 @@ const createInstance = async (config) => {
     return {
         createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, cleanURL(config.relayerUrl), publicKeyData.publicKey, publicParamsData, coprocessorSigners, thresholdCoprocessorSigners),
         generateKeypair,
-        createEIP712: createEIP712(gatewayChainId, verifyingContractAddressDecryption, chainId),
+        createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
         publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider),
         userDecrypt: userDecryptRequest(kmsSigners, gatewayChainId, chainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider),
         getPublicKey: () => publicKeyData.publicKey
@@ -1155,15 +1182,15 @@ const createInstance = async (config) => {
 };
 
 const createTfheKeypair = () => {
-    const block_params = new nodeTfhe.ShortintParameters(nodeTfhe.ShortintParametersName.PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128);
-    const casting_params = new nodeTfhe.ShortintCompactPublicKeyEncryptionParameters(nodeTfhe.ShortintCompactPublicKeyEncryptionParametersName.V1_0_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128);
-    const config = nodeTfhe.TfheConfigBuilder.default()
+    const block_params = new TFHEPkg.ShortintParameters(TFHEPkg.ShortintParametersName.PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128);
+    const casting_params = new TFHEPkg.ShortintCompactPublicKeyEncryptionParameters(TFHEPkg.ShortintCompactPublicKeyEncryptionParametersName.V1_0_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128);
+    const config = TFHEPkg.TfheConfigBuilder.default()
         .use_custom_parameters(block_params)
         .use_dedicated_compact_public_key_parameters(casting_params)
         .build();
-    let clientKey = nodeTfhe.TfheClientKey.generate(config);
-    let publicKey = nodeTfhe.TfheCompactPublicKey.new(clientKey);
-    const crs = nodeTfhe.CompactPkeCrs.from_config(config, 4 * 512);
+    let clientKey = TFHEPkg.TfheClientKey.generate(config);
+    let publicKey = TFHEPkg.TfheCompactPublicKey.new(clientKey);
+    const crs = TFHEPkg.CompactPkeCrs.from_config(config, 4 * 512);
     return { clientKey, publicKey, crs };
 };
 const createTfhePublicKey = () => {
@@ -1171,6 +1198,9 @@ const createTfhePublicKey = () => {
     return toHexString(publicKey.serialize());
 };
 
+global.TFHE = TFHEPkg__namespace;
+global.TKMS = TKMSPkg__namespace;
+
 exports.ENCRYPTION_TYPES = ENCRYPTION_TYPES;
 exports.SepoliaConfig = SepoliaConfig;
 exports.createEIP712 = createEIP712;

package/lib/node.d.ts

@@ -15,7 +15,7 @@ import { TfheCompactPublicKey } from 'node-tfhe';
  * @param durationDays - How many days the decryption permission remains valid
  * @returns EIP712 typed data structure for user decryption
  */
-export declare const createEIP712: (gatewayChainId: number, verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
+export declare const createEIP712: (verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
 
 export declare const createInstance: (config: FhevmInstanceConfig) => Promise<FhevmInstance>;
 
@@ -110,7 +110,7 @@ export declare type HandleContractPair = {
     contractAddress: string;
 };
 
-export declare type PublicParams<T = CompactPkeCrs> = {
+export declare type PublicParams<T = TFHE['CompactPkeCrs']> = {
     [key in EncryptionTypes]?: {
         publicParams: T;
         publicParamsId: string;

package/lib/node.js

@@ -1,6 +1,7 @@
+import * as TFHEPkg from 'node-tfhe';
+import { ShortintParameters, ShortintParametersName, ShortintCompactPublicKeyEncryptionParameters, ShortintCompactPublicKeyEncryptionParametersName, TfheConfigBuilder, TfheClientKey, TfheCompactPublicKey, CompactPkeCrs } from 'node-tfhe';
+import * as TKMSPkg from 'node-tkms';
 import { JsonRpcProvider, BrowserProvider, Contract, ethers, getAddress, isAddress, AbiCoder } from 'ethers';
-import { TfheCompactPublicKey, CompactPkeCrs, CompactCiphertextList, ZkComputeLoad, ShortintParameters, ShortintParametersName, ShortintCompactPublicKeyEncryptionParameters, ShortintCompactPublicKeyEncryptionParametersName, TfheConfigBuilder, TfheClientKey } from 'node-tfhe';
-import { u8vec_to_ml_kem_pke_pk, u8vec_to_ml_kem_pke_sk, new_server_id_addr, new_client, process_user_decryption_resp_from_js, ml_kem_pke_keygen, ml_kem_pke_pk_to_u8vec, ml_kem_pke_get_pk, ml_kem_pke_sk_to_u8vec } from 'node-tkms';
 import createHash from 'keccak';
 import fetchRetry from 'fetch-retry';
 
@@ -80,10 +81,17 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
             if (!publicParams2048Response.ok) {
                 throw new Error(`HTTP error! status: ${publicParams2048Response.status} on ${publicParams2048Response.url}`);
             }
-            const publicParams2048 = await publicParams2048Response.bytes();
+            let publicParams2048;
+            if (typeof publicParams2048Response.bytes === 'function') {
+                // bytes is not widely supported yet
+                publicParams2048 = await publicParams2048Response.bytes();
+            }
+            else {
+                publicParams2048 = new Uint8Array(await publicParams2048Response.arrayBuffer());
+            }
             let pub_key;
             try {
-                pub_key = TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
+                pub_key = TFHE.TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
             }
             catch (e) {
                 throw new Error('Invalid public key (deserialization failed)', {
@@ -92,7 +100,7 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
             }
             let crs;
             try {
-                crs = CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
+                crs = TFHE.CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
             }
             catch (e) {
                 throw new Error('Invalid crs (deserialization failed)', {
@@ -161,7 +169,7 @@ const getTfheCompactPublicKey = async (config) => {
         const buff = config.publicKey.data;
         try {
             return {
-                publicKey: TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
+                publicKey: TFHE.TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
                 publicKeyId: config.publicKey.id,
             };
         }
@@ -185,7 +193,7 @@ const getPublicParams = async (config) => {
         try {
             return {
                 2048: {
-                    publicParams: CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
+                    publicParams: TFHE.CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
                     publicParamsId: config.publicParams['2048'].publicParamsId,
                 },
             };
@@ -368,8 +376,8 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
     let pubKey;
     let privKey;
     try {
-        pubKey = u8vec_to_ml_kem_pke_pk(fromHexString(publicKey));
-        privKey = u8vec_to_ml_kem_pke_sk(fromHexString(privateKey));
+        pubKey = TKMS.u8vec_to_ml_kem_pke_pk(fromHexString(publicKey));
+        privKey = TKMS.u8vec_to_ml_kem_pke_sk(fromHexString(privateKey));
     }
     catch (e) {
         throw new Error('Invalid public or private key', { cause: e });
@@ -400,9 +408,9 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
     }
     // assume the KMS Signers have the correct order
     let indexedKmsSigners = kmsSigners.map((signer, index) => {
-        return new_server_id_addr(index + 1, signer);
+        return TKMS.new_server_id_addr(index + 1, signer);
     });
-    const client = new_client(indexedKmsSigners, userAddress, 'default');
+    const client = TKMS.new_client(indexedKmsSigners, userAddress, 'default');
     try {
         const buffer = new ArrayBuffer(32);
         const view = new DataView(buffer);
@@ -422,7 +430,7 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
             ciphertext_handles: handles.map((h) => h.handle.replace(/^0x/, '')),
             eip712_verifying_contract: verifyingContractAddress,
         };
-        const decryption = process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
+        const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
         const results = buildUserDecryptedResult(handles.map((h) => h.handle), listBigIntDecryptions);
         return results;
@@ -457,7 +465,7 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
     }
     const publicKey = tfheCompactPublicKey;
     const bits = [];
-    const builder = CompactCiphertextList.builder(publicKey);
+    const builder = TFHE.CompactCiphertextList.builder(publicKey);
     let ciphertextWithZKProof = new Uint8Array(); // updated in `_prove`
     const checkLimit = (added) => {
         if (bits.reduce((acc, val) => acc + Math.max(2, val), 0) + added > 2048) {
@@ -588,7 +596,7 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
             auxData.set(buffUser, 20);
             auxData.set(buffAcl, 40);
             auxData.set(buffChainId, auxData.length - buffChainId.length);
-            const encrypted = builder.build_with_proof_packed(pp, auxData, ZkComputeLoad.Verify);
+            const encrypted = builder.build_with_proof_packed(pp, auxData, TFHE.ZkComputeLoad.Verify);
             ciphertextWithZKProof = encrypted.safe_serialize(SERIALIZED_SIZE_LIMIT_CIPHERTEXT);
             return ciphertextWithZKProof;
         },
@@ -634,9 +642,9 @@ const computeHandles = (ciphertextWithZKProof, bitwidths, aclContractAddress, ch
         if (BigInt(chainId) > MAX_UINT64) {
             throw new Error('ChainId exceeds maximum allowed value (8 bytes)'); // fhevm assumes chainID is only taking up to 8 bytes
         }
-        const chainId8Bytes = chainId32Bytes.slice(24, 32);
+        const chainId8Bytes = fromHexString(hex).slice(24, 32);
         dataInput[21] = encryptionIndex;
-        chainId8Bytes.copy(dataInput, 22);
+        dataInput.set(chainId8Bytes, 22);
         dataInput[30] = encryptionType;
         dataInput[31] = ciphertextVersion;
         return dataInput;
@@ -988,7 +996,7 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
  * @param durationDays - How many days the decryption permission remains valid
  * @returns EIP712 typed data structure for user decryption
  */
-const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
+const createEIP712 = (verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
     if (delegatedAccount && !isAddress(delegatedAccount))
         throw new Error('Invalid delegated account.');
     if (!isAddress(verifyingContract)) {
@@ -1017,7 +1025,7 @@ const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (p
     const domain = {
         name: 'Decryption',
         version: '1',
-        chainId: gatewayChainId,
+        chainId: contractsChainId,
         verifyingContract,
     };
     if (delegatedAccount) {
@@ -1071,10 +1079,10 @@ const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (p
     };
 };
 const generateKeypair = () => {
-    const keypair = ml_kem_pke_keygen();
+    const keypair = TKMS.ml_kem_pke_keygen();
     return {
-        publicKey: toHexString(ml_kem_pke_pk_to_u8vec(ml_kem_pke_get_pk(keypair))),
-        privateKey: toHexString(ml_kem_pke_sk_to_u8vec(keypair)),
+        publicKey: toHexString(TKMS.ml_kem_pke_pk_to_u8vec(TKMS.ml_kem_pke_get_pk(keypair))),
+        privateKey: toHexString(TKMS.ml_kem_pke_sk_to_u8vec(keypair)),
     };
 };
 
@@ -1131,7 +1139,7 @@ const createInstance = async (config) => {
     return {
         createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, cleanURL(config.relayerUrl), publicKeyData.publicKey, publicParamsData, coprocessorSigners, thresholdCoprocessorSigners),
         generateKeypair,
-        createEIP712: createEIP712(gatewayChainId, verifyingContractAddressDecryption, chainId),
+        createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
         publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider),
         userDecrypt: userDecryptRequest(kmsSigners, gatewayChainId, chainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider),
         getPublicKey: () => publicKeyData.publicKey
@@ -1169,4 +1177,7 @@ const createTfhePublicKey = () => {
     return toHexString(publicKey.serialize());
 };
 
+global.TFHE = TFHEPkg;
+global.TKMS = TKMSPkg;
+
 export { ENCRYPTION_TYPES, SepoliaConfig, createEIP712, createInstance, createTfheKeypair, createTfhePublicKey, generateKeypair };

package/lib/web.d.ts

@@ -1,4 +1,3 @@
-import { CompactPkeCrs } from 'node-tfhe';
 import { Eip1193Provider } from 'ethers';
 import { InitInput as KMSInput } from 'tkms';
 import { InitInput as TFHEInput } from 'tfhe';
@@ -15,7 +14,7 @@ import { InitInput as TFHEInput } from 'tfhe';
  * @param durationDays - How many days the decryption permission remains valid
  * @returns EIP712 typed data structure for user decryption
  */
-export declare const createEIP712: (gatewayChainId: number, verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
+export declare const createEIP712: (verifyingContract: string, contractsChainId: number) => (publicKey: string | Uint8Array, contractAddresses: string[], startTimestamp: string | number, durationDays: string | number, delegatedAccount?: string) => EIP712;
 
 export declare const createInstance: (config: FhevmInstanceConfig) => Promise<FhevmInstance>;
 
@@ -110,7 +109,7 @@ export declare const initFhevm: ({ tfheParams, kmsParams, thread, }?: {
 
 export { KMSInput }
 
-export declare type PublicParams<T = CompactPkeCrs> = {
+export declare type PublicParams<T = TFHE['CompactPkeCrs']> = {
     [key in EncryptionTypes]?: {
         publicParams: T;
         publicParamsId: string;