@zama-fhe/relayer-sdk 0.1.0-5 → 0.1.0-7

package/lib/web.js

@@ -293,6 +293,22 @@ function passArray8ToWasm0$1(arg, malloc) {
     WASM_VECTOR_LEN$1 = arg.length;
     return ptr;
 }
+
+function init_panic_hook() {
+    wasm$1.init_panic_hook();
+}
+
+/**
+ * @param {TfheServerKey} server_key
+ */
+function set_server_key(server_key) {
+    _assertClass$1(server_key, TfheServerKey);
+    const ret = wasm$1.set_server_key(server_key.__wbg_ptr);
+    if (ret[1]) {
+        throw takeFromExternrefTable0$1(ret[0]);
+    }
+}
+
 /**
  * @param {ShortintCompactPublicKeyEncryptionParametersName} param
  * @returns {string}
@@ -327,21 +343,6 @@ function shortint_params_name(param) {
     }
 }
 
-function init_panic_hook() {
-    wasm$1.init_panic_hook();
-}
-
-/**
- * @param {TfheServerKey} server_key
- */
-function set_server_key(server_key) {
-    _assertClass$1(server_key, TfheServerKey);
-    const ret = wasm$1.set_server_key(server_key.__wbg_ptr);
-    if (ret[1]) {
-        throw takeFromExternrefTable0$1(ret[0]);
-    }
-}
-
 /**
  * @param {number} num_threads
  * @returns {Promise<any>}
@@ -24780,223 +24781,6 @@ var tfhe$1 = /*#__PURE__*/Object.freeze({
   wbg_rayon_start_worker: wbg_rayon_start_worker
 });
 
