@zama-fhe/relayer-sdk 0.1.0 → 0.1.1

package/lib/node.cjs

@@ -44,7 +44,9 @@ const fromHexString = (hexString) => {
         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'), '')}`;
+function toHexString(bytes, with0x = false) {
+    return `${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);
@@ -55,95 +57,370 @@ const bytesToBigInt = function (byteArray) {
     return BigInt(`0x${hex}`);
 };
 
-const keyurlCache = {};
-const getKeysFromRelayer = async (url, publicKeyId) => {
-    if (keyurlCache[url]) {
-        return keyurlCache[url];
+function getErrorCause(e) {
+    if (e instanceof Error && typeof e.cause === 'object' && e.cause !== null) {
+        return e.cause;
     }
-    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());
+    return undefined;
+}
+function getErrorCauseCode(e) {
+    const cause = getErrorCause(e);
+    if (!cause || !('code' in cause) || !cause.code) {
+        return undefined;
+    }
+    if (typeof cause.code !== 'string') {
+        return undefined;
+    }
+    return cause.code;
+}
+function getErrorCauseStatus(e) {
+    const cause = getErrorCause(e);
+    if (!cause || !('status' in cause) || cause.status === undefined) {
+        return undefined;
+    }
+    if (typeof cause.status !== 'number') {
+        return undefined;
+    }
+    return cause.status;
+}
+async function throwRelayerResponseError(operation, response) {
+    let message;
+    // Special case for 429
+    if (response.status === 429) {
+        message = `Relayer rate limit exceeded: Please wait and try again later.`;
+    }
+    else {
+        switch (operation) {
+            case 'PUBLIC_DECRYPT': {
+                message = `Public decrypt failed: relayer respond with HTTP code ${response.status}`;
+                break;
             }
-            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}`);
+            case 'USER_DECRYPT': {
+                message = `User decrypt failed: relayer respond with HTTP code ${response.status}`;
+                break;
             }
-            let publicParams2048;
-            if (typeof publicParams2048Response.bytes === 'function') {
-                // bytes is not widely supported yet
-                publicParams2048 = await publicParams2048Response.bytes();
+            case 'KEY_URL': {
+                message = `HTTP error! status: ${response.status}`;
+                break;
             }
-            else {
-                publicParams2048 = new Uint8Array(await publicParams2048Response.arrayBuffer());
+            default: {
+                const responseText = await response.text();
+                message = `Relayer didn't response correctly. Bad status ${response.statusText}. Content: ${responseText}`;
+                break;
             }
-            let pub_key;
-            try {
-                pub_key = TFHE.TfheCompactPublicKey.safe_deserialize(publicKey, SERIALIZED_SIZE_LIMIT_PK);
+        }
+    }
+    const cause = {
+        code: 'RELAYER_FETCH_ERROR',
+        operation,
+        status: response.status,
+        statusText: response.statusText,
+        url: response.url,
+    };
+    throw new Error(message, {
+        cause,
+    });
+}
+function throwRelayerJSONError(operation, error) {
+    let message;
+    switch (operation) {
+        case 'PUBLIC_DECRYPT': {
+            message = "Public decrypt failed: Relayer didn't return a JSON";
+            break;
+        }
+        case 'USER_DECRYPT': {
+            message = "User decrypt failed: Relayer didn't return a JSON";
+            break;
+        }
+        default: {
+            message = "Relayer didn't return a JSON";
+            break;
+        }
+    }
+    const cause = {
+        code: 'RELAYER_NO_JSON_ERROR',
+        operation,
+        error,
+    };
+    throw new Error(message, {
+        cause,
+    });
+}
+function throwRelayerUnexpectedJSONError(operation, error) {
+    let message;
+    switch (operation) {
+        case 'PUBLIC_DECRYPT': {
+            message =
+                'Public decrypt failed: Relayer returned an unexpected JSON response';
+            break;
+        }
+        case 'USER_DECRYPT': {
+            message =
+                'User decrypt failed: Relayer returned an unexpected JSON response';
+            break;
+        }
+        default: {
+            message = 'Relayer returned an unexpected JSON response';
+            break;
+        }
+    }
+    const cause = {
+        code: 'RELAYER_UNEXPECTED_JSON_ERROR',
+        operation,
+        error,
+    };
+    throw new Error(message, {
+        cause,
+    });
+}
+function throwRelayerInternalError(operation, json) {
+    let message;
+    switch (operation) {
+        case 'PUBLIC_DECRYPT': {
+            message =
+                "Pulbic decrypt failed: the public decryption didn't succeed for an unknown reason";
+            break;
+        }
+        case 'USER_DECRYPT': {
+            message =
+                "User decrypt failed: the user decryption didn't succeed for an unknown reason";
+            break;
+        }
+        default: {
+            message = "Relayer didn't response correctly.";
+            break;
+        }
+    }
+    const cause = {
+        code: 'RELAYER_INTERNAL_ERROR',
+        operation,
+        error: json,
+    };
+    throw new Error(message, {
+        cause,
+    });
+}
+function throwRelayerUnknownError(operation, error, message) {
+    if (!message) {
+        switch (operation) {
+            case 'PUBLIC_DECRYPT': {
+                message = "Public decrypt failed: Relayer didn't respond";
+                break;
             }
-            catch (e) {
-                throw new Error('Invalid public key (deserialization failed)', {
-                    cause: e,
-                });
+            case 'USER_DECRYPT': {
+                message = "User decrypt failed: Relayer didn't respond";
+                break;
             }
-            let crs;
-            try {
-                crs = TFHE.CompactPkeCrs.safe_deserialize(new Uint8Array(publicParams2048), SERIALIZED_SIZE_LIMIT_CRS);
+            default: {
+                message = "Relayer didn't response correctly. Bad JSON.";
+                break;
             }
-            catch (e) {
-                throw new Error('Invalid crs (deserialization failed)', {
-                    cause: e,
-                });
+        }
+    }
+    const cause = {
+        code: 'RELAYER_UNKNOWN_ERROR',
+        operation,
+        error,
+    };
+    throw new Error(message ?? "Relayer didn't response correctly.", {
+        cause,
+    });
+}
+
+function assertIsRelayerFetchResponseJson(json) {
+    if (!json || typeof json !== 'object') {
+        throw new Error('Unexpected response JSON.');
+    }
+    if (!('response' in json &&
+        json.response !== null &&
+        json.response !== undefined)) {
+        throw new Error("Unexpected response JSON format: missing 'response' property.");
+    }
+}
+async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options) {
+    const init = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(options?.apiKey && { 'x-api-key': options.apiKey }),
+        },
+        body: JSON.stringify(payload),
+    };
+    let response;
+    let json;
+    try {
+        response = await fetch(url, init);
+    }
+    catch (e) {
+        throwRelayerUnknownError(relayerOperation, e);
+    }
+    if (!response.ok) {
+        await throwRelayerResponseError(relayerOperation, response);
+    }
+    let parsed;
+    try {
+        parsed = await response.json();
+    }
+    catch (e) {
+        throwRelayerJSONError(relayerOperation, e);
+    }
+    try {
+        assertIsRelayerFetchResponseJson(parsed);
+        json = parsed;
+    }
+    catch (e) {
+        throwRelayerUnexpectedJSONError(relayerOperation, e);
+    }
+    return json;
+}
+async function fetchRelayerGet(relayerOperation, url) {
+    let response;
+    let json;
+    try {
+        response = await fetch(url);
+    }
+    catch (e) {
+        throwRelayerUnknownError(relayerOperation, e);
+    }
+    if (!response.ok) {
+        await throwRelayerResponseError(relayerOperation, response);
+    }
+    let parsed;
+    try {
+        parsed = await response.json();
+    }
+    catch (e) {
+        throwRelayerJSONError(relayerOperation, e);
+    }
+    try {
+        assertIsRelayerFetchResponseJson(parsed);
+        json = parsed;
+    }
+    catch (e) {
+        throwRelayerUnexpectedJSONError(relayerOperation, e);
+    }
+    return json;
+}
+
+// export type RelayerKeysItem = {
+//   data_id: string;
+//   param_choice: number;
+//   urls: string[];
+//   signatures: string[];
+// };
+// export type RelayerKey = {
+//   data_id: string;
+//   param_choice: number;
+//   signatures: string[];
+//   urls: string[];
+// };
+// export type RelayerKeys = {
+//   response: {
+//     fhe_key_info: {
+//       fhe_public_key: RelayerKey;
+//       fhe_server_key: RelayerKey;
+//     }[];
+//     verf_public_key: {
+//       key_id: string;
+//       server_id: number;
+//       verf_public_key_address: string;
+//       verf_public_key_url: string;
+//     }[];
+//     crs: {
+//       [key: string]: RelayerKeysItem;
+//     };
+//   };
+//   status: string;
+// };
+const keyurlCache = {};
+const getKeysFromRelayer = async (url, publicKeyId) => {
+    if (keyurlCache[url]) {
+        return keyurlCache[url];
+    }
+    const data = await fetchRelayerGet('KEY_URL', `${url}/v1/keyurl`);
+    try {
+        // const response = await fetch(`${url}/v1/keyurl`);
+        // if (!response.ok) {
+        //   await throwRelayerResponseError("KEY_URL", response);
+        // }
+        //const data: RelayerKeys = 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}`);
             }
-            const result = {
-                publicKey: pub_key,
-                publicKeyId,
-                publicParams: {
-                    2048: {
-                        publicParams: crs,
-                        publicParamsId,
-                    },
-                },
-            };
-            keyurlCache[url] = result;
-            return result;
+            // 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 {
-            throw new Error('No public key available');
+            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.', {
@@ -259,9 +536,6 @@ const NumEncryptedBits = {
     6: 128, // euint128
     7: 160, // eaddress
     8: 256, // euint256
-    9: 512, // ebytes64
-    10: 1024, // ebytes128
-    11: 2048, // ebytes256
 };
 function checkEncryptedBits(handles) {
     let total = 0;
@@ -284,6 +558,8 @@ function checkEncryptedBits(handles) {
     return total;
 }
 
+// Add type checking
+const getAddress$1 = (value) => ethers.getAddress(value);
 const aclABI$1 = [
     'function persistAllowed(bytes32 handle, address account) view returns (bool)',
 ];
@@ -296,7 +572,7 @@ function formatAccordingToType(decryptedBigInt, type) {
     }
     else if (type === 7) {
         // eaddress
-        return ethers.getAddress('0x' + decryptedBigInt.toString(16).padStart(40, '0'));
+        return getAddress$1('0x' + decryptedBigInt.toString(16).padStart(40, '0'));
     }
     else if (type === 9) {
         // ebytes64
@@ -339,7 +615,16 @@ function checkDeadlineValidity(startTimestamp, durationDays) {
         throw Error('User decrypt request has expired');
     }
 }
-const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays) => {
+const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider, options) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays) => {
+    let pubKey;
+    let privKey;
+    try {
+        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 });
+    }
     // Casting handles if string
     const signatureSanitized = signature.replace(/^(0x)/, '');
     const publicKeySanitized = publicKey.replace(/^(0x)/, '');