-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);
-const cleanURL = (url) => {
-    if (!url)
-        return '';
-    return url.endsWith('/') ? url.slice(0, -1) : url;
-};
-const numberToHex = (num) => {
-    let hex = num.toString(16);
-    return hex.length % 2 ? '0' + hex : hex;
-};
-const fromHexString = (hexString) => {
-    const arr = hexString.replace(/^(0x)/, '').match(/.{1,2}/g);
-    if (!arr)
-        return new Uint8Array();
-    return Uint8Array.from(arr.map((byte) => parseInt(byte, 16)));
-};
-const toHexString = (bytes, with0x = false) => `${with0x ? '0x' : ''}${bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')}`;
-const bytesToBigInt = function (byteArray) {
-    if (!byteArray || byteArray?.length === 0) {
-        return BigInt(0);
-    }
-    const hex = Array.from(byteArray)
-        .map((b) => b.toString(16).padStart(2, '0')) // byte to hex
-        .join('');
-    return BigInt(`0x${hex}`);
-};
-
-const keyurlCache = {};
-const getKeysFromRelayer = async (url, publicKeyId) => {
-    if (keyurlCache[url]) {
-        return keyurlCache[url];
-    }
-    try {
-        const response = await fetch(`${url}/v1/keyurl`);
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const data = await response.json();
-        if (data) {
-            let pubKeyUrl;
-            // If no publicKeyId is provided, use the first one
-            // Warning: if there are multiple keys available, the first one will most likely never be the
-            // same between several calls (fetching the infos is non-deterministic)
-            if (!publicKeyId) {
-                pubKeyUrl = data.response.fhe_key_info[0].fhe_public_key.urls[0];
-                publicKeyId = data.response.fhe_key_info[0].fhe_public_key.data_id;
-            }
-            else {
-                // If a publicKeyId is provided, get the corresponding info
-                const keyInfo = data.response.fhe_key_info.find((info) => info.fhe_public_key.data_id === publicKeyId);
-                if (!keyInfo) {
-                    throw new Error(`Could not find FHE key info with data_id ${publicKeyId}`);
-                }
-                // TODO: Get a given party's public key url instead of the first one
-                pubKeyUrl = keyInfo.fhe_public_key.urls[0];
-            }
-            const publicKeyResponse = await fetch(pubKeyUrl);
-            if (!publicKeyResponse.ok) {
-                throw new Error(`HTTP error! status: ${publicKeyResponse.status} on ${publicKeyResponse.url}`);
-            }
-            let publicKey;
-            if (typeof publicKeyResponse.bytes === 'function') {
-                // bytes is not widely supported yet
-                publicKey = await publicKeyResponse.bytes();
-            }
-            else {
-                publicKey = new Uint8Array(await publicKeyResponse.arrayBuffer());
-            }
-            const publicParamsUrl = data.response.crs['2048'].urls[0];
-            const publicParamsId = data.response.crs['2048'].data_id;
-            const publicParams2048Response = await fetch(publicParamsUrl);
-            if (!publicParams2048Response.ok) {
-                throw new Error(`HTTP error! status: ${publicParams2048Response.status} on ${publicParams2048Response.url}`);
-            }
-            const publicParams2048 = await publicParams2048Response.bytes();
-            let pub_key;
-            try {
-                pub_key = TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
-            }
-            catch (e) {
-                throw new Error('Invalid public key (deserialization failed)', {
-                    cause: e,
-                });
-            }
-            let crs;
-            try {
-                crs = CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
-            }
-            catch (e) {
-                throw new Error('Invalid crs (deserialization failed)', {
-                    cause: e,
-                });
-            }
-            const result = {
-                publicKey: pub_key,
-                publicKeyId,
-                publicParams: {
-                    2048: {
-                        publicParams: crs,
-                        publicParamsId,
-                    },
-                },
-            };
-            keyurlCache[url] = result;
-            return result;
-        }
-        else {
-            throw new Error('No public key available');
-        }
-    }
-    catch (e) {
-        throw new Error('Impossible to fetch public key: wrong relayer url.', {
-            cause: e,
-        });
-    }
-};
-
-const abiKmsVerifier = [
-    'function getKmsSigners() view returns (address[])',
-    'function getThreshold() view returns (uint256)',
-];
-const abiInputVerifier = [
-    'function getCoprocessorSigners() view returns (address[])',
-    'function getThreshold() view returns (uint256)',
-];
-const getProvider = (config) => {
-    if (typeof config.network === 'string') {
-        return new JsonRpcProvider(config.network);
-    }
-    else if (config.network) {
-        return new BrowserProvider(config.network);
-    }
-    throw new Error('You must provide a network URL or a EIP1193 object (eg: window.ethereum)');
-};
-const getChainId = async (provider, config) => {
-    if (config.chainId && typeof config.chainId === 'number') {
-        return config.chainId;
-    }
-    else if (config.chainId && typeof config.chainId !== 'number') {
-        throw new Error('chainId must be a number.');
-    }
-    else {
-        const chainId = (await provider.getNetwork()).chainId;
-        return Number(chainId);
-    }
-};
-const getTfheCompactPublicKey = async (config) => {
-    if (config.relayerUrl && !config.publicKey) {
-        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
-        return { publicKey: inputs.publicKey, publicKeyId: inputs.publicKeyId };
-    }
-    else if (config.publicKey && config.publicKey.data && config.publicKey.id) {
-        const buff = config.publicKey.data;
-        try {
-            return {
-                publicKey: TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
-                publicKeyId: config.publicKey.id,
-            };
-        }
-        catch (e) {
-            throw new Error('Invalid public key (deserialization failed)', {
-                cause: e,
-            });
-        }
-    }
-    else {
-        throw new Error('You must provide a public key with its public key ID.');
-    }
-};
-const getPublicParams = async (config) => {
-    if (config.relayerUrl && !config.publicParams) {
-        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
-        return inputs.publicParams;
-    }
-    else if (config.publicParams && config.publicParams['2048']) {
-        const buff = config.publicParams['2048'].publicParams;
-        try {
-            return {
-                2048: {
-                    publicParams: CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
-                    publicParamsId: config.publicParams['2048'].publicParamsId,
-                },
-            };
-        }
-        catch (e) {
-            throw new Error('Invalid public key (deserialization failed)', {
-                cause: e,
-            });
-        }
-    }
-    else {
-        throw new Error('You must provide a valid CRS with its CRS ID.');
-    }
-};
-const getKMSSigners = async (provider, config) => {
-    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
-    const signers = await kmsContract.getKmsSigners();
-    return signers;
-};
-const getKMSSignersThreshold = async (provider, config) => {
-    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
-    const threshold = await kmsContract.getThreshold();
-    return Number(threshold); // threshold is always supposed to fit in a number
-};
-const getCoprocessorSigners = async (provider, config) => {
-    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
-    const signers = await inputContract.getCoprocessorSigners();
-    return signers;
-};
-const getCoprocessorSignersThreshold = async (provider, config) => {
-    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
-    const threshold = await inputContract.getThreshold();
-    return Number(threshold); // threshold is always supposed to fit in a number
-};
-
 let wasm;
 
 let WASM_VECTOR_LEN = 0;
@@ -25189,23 +24973,6 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-/**
- * Create a new [ServerIdAddr] structure that holds an ID and an address
- * which must be a valid EIP-55 address, notably prefixed with "0x".
- * @param {number} id
- * @param {string} addr
- * @returns {ServerIdAddr}
- */
-function new_server_id_addr(id, addr) {
-    const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.new_server_id_addr(id, ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ServerIdAddr.__wrap(ret[0]);
-}
-
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -26433,6 +26200,230 @@ async function __wbg_init(module_or_path) {
     return __wbg_finalize_init(instance, module);
 }
 
+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);
+const cleanURL = (url) => {
+    if (!url)
+        return '';
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+};
+const numberToHex = (num) => {
+    let hex = num.toString(16);
+    return hex.length % 2 ? '0' + hex : hex;
+};
+const fromHexString = (hexString) => {
+    const arr = hexString.replace(/^(0x)/, '').match(/.{1,2}/g);
+    if (!arr)
+        return new Uint8Array();
+    return Uint8Array.from(arr.map((byte) => parseInt(byte, 16)));
+};
+const toHexString = (bytes, with0x = false) => `${with0x ? '0x' : ''}${bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')}`;
+const bytesToBigInt = function (byteArray) {
+    if (!byteArray || byteArray?.length === 0) {
+        return BigInt(0);
+    }
+    const hex = Array.from(byteArray)
+        .map((b) => b.toString(16).padStart(2, '0')) // byte to hex
+        .join('');
+    return BigInt(`0x${hex}`);
+};
+
+const keyurlCache = {};
+const getKeysFromRelayer = async (url, publicKeyId) => {
+    if (keyurlCache[url]) {
+        return keyurlCache[url];
+    }
+    try {
+        const response = await fetch(`${url}/v1/keyurl`);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        if (data) {
+            let pubKeyUrl;
+            // If no publicKeyId is provided, use the first one
+            // Warning: if there are multiple keys available, the first one will most likely never be the
+            // same between several calls (fetching the infos is non-deterministic)
+            if (!publicKeyId) {
+                pubKeyUrl = data.response.fhe_key_info[0].fhe_public_key.urls[0];
+                publicKeyId = data.response.fhe_key_info[0].fhe_public_key.data_id;
+            }
+            else {
+                // If a publicKeyId is provided, get the corresponding info
+                const keyInfo = data.response.fhe_key_info.find((info) => info.fhe_public_key.data_id === publicKeyId);
+                if (!keyInfo) {
+                    throw new Error(`Could not find FHE key info with data_id ${publicKeyId}`);
+                }
+                // TODO: Get a given party's public key url instead of the first one
+                pubKeyUrl = keyInfo.fhe_public_key.urls[0];
+            }
+            const publicKeyResponse = await fetch(pubKeyUrl);
+            if (!publicKeyResponse.ok) {
+                throw new Error(`HTTP error! status: ${publicKeyResponse.status} on ${publicKeyResponse.url}`);
+            }
+            let publicKey;
+            if (typeof publicKeyResponse.bytes === 'function') {
+                // bytes is not widely supported yet
+                publicKey = await publicKeyResponse.bytes();
+            }
+            else {
+                publicKey = new Uint8Array(await publicKeyResponse.arrayBuffer());
+            }
+            const publicParamsUrl = data.response.crs['2048'].urls[0];
+            const publicParamsId = data.response.crs['2048'].data_id;
+            const publicParams2048Response = await fetch(publicParamsUrl);
+            if (!publicParams2048Response.ok) {
+                throw new Error(`HTTP error! status: ${publicParams2048Response.status} on ${publicParams2048Response.url}`);
+            }
+            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 = TFHE.TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
+            }
+            catch (e) {
+                throw new Error('Invalid public key (deserialization failed)', {
+                    cause: e,
+                });
+            }
+            let crs;
+            try {
+                crs = TFHE.CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
+            }
+            catch (e) {
+                throw new Error('Invalid crs (deserialization failed)', {
+                    cause: e,
+                });
+            }
+            const result = {
+                publicKey: pub_key,
+                publicKeyId,
+                publicParams: {
+                    2048: {
+                        publicParams: crs,
+                        publicParamsId,
+                    },
+                },
+            };
+            keyurlCache[url] = result;
+            return result;
+        }
+        else {
+            throw new Error('No public key available');
+        }
+    }
+    catch (e) {
+        throw new Error('Impossible to fetch public key: wrong relayer url.', {
+            cause: e,
+        });
+    }
+};
+
+const abiKmsVerifier = [
+    'function getKmsSigners() view returns (address[])',
+    'function getThreshold() view returns (uint256)',
+];
+const abiInputVerifier = [
+    'function getCoprocessorSigners() view returns (address[])',
+    'function getThreshold() view returns (uint256)',
+];
+const getProvider = (config) => {
+    if (typeof config.network === 'string') {
+        return new JsonRpcProvider(config.network);
+    }
+    else if (config.network) {
+        return new BrowserProvider(config.network);
+    }
+    throw new Error('You must provide a network URL or a EIP1193 object (eg: window.ethereum)');
+};
+const getChainId = async (provider, config) => {
+    if (config.chainId && typeof config.chainId === 'number') {
+        return config.chainId;
+    }
+    else if (config.chainId && typeof config.chainId !== 'number') {
+        throw new Error('chainId must be a number.');
+    }
+    else {
+        const chainId = (await provider.getNetwork()).chainId;
+        return Number(chainId);
+    }
+};
+const getTfheCompactPublicKey = async (config) => {
+    if (config.relayerUrl && !config.publicKey) {
+        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
+        return { publicKey: inputs.publicKey, publicKeyId: inputs.publicKeyId };
+    }
+    else if (config.publicKey && config.publicKey.data && config.publicKey.id) {
+        const buff = config.publicKey.data;
+        try {
+            return {
+                publicKey: TFHE.TfheCompactPublicKey.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_PK),
+                publicKeyId: config.publicKey.id,
+            };
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    else {
+        throw new Error('You must provide a public key with its public key ID.');
+    }
+};
+const getPublicParams = async (config) => {
+    if (config.relayerUrl && !config.publicParams) {
+        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
+        return inputs.publicParams;
+    }
+    else if (config.publicParams && config.publicParams['2048']) {
+        const buff = config.publicParams['2048'].publicParams;
+        try {
+            return {
+                2048: {
+                    publicParams: TFHE.CompactPkeCrs.safe_deserialize(buff, SERIALIZED_SIZE_LIMIT_CRS),
+                    publicParamsId: config.publicParams['2048'].publicParamsId,
+                },
+            };
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    else {
+        throw new Error('You must provide a valid CRS with its CRS ID.');
+    }
+};
+const getKMSSigners = async (provider, config) => {
+    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
+    const signers = await kmsContract.getKmsSigners();
+    return signers;
+};
+const getKMSSignersThreshold = async (provider, config) => {
+    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
+    const threshold = await kmsContract.getThreshold();
+    return Number(threshold); // threshold is always supposed to fit in a number
+};
+const getCoprocessorSigners = async (provider, config) => {
+    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
+    const signers = await inputContract.getCoprocessorSigners();
+    return signers;
+};
+const getCoprocessorSignersThreshold = async (provider, config) => {
+    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
+    const threshold = await inputContract.getThreshold();
+    return Number(threshold); // threshold is always supposed to fit in a number
+};
+
 const NumEncryptedBits = {
     0: 2, // ebool
     2: 8, // euint8
@@ -26524,6 +26515,8 @@ function checkDeadlineValidity(startTimestamp, durationDays) {
 }
 const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays) => {
     // Casting handles if string
+    const signatureSanitized = signature.replace(/^(0x)/, '');
+    const publicKeySanitized = publicKey.replace(/^(0x)/, '');
     const handles = _handles.map((h) => ({
         handle: typeof h.handle === 'string'
             ? toHexString(fromHexString(h.handle), true)
@@ -26565,8 +26558,8 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
         contractsChainId: chainId.toString(), // Convert to string
         contractAddresses: contractAddresses.map((c) => getAddress(c)),
         userAddress: getAddress(userAddress),
-        signature: signature.replace(/^(0x)/, ''),
-        publicKey: publicKey.replace(/^(0x)/, ''),
+        signature: signatureSanitized,
+        publicKey: publicKeySanitized,
     };
     const options = {
         method: 'POST',
@@ -26578,8 +26571,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 });
@@ -26610,9 +26603,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);
@@ -26626,13 +26619,13 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
             salt: null,
         };
         const payloadForVerification = {
-            signature,
+            signature: signatureSanitized,
             client_address: userAddress,
-            enc_key: publicKey.replace(/^0x/, ''),
+            enc_key: publicKeySanitized,
             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;
@@ -26667,7 +26660,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) {
@@ -26798,7 +26791,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;
         },
@@ -26844,9 +26837,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;
@@ -27198,7 +27191,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)) {
@@ -27227,7 +27220,7 @@ const createEIP712 = (gatewayChainId, verifyingContract, contractsChainId) => (p
     const domain = {
         name: 'Decryption',
         version: '1',
-        chainId: gatewayChainId,
+        chainId: contractsChainId,
         verifyingContract,
     };
     if (delegatedAccount) {
@@ -27281,14 +27274,34 @@ 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)),
     };
 };
 
 global.fetch = fetchRetry(global.fetch, { retries: 5, retryDelay: 500 });