@@ -347,7 +632,7 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
         handle: typeof h.handle === 'string'
             ? toHexString(fromHexString(h.handle), true)
             : toHexString(h.handle, true),
-        contractAddress: h.contractAddress,
+        contractAddress: getAddress$1(h.contractAddress),
     }));
     checkEncryptedBits(handles.map((h) => h.handle));
     checkDeadlineValidity(BigInt(startTimestamp), BigInt(durationDays));
@@ -382,51 +667,12 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
             durationDays: durationDays.toString(), // Convert to string
         },
         contractsChainId: chainId.toString(), // Convert to string
-        contractAddresses: contractAddresses.map((c) => ethers.getAddress(c)),
-        userAddress: ethers.getAddress(userAddress),
+        contractAddresses: contractAddresses.map((c) => getAddress$1(c)),
+        userAddress: getAddress$1(userAddress),
         signature: signatureSanitized,
         publicKey: publicKeySanitized,
     };
-    const options = {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(payloadForRequest),
-    };
-    let pubKey;
-    let privKey;
-    try {
-        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 });
-    }
-    let response;
-    let json;
-    try {
-        response = await fetch(`${relayerUrl}/v1/user-decrypt`, options);
-        if (!response.ok) {
-            throw new Error(`User decrypt failed: relayer respond with HTTP code ${response.status}`);
-        }
-    }
-    catch (e) {
-        throw new Error("User decrypt failed: Relayer didn't respond", {
-            cause: e,
-        });
-    }
-    try {
-        json = await response.json();
-    }
-    catch (e) {
-        throw new Error("User decrypt failed: Relayer didn't return a JSON", {
-            cause: e,
-        });
-    }
-    if (json.status === 'failure') {
-        throw new Error("User decrypt failed: the user decryption didn't succeed for an unknown reason", { cause: json });
-    }
+    const json = await fetchRelayerJsonRpcPost('USER_DECRYPT', `${relayerUrl}/v1/user-decrypt`, payloadForRequest, options);
     // assume the KMS Signers have the correct order
     let indexedKmsSigners = kmsSigners.map((signer, index) => {
         return TKMS.new_server_id_addr(index + 1, signer);
@@ -673,6 +919,8 @@ const computeHandles = (ciphertextWithZKProof, bitwidths, aclContractAddress, ch
     return handles;
 };
 
+// Add type checking
+const getAddress = (value) => ethers.getAddress(value);
 const currentCiphertextVersion = () => {
     return 0;
 };
@@ -692,6 +940,20 @@ function isThresholdReached$1(coprocessorSigners, recoveredAddresses, threshold)
     }
     return recoveredAddresses.length >= threshold;
 }