+const SepoliaConfig = {
+    // ACL_CONTRACT_ADDRESS (FHEVM Host chain)
+    aclContractAddress: '0x687820221192C5B662b25367F70076A37bc79b6c',
+    // KMS_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
+    kmsContractAddress: '0x1364cBBf2cDF5032C47d8226a6f6FBD2AFCDacAC',
+    // INPUT_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
+    inputVerifierContractAddress: '0xbc91f3daD1A5F19F8390c400196e58073B6a0BC4',
+    // DECRYPTION_ADDRESS (Gateway chain)
+    verifyingContractAddressDecryption: '0xb6E160B1ff80D67Bfe90A85eE06Ce0A2613607D1',
+    // INPUT_VERIFICATION_ADDRESS (Gateway chain)
+    verifyingContractAddressInputVerification: '0x7048C39f048125eDa9d678AEbaDfB22F7900a29F',
+    // FHEVM Host chain id
+    chainId: 11155111,
+    // Gateway chain id
+    gatewayChainId: 55815,
+    // Optional RPC provider to host chain
+    network: 'https://eth-sepolia.public.blastapi.io',
+    // Relayer URL
+    relayerUrl: 'https://relayer.testnet.zama.cloud',
+};
 const createInstance = async (config) => {
     const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, kmsContractAddress, aclContractAddress, gatewayChainId, } = config;
     if (!kmsContractAddress || !isAddress(kmsContractAddress)) {
@@ -27321,7 +27334,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
@@ -27365,4 +27378,26 @@ const initFhevm = async ({ tfheParams, kmsParams, thread, } = {}) => {
     return true;
 };
 
-export { ENCRYPTION_TYPES, createEIP712, createInstance, generateKeypair, initFhevm };
+// ESM explicit named re-export is required.
+window.TFHE = {
+    default: __wbg_init$1,
+    initThreadPool,
+    init_panic_hook,
+    TfheCompactPublicKey: TfheCompactPublicKey,
+    CompactPkeCrs: CompactPkeCrs,
+    CompactCiphertextList: CompactCiphertextList,
+    ZkComputeLoad: ZkComputeLoad,
+};
+window.TKMS = {
+    default: __wbg_init,
+    u8vec_to_ml_kem_pke_pk,
+    u8vec_to_ml_kem_pke_sk,
+    new_client,
+    process_user_decryption_resp_from_js,
+    ml_kem_pke_keygen,
+    ml_kem_pke_pk_to_u8vec,
+    ml_kem_pke_sk_to_u8vec,
+    ml_kem_pke_get_pk,
+};
+
+export { ENCRYPTION_TYPES, SepoliaConfig, createEIP712, createInstance, generateKeypair, initFhevm };