+function isFhevmRelayerInputProofResponse(json) {
+    const response = json.response;
+    if (typeof response !== 'object' || response === null) {
+        return false;
+    }
+    if (!('handles' in response && Array.isArray(response.handles))) {
+        return false;
+    }
+    if (!('signatures' in response && Array.isArray(response.signatures))) {
+        return false;
+    }
+    return (response.signatures.every((s) => typeof s === 'string') &&
+        response.handles.every((h) => typeof h === 'string'));
+}
 const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerUrl, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners) => (contractAddress, userAddress) => {
     if (!ethers.isAddress(contractAddress)) {
         throw new Error('Contract address is not a valid address.');
@@ -737,18 +999,6 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
             input.add256(value);
             return this;
         },
-        addBytes64(value) {
-            input.addBytes64(value);
-            return this;
-        },
-        addBytes128(value) {
-            input.addBytes128(value);
-            return this;
-        },
-        addBytes256(value) {
-            input.addBytes256(value);
-            return this;
-        },
         addAddress(value) {
             input.addAddress(value);
             return this;
@@ -756,43 +1006,18 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
         getBits() {
             return input.getBits();
         },
-        encrypt: async () => {
+        encrypt: async (options) => {
             const bits = input.getBits();
             const ciphertext = input.encrypt();
-            // https://github.com/zama-ai/fhevm-relayer/blob/978b08f62de060a9b50d2c6cc19fd71b5fb8d873/src/input_http_listener.rs#L13C1-L22C1
             const payload = {
-                contractAddress: ethers.getAddress(contractAddress),
-                userAddress: ethers.getAddress(userAddress),
+                contractAddress: getAddress(contractAddress),
+                userAddress: getAddress(userAddress),
                 ciphertextWithInputVerification: toHexString(ciphertext),
-                contractChainId: '0x' + chainId.toString(16),
+                contractChainId: ('0x' + chainId.toString(16)),
             };
-            const options = {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(payload),
-            };
-            const url = `${relayerUrl}/v1/input-proof`;
-            let json;
-            try {
-                const response = await fetch(url, options);
-                if (!response.ok) {
-                    throw new Error(`Relayer didn't response correctly. Bad status ${response.statusText}. Content: ${await response.text()}`);
-                }
-                try {
-                    json = await response.json();
-                }
-                catch (e) {
-                    throw new Error("Relayer didn't response correctly. Bad JSON.", {
-                        cause: e,
-                    });
-                }
-            }
-            catch (e) {
-                throw new Error("Relayer didn't response correctly.", {
-                    cause: e,
-                });
+            const json = await fetchRelayerJsonRpcPost('INPUT_PROOF', `${relayerUrl}/v1/input-proof`, payload, options);
+            if (!isFhevmRelayerInputProofResponse(json)) {
+                throwRelayerInternalError('INPUT_PROOF', json);
             }
             const handles = computeHandles(ciphertext, bits, aclContractAddress, chainId, currentCiphertextVersion());
             // Note that the hex strings returned by the relayer do have have the 0x prefix
@@ -884,9 +1109,6 @@ const CiphertextType = {
     6: 'uint256',
     7: 'address',
     8: 'uint256',
-    9: 'bytes',
-    10: 'bytes',
-    11: 'bytes',
 };
 function deserializeDecryptedResult(handles, decryptedResult) {
     let typesList = [];
@@ -911,7 +1133,7 @@ function deserializeDecryptedResult(handles, decryptedResult) {
     handles.forEach((handle, idx) => (results[handle] = rawValues[idx]));
     return results;
 }
-const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider) => async (_handles) => {
+const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider, options) => async (_handles) => {
     const acl = new ethers.ethers.Contract(aclContractAddress, aclABI, provider);
     let handles;
     try {
@@ -929,51 +1151,12 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
     catch (e) {
         throw e;
     }
-    const verifications = handles.map(async (ctHandle) => {
-        const isAllowedForDecryption = await acl.isAllowedForDecryption(ctHandle);
-        if (!isAllowedForDecryption) {
-            throw new Error(`Handle ${ctHandle} is not allowed for public decryption!`);
-        }
-    });
-    await Promise.all(verifications).catch((e) => {
-        throw e;
-    });
     // check 2048 bits limit
     checkEncryptedBits(handles);
     const payloadForRequest = {
         ciphertextHandles: handles,
     };
-    const options = {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(payloadForRequest),
-    };
-    let response;
-    let json;
-    try {
-        response = await fetch(`${relayerUrl}/v1/public-decrypt`, options);
-        if (!response.ok) {
-            throw new Error(`Public decrypt failed: relayer respond with HTTP code ${response.status}`);
-        }
-    }
-    catch (e) {
-        throw new Error("Public decrypt failed: Relayer didn't respond", {
-            cause: e,
-        });
-    }
-    try {
-        json = await response.json();
-    }
-    catch (e) {
-        throw new Error("Public decrypt failed: Relayer didn't return a JSON", {
-            cause: e,
-        });
-    }
-    if (json.status === 'failure') {
-        throw new Error("Public decrypt failed: the public decrypt didn't succeed for an unknown reason", { cause: json });
-    }
+    const json = await fetchRelayerJsonRpcPost('PUBLIC_DECRYPT', `${relayerUrl}/v1/public-decrypt`, payloadForRequest, options);
     // verify signatures on decryption:
     const domain = {
         name: 'Decryption',
@@ -1208,3 +1391,5 @@ exports.createInstance = createInstance;
 exports.createTfheKeypair = createTfheKeypair;
 exports.createTfhePublicKey = createTfhePublicKey;
 exports.generateKeypair = generateKeypair;
+exports.getErrorCauseCode = getErrorCauseCode;
+exports.getErrorCauseStatus = getErrorCauseStatus;