@zama-fhe/relayer-sdk 0.4.0-alpha.0 → 0.4.0-alpha.2

package/lib/node.js

@@ -1,37 +1,15 @@
 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, getAddress as getAddress$2, ethers, isAddress as isAddress$1, keccak256, AbiCoder } from 'ethers';
+import { JsonRpcProvider, BrowserProvider, Contract, getAddress as getAddress$2, isAddress as isAddress$1, keccak256, ethers, AbiCoder } from 'ethers';
 
 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);
 
-function setAuth(init, auth) {
-    if (auth) {
-        switch (auth.__type) {
-            case 'BearerToken':
-                init.headers['Authorization'] =
-                    `Bearer ${auth.token}`;
-                break;
-            case 'ApiKeyHeader':
-                init.headers[auth.header || 'x-api-key'] =
-                    auth.value;
-                break;
-            case 'ApiKeyCookie':
-                if (typeof window !== 'undefined') {
-                    document.cookie = `${auth.cookie || 'x-api-key'}=${auth.value}; path=/; SameSite=Lax; Secure; HttpOnly;`;
-                    init.credentials = 'include';
-                }
-                else {
-                    let cookie = `${auth.cookie || 'x-api-key'}=${auth.value};`;
-                    init.headers['Cookie'] = cookie;
-                }
-                break;
-        }
-    }
-    return init;
-}
+// This file is auto-generated
+const version = '0.4.0-alpha.2';
+const sdkName = '@zama-fhe/relayer-sdk';
 
 function getErrorCause(e) {
     if (e instanceof Error && typeof e.cause === 'object' && e.cause !== null) {
@@ -213,7 +191,39 @@ function throwRelayerUnknownError(operation, error, message) {
     });
 }
 
-////////////////////////////////////////////////////////////////////////////////
+/**
+ * Set the authentication method for the request. The default is no authentication.
+ * It supports:
+ * - Bearer Token
+ * - Custom header
+ * - Custom cookie
+ */
+function setAuth(init, auth) {
+    if (auth) {
+        switch (auth.__type) {
+            case 'BearerToken':
+                init.headers['Authorization'] =
+                    `Bearer ${auth.token}`;
+                break;
+            case 'ApiKeyHeader':
+                init.headers[auth.header || 'x-api-key'] =
+                    auth.value;
+                break;
+            case 'ApiKeyCookie':
+                if (typeof window !== 'undefined') {
+                    document.cookie = `${auth.cookie || 'x-api-key'}=${auth.value}; path=/; SameSite=Lax; Secure; HttpOnly;`;
+                    init.credentials = 'include';
+                }
+                else {
+                    let cookie = `${auth.cookie || 'x-api-key'}=${auth.value};`;
+                    init.headers['Cookie'] = cookie;
+                }
+                break;
+        }
+    }
+    return init;
+}
+
 function assertIsRelayerV1FetchResponseJson(json) {
     if (!json || typeof json !== 'object') {
         throw new Error('Unexpected response JSON.');
@@ -224,11 +234,13 @@ function assertIsRelayerV1FetchResponseJson(json) {
         throw new Error("Unexpected response JSON format: missing 'response' property.");
     }
 }
-async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options) {
+async function fetchRelayerV1Post(relayerOperation, url, payload, options) {
     const init = setAuth({
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
+            'ZAMA-SDK-VERSION': `${version}`,
+            'ZAMA-SDK-NAME': `${sdkName}`,
         },
         body: JSON.stringify(payload),
     }, options?.auth);
@@ -259,14 +271,20 @@ async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options)
     }
     return json;
 }
-async function fetchRelayerGet(relayerOperation, url) {
+async function fetchRelayerV1Get(relayerOperation, url) {
+    const init = {
+        method: 'GET',
+        headers: {
+            'ZAMA-SDK-VERSION': `${version}`,
+            'ZAMA-SDK-NAME': `${sdkName}`,
+        },
+    };
     let response;
     let json;
     try {
-        response = await fetch(url);
+        response = await fetch(url, init);
     }
     catch (e) {
-        console.log(e);
         throwRelayerUnknownError(relayerOperation, e);
     }
     if (!response.ok) {
@@ -294,7 +312,7 @@ const getKeysFromRelayer = async (versionUrl, publicKeyId) => {
     if (keyurlCache[versionUrl]) {
         return keyurlCache[versionUrl];
     }
-    const data = await fetchRelayerGet('KEY_URL', `${versionUrl}/keyurl`);
+    const data = await fetchRelayerV1Get('KEY_URL', `${versionUrl}/keyurl`);
     try {
         let pubKeyUrl;
         // If no publicKeyId is provided, use the first one
@@ -383,7 +401,7 @@ class RelayerErrorBase extends Error {
     _docsPath;
     _docsUrl;
     _version;
-    static VERSION = '0.3.0-6';
+    static VERSION = version;
     static DEFAULT_DOCS_BASE_URL = 'https//docs.zama.org';
     static FULL_VERSION = `@zama-fhe/relayer-sdk@${RelayerErrorBase.VERSION}`;
     constructor(params) {
@@ -792,6 +810,14 @@ function assertRecordStringArrayProperty(o, property, objName) {
         }
     }
 }
+function safeJSONstringify(o, space) {
+    try {
+        return JSON.stringify(o, (_, v) => (typeof v === 'bigint' ? v.toString() : v), space);
+    }
+    catch {
+        return '';
+    }
+}
 
 const abiKmsVerifier = [
     'function getKmsSigners() view returns (address[])',
@@ -891,6 +917,7 @@ const getCoprocessorSignersThreshold = async (provider, inputVerifierContractAdd
     return Number(threshold); // threshold is always supposed to fit in a number
 };
 
+// This file contains common utilities for both user and public decryption requests
 const NumEncryptedBits = {
     0: 2, // ebool
     2: 8, // euint8
@@ -901,17 +928,17 @@ const NumEncryptedBits = {
     7: 160, // eaddress
     8: 256, // euint256
 };
-function getHandleType(handle) {
-    if (handle.length !== 66) {
-        throw new Error(`Handle ${handle} is not of valid length`);
-    }
-    const hexPair = handle.slice(-4, -2).toLowerCase();
-    const typeDiscriminant = parseInt(hexPair, 16);
-    if (!(typeDiscriminant in NumEncryptedBits)) {
-        throw new Error(`Handle ${handle} is not of valid type`);
-    }
-    return typeDiscriminant;
-}
+// export function getHandleType(handle: `0x${string}`): number {
+//   if (handle.length !== 66) {
+//     throw new Error(`Handle ${handle} is not of valid length`);
+//   }
+//   const hexPair = handle.slice(-4, -2).toLowerCase();
+//   const typeDiscriminant = parseInt(hexPair, 16);
+//   if (!(typeDiscriminant in NumEncryptedBits)) {
+//     throw new Error(`Handle ${handle} is not of valid type`);
+//   }
+//   return typeDiscriminant;
+// }
 function checkEncryptedBits(handles) {
     let total = 0;
     for (const handle of handles) {
@@ -969,7 +996,7 @@ function isBytes(value, bytewidth) {
     if (!(value instanceof Uint8Array)) {
         return false;
     }
-    return value.length === bytewidth ;
+    return bytewidth ? value.length === bytewidth : true;
 }
 function isBytesHex(value, bytewidth) {
     if (!is0x(value)) {
@@ -1202,6 +1229,54 @@ function assertUint8ArrayProperty(o, property, objName) {
         });
     }
 }
+////////////////////////////////////////////////////////////////////////////////
+// Hex
+////////////////////////////////////////////////////////////////////////////////
+const HEX_CHARS = {
+    '0': 0,
+    '1': 1,
+    '2': 2,
+    '3': 3,
+    '4': 4,
+    '5': 5,
+    '6': 6,
+    '7': 7,
+    '8': 8,
+    '9': 9,
+    a: 10,
+    b: 11,
+    c: 12,
+    d: 13,
+    e: 14,
+    f: 15,
+    A: 10,
+    B: 11,
+    C: 12,
+    D: 13,
+    E: 14,
+    F: 15,
+};
+Object.freeze(HEX_CHARS);
+const HEX_BYTES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+Object.freeze(HEX_BYTES);
+const HEX_CHARS_CODES = new Uint8Array([
+    48,
+    49,
+    50,
+    51,
+    52,
+    53,
+    54,
+    55,
+    56,
+    57, // '0'-'9'
+    97,
+    98,
+    99,
+    100,
+    101,
+    102, // 'a'-'f'
+]);
 /**
  * Convert a Uint8Array to a hex string (without 0x prefix).
  */
@@ -1221,15 +1296,49 @@ function bytesToHexNo0x(bytes) {
 function bytesToHex(bytes) {
     return `0x${bytesToHexNo0x(bytes)}`;
 }
+function bytesToHexLarge(bytes) {
+    const out = new Uint8Array(2 + bytes.length * 2);
+    out[0] = 48; // '0'
+    out[1] = 120; // 'x'
+    for (let i = 0; i < bytes.length; i++) {
+        const j = 2 + i * 2;
+        out[j] = HEX_CHARS_CODES[bytes[i] >> 4];
+        out[j + 1] = HEX_CHARS_CODES[bytes[i] & 0xf];
+    }
+    return new TextDecoder().decode(out);
+}
 /**
  * Convert a hex string prefixed by 0x or not to a Uint8Array
+ * Any invalid byte string is converted to 0
+ * "0xzzff" = [0, 255]
+ * "0xzfff" = [0, 255]
  */
 function hexToBytes(hexString) {
+    if (hexString.length % 2 !== 0) {
+        throw new Error('Invalid hex string: odd length');
+    }
     const arr = hexString.replace(/^(0x)/, '').match(/.{1,2}/g);
     if (!arr)
         return new Uint8Array();
     return Uint8Array.from(arr.map((byte) => parseInt(byte, 16)));
 }
+function hexToBytesFaster(hexString, strict = false) {
+    const offset = hexString[0] === '0' && hexString[1] === 'x' ? 2 : 0;
+    const len = hexString.length - offset;
+    if (len % 2 !== 0) {
+        throw new Error('Invalid hex string: odd length');
+    }
+    const bytes = new Uint8Array(len / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        const hi = HEX_CHARS[hexString[offset + i * 2]];
+        const lo = HEX_CHARS[hexString[offset + i * 2 + 1]];
+        if ((hi === undefined || lo === undefined) && strict) {
+            throw new Error(`Invalid hex character at position ${offset + i * 2}`);
+        }
+        bytes[i] = (hi << 4) | lo;
+    }
+    return bytes;
+}
 /**
  * Convert a Uint8Array to a bigint
  */
@@ -1243,9 +1352,6 @@ function bytesToBigInt(byteArray) {
     }
     return result;
 }
-function toHexString(bytes, with0x = false) {
-    return `${with0x ? '0x' : ''}${bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')}`;
-}
 async function fetchBytes(url) {
     const response = await fetch(url);
     if (!response.ok) {
@@ -1321,9 +1427,7 @@ function checkDeadlineValidity(startTimestamp, durationDays) {
         throw Error('User decrypt request has expired');
     }
 }
-const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, 
-//relayerUrl: string,
-relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays, options) => {
+const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerProvider, provider, defaultOptions) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays, options) => {
     const extraData = '0x00';
     let pubKey;
     let privKey;
@@ -1337,16 +1441,16 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
     // Casting handles if string
     const signatureSanitized = signature.replace(/^(0x)/, '');
     const publicKeySanitized = publicKey.replace(/^(0x)/, '');
-    const handles = _handles.map((h) => ({
+    const handleContractPairs = _handles.map((h) => ({
         handle: typeof h.handle === 'string'
-            ? toHexString(hexToBytes(h.handle), true)
-            : toHexString(h.handle, true),
+            ? bytesToHex(hexToBytes(h.handle))
+            : bytesToHex(h.handle),
         contractAddress: getAddress$1(h.contractAddress),
     }));
-    checkEncryptedBits(handles.map((h) => h.handle));
+    checkEncryptedBits(handleContractPairs.map((h) => h.handle));
     checkDeadlineValidity(BigInt(startTimestamp), BigInt(durationDays));
-    const acl = new ethers.Contract(aclContractAddress, aclABI$1, provider);
-    const verifications = handles.map(async ({ handle, contractAddress }) => {
+    const acl = new Contract(aclContractAddress, aclABI$1, provider);
+    const verifications = handleContractPairs.map(async ({ handle, contractAddress }) => {
         const userAllowed = await acl.persistAllowed(handle, userAddress);
         const contractAllowed = await acl.persistAllowed(handle, contractAddress);
         if (!userAllowed) {
@@ -1370,7 +1474,7 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
         throw e;
     });
     const payloadForRequest = {
-        handleContractPairs: handles,
+        handleContractPairs,
         requestValidity: {
             startTimestamp: startTimestamp.toString(), // Convert to string
             durationDays: durationDays.toString(), // Convert to string
@@ -1382,13 +1486,10 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
         publicKey: publicKeySanitized,
         extraData,
     };
-    const json = await relayerProvider.fetchPostUserDecrypt(payloadForRequest, options ?? instanceOptions);
-    // const json = await fetchRelayerJsonRpcPost(
-    //   'USER_DECRYPT',
-    //   `${relayerUrl}/v1/user-decrypt`,
-    //   payloadForRequest,
-    //   instanceOptions ?? options,
-    // );
+    const json = await relayerProvider.fetchPostUserDecrypt(payloadForRequest, {
+        ...defaultOptions,
+        ...options,
+    });
     // assume the KMS Signers have the correct order
     let indexedKmsSigners = kmsSigners.map((signer, index) => {
         return TKMS.new_server_id_addr(index + 1, signer);
@@ -1410,13 +1511,13 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
             signature: signatureSanitized,
             client_address: userAddress,
             enc_key: publicKeySanitized,
-            ciphertext_handles: handles.map((h) => h.handle.replace(/^0x/, '')),
+            ciphertext_handles: handleContractPairs.map((h) => h.handle.replace(/^0x/, '')),
             eip712_verifying_contract: verifyingContractAddress,
         };
         const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json, //json.response,
         pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
-        const results = buildUserDecryptResults(handles.map((h) => h.handle), listBigIntDecryptions);
+        const results = buildUserDecryptResults(handleContractPairs.map((h) => h.handle), listBigIntDecryptions);
         return results;
     }
     catch (e) {
@@ -1559,9 +1660,8 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
 
 const MAX_UINT64 = BigInt('18446744073709551615'); // 2^64 - 1
 BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-const MAX_UINT32 = 0xffffffff;
 const MAX_UINT8 = 0xff;
-function numberToHex(num) {
+function numberToHexNo0x(num) {
     let hex = num.toString(16);
     return hex.length % 2 ? '0' + hex : hex;
 }
@@ -1595,25 +1695,19 @@ function isUint8(value) {
     }
     return value <= MAX_UINT8;
 }
-function isUint32(value) {
-    if (!isUint(value)) {
-        return false;
-    }
-    return value <= MAX_UINT32;
-}
 function isUint64(value) {
     if (!isUint(value)) {
         return false;
     }
     return value <= MAX_UINT64;
 }
-function uint32ToBytes32(uint32) {
-    if (!isUint32(uint32)) {
-        throw new InvalidTypeError({ expectedType: 'Uint32' });
+function numberToBytes32(num) {
+    if (!isUintNumber(num)) {
+        throw new InvalidTypeError({ expectedType: 'Uint' });
     }
     const buffer = new ArrayBuffer(32);
     const view = new DataView(buffer);
-    view.setUint32(28, Number(uint32), false);
+    view.setBigUint64(24, BigInt(num), false);
     return new Uint8Array(buffer);
 }
 function assertIsUint8(value) {
@@ -1708,47 +1802,216 @@ function checksummedAddressToBytes20(address) {
     return bytes;
 }
 
+class FhevmHandleError extends RelayerErrorBase {
+    constructor({ handle, message }) {
+        super({
+            message: message ??
+                (handle
+                    ? `FHEVM Handle "${handle}" is invalid.`
+                    : `FHEVM Handle is invalid.`),
+            name: 'FhevmHandleError',
+        });
+    }
+}
+
+class FheTypeError extends RelayerErrorBase {
+    constructor({ fheTypeId, message, }) {
+        super({
+            message: message ??
+                (fheTypeId
+                    ? `FheTypeId "${fheTypeId}" is invalid.`
+                    : `FheTypeId is invalid.`),
+            name: 'FheTypeError',
+        });
+    }
+}
+
+const FheTypeIdToName = {
+    0: 'ebool',
+    //1: 'euint4', has been deprecated
+    2: 'euint8',
+    3: 'euint16',
+    4: 'euint32',
+    5: 'euint64',
+    6: 'euint128',
+    7: 'eaddress',
+    8: 'euint256',
+};
+const FheTypeIdToEncryptionBitwidth = {
+    0: 2,
+    //1:?, euint4 has been deprecated
+    2: 8,
+    3: 16,
+    4: 32,
+    5: 64,
+    6: 128,
+    7: 160,
+    8: 256,
+};
+const EncryptionBitwidthToFheTypeId = {
+    2: 0,
+    //?:1, euint4 has been deprecated
+    8: 2,
+    16: 3,
+    32: 4,
+    64: 5,
+    128: 6,
+    160: 7,
+    256: 8,
+};
+const FheTypeIdToSolidityPrimitiveTypeName = {
+    0: 'bool',
+    //1:'uint256', euint4 has been deprecated
+    2: 'uint256',
+    3: 'uint256',
+    4: 'uint256',
+    5: 'uint256',
+    6: 'uint256',
+    7: 'address',
+    8: 'uint256',
+};
+Object.freeze(FheTypeIdToEncryptionBitwidth);
+Object.freeze(EncryptionBitwidthToFheTypeId);
+Object.freeze(FheTypeIdToSolidityPrimitiveTypeName);
+////////////////////////////////////////////////////////////////////////////////
+// Type Guards
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Checks if a value is a valid FheTypeId.
+ * @example isFheTypeId(2) // true (euint8)
+ * @example isFheTypeId(1) // false (euint4 is deprecated)
+ */
+function isFheTypeId(value) {
+    switch (value) {
+        case 0:
+        // 1: euint4 is deprecated
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Checks if a value is a valid encryption bit width.
+ * @example isEncryptionBits(8) // true
+ * @example isEncryptionBits(4) // false (euint4 is deprecated)
+ */
+function isEncryptionBits(value) {
+    if (typeof value !== 'number') {
+        return false;
+    }
+    return value in EncryptionBitwidthToFheTypeId;
+}
+////////////////////////////////////////////////////////////////////////////////
+// FheTypeId extractors
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Converts an encryption bit width to its corresponding FheTypeId.
+ * @throws {FheTypeError} If bitwidth is not a valid encryption bit width.
+ * @example fheTypeIdFromEncryptionBits(8) // 2 (euint8)
+ */
+function fheTypeIdFromEncryptionBits(bitwidth) {
+    if (!isEncryptionBits(bitwidth)) {
+        throw new FheTypeError({
+            message: `Invalid encryption bits ${bitwidth}`,
+        });
+    }
+    return EncryptionBitwidthToFheTypeId[bitwidth];
+}
+/**
+ * Converts an FheTypeId to its corresponding FheTypeName.
+ * @throws {FheTypeError} If id is not a valid FheTypeId.
+ * @example fheTypeNameFromId(2) // 'euint8'
+ */
+function fheTypeNameFromId(id) {
+    if (!isFheTypeId(id)) {
+        throw new FheTypeError({
+            message: `Invalid FheType id '${id}'`,
+        });
+    }
+    return FheTypeIdToName[id];
+}
+////////////////////////////////////////////////////////////////////////////////
+// Solidity primitive type names
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Returns the Solidity primitive type name for an FheTypeId.
+ * @example solidityPrimitiveTypeNameFromFheTypeId(0) // 'bool'
+ * @example solidityPrimitiveTypeNameFromFheTypeId(7) // 'address'
+ * @example solidityPrimitiveTypeNameFromFheTypeId(2) // 'uint256'
+ */
+function solidityPrimitiveTypeNameFromFheTypeId(typeId) {
+    if (!isFheTypeId(typeId)) {
+        throw new FheTypeError({
+            message: `Invalid FheType id '${typeId}'`,
+        });
+    }
+    return FheTypeIdToSolidityPrimitiveTypeName[typeId];
+}
+////////////////////////////////////////////////////////////////////////////////
+// Encryption Bits
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Returns the encryption bit width for an FheTypeId.
+ * @example encryptionBitsFromFheTypeId(2) // 8 (euint8)
+ * @example encryptionBitsFromFheTypeId(7) // 160 (eaddress)
+ */
+function encryptionBitsFromFheTypeId(typeId) {
+    if (!isFheTypeId(typeId)) {
+        throw new FheTypeError({
+            message: `Invalid FheType id '${typeId}'`,
+        });
+    }
+    return FheTypeIdToEncryptionBitwidth[typeId];
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // FhevmHandle
 ////////////////////////////////////////////////////////////////////////////////
 class FhevmHandle {
+    //////////////////////////////////////////////////////////////////////////////
+    // Instance Properties
+    //////////////////////////////////////////////////////////////////////////////
     _hash21;
     _chainId;
     _fheTypeId;
     _version;
     _computed;
     _index;
+    _handleBytes32Hex;
+    _handleBytes32;
+    //////////////////////////////////////////////////////////////////////////////
+    // Static Constants
+    //////////////////////////////////////////////////////////////////////////////
     static RAW_CT_HASH_DOMAIN_SEPARATOR = 'ZK-w_rct';
     static HANDLE_HASH_DOMAIN_SEPARATOR = 'ZK-w_hdl';
-    static FheTypeIdToEncryptionBitwidths = {
-        0: 2,
-        2: 8,
-        3: 16,
-        4: 32,
-        5: 64,
-        6: 128,
-        7: 160,
-        8: 256,
-    };
-    static FheTypeEncryptionBitwidthsToId = {
-        2: 0,
-        8: 2,
-        16: 3,
-        32: 4,
-        64: 5,
-        128: 6,
-        160: 7,
-        256: 8,
-    };
-    static {
-        Object.freeze(FhevmHandle.FheTypeIdToEncryptionBitwidths);
-        Object.freeze(FhevmHandle.FheTypeEncryptionBitwidthsToId);
-    }
-    constructor(hash21, chainId, fheTypeId, version, computed, index) {
+    static CURRENT_CIPHERTEXT_VERSION = 0;
+    //////////////////////////////////////////////////////////////////////////////
+    // Constructor
+    //////////////////////////////////////////////////////////////////////////////
+    constructor({ hash21, chainId, fheTypeId, version, computed, index, handleBytes32, handleBytes32Hex, }) {
+        if (!isUintNumber(chainId)) {
+            throw new FhevmHandleError({
+                message: 'ChainId must be a positive integer',
+            });
+        }
         if (BigInt(chainId) > MAX_UINT64) {
             // fhevm assumes chainID is only taking up to 8 bytes
-            throw new Error('ChainId exceeds maximum allowed value (8 bytes)');
+            throw new FhevmHandleError({
+                message: 'ChainId exceeds maximum allowed value (8 bytes)',
+            });
         }
+        if (!isBytesHex(hash21, 21)) {
+            throw new FhevmHandleError({ message: 'Hash21 should be 21 bytes long' });
+        }
+        this._handleBytes32 = handleBytes32;
+        this._handleBytes32Hex = handleBytes32Hex;
         this._hash21 = hash21;
         this._chainId = chainId;
         this._fheTypeId = fheTypeId;
@@ -1758,6 +2021,9 @@ class FhevmHandle {
             this._index = index;
         }
     }
+    //////////////////////////////////////////////////////////////////////////////
+    // Instance Getters
+    //////////////////////////////////////////////////////////////////////////////
     get hash21() {
         return this._hash21;
     }
@@ -1767,6 +2033,9 @@ class FhevmHandle {
     get fheTypeId() {
         return this._fheTypeId;
     }
+    get fheTypeName() {
+        return fheTypeNameFromId(this._fheTypeId);
+    }
     get version() {
         return this._version;
     }
@@ -1776,6 +2045,106 @@ class FhevmHandle {
     get index() {
         return this._index;
     }
+    get encryptedBitwidth() {
+        return encryptionBitsFromFheTypeId(this._fheTypeId);
+    }
+    get solidityPrimitiveTypeName() {
+        return solidityPrimitiveTypeNameFromFheTypeId(this._fheTypeId);
+    }
+    toJSON() {
+        return {
+            handle: this.toBytes32Hex(),
+            fheTypeName: this.fheTypeName,
+            fheTypeId: this.fheTypeId,
+            chainId: this.chainId,
+            index: this.index,
+            computed: this.computed,
+            encryptedBitwidth: this.encryptedBitwidth,
+            version: this.version,
+            solidityPrimitiveTypeName: this.solidityPrimitiveTypeName,
+            hash21: this.hash21,
+        };
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Instance Serialization
+    //////////////////////////////////////////////////////////////////////////////
+    toBytes32() {
+        if (this._handleBytes32 === undefined) {
+            assertRelayer((this._index === undefined && this._computed) ||
+                (this._index !== undefined && this._index < 255 && !this._computed));
+            const chainId32Bytes = numberToBytes32(this._chainId);
+            const chainId8Bytes = chainId32Bytes.subarray(24, 32);
+            const handleHash21 = hexToBytes(this._hash21);
+            assertRelayer(handleHash21.length === 21);
+            const handleBytes32AsBytes = new Uint8Array(32);
+            handleBytes32AsBytes.set(handleHash21, 0);
+            handleBytes32AsBytes[21] = this._index === undefined ? 255 : this._index;
+            handleBytes32AsBytes.set(chainId8Bytes, 22);
+            handleBytes32AsBytes[30] = this._fheTypeId;
+            handleBytes32AsBytes[31] = this._version;
+            this._handleBytes32 = handleBytes32AsBytes;
+        }
+        return this._handleBytes32;
+    }
+    toBytes32Hex() {
+        if (this._handleBytes32Hex === undefined) {
+            this._handleBytes32Hex = bytesToHex(this.toBytes32());
+        }
+        return this._handleBytes32Hex;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Static Factory Methods
+    //////////////////////////////////////////////////////////////////////////////
+    static fromComponents(params) {
+        return new FhevmHandle(params);
+    }
+    static fromBytes32(handle) {
+        if (!isBytes32(handle)) {
+            throw new FhevmHandleError({
+                message: `FHEVM Handle is not a valid bytes32 array.`,
+            });
+        }
+        const bytes = handle;
+        // Extract hash21 (bytes 0-20)
+        const hash21 = bytesToHex(bytes.slice(0, 21));
+        // Extract index (byte 21) - 255 means computed
+        const indexByte = bytes[21];
+        const computed = indexByte === 255;
+        const index = computed ? undefined : indexByte;
+        // Extract chainId (bytes 22-29, 8 bytes as big-endian uint64)
+        let chainId = 0;
+        for (let i = 22; i < 30; i++) {
+            chainId = chainId * 256 + bytes[i];
+        }
+        // Extract fheTypeId (byte 30)
+        const fheTypeIdByte = bytes[30];
+        if (!isFheTypeId(fheTypeIdByte)) {
+            throw new FhevmHandleError({
+                handle,
+                message: `FHEVM Handle "${handle}" is invalid. Unknown FheType: ${fheTypeIdByte}`,
+            });
+        }
+        // Extract version (byte 31)
+        const version = bytes[31];
+        return new FhevmHandle({
+            hash21,
+            chainId,
+            fheTypeId: fheTypeIdByte,
+            version,
+            computed,
+            index,
+            handleBytes32: handle,
+        });
+    }
+    static fromBytes32Hex(handle) {
+        if (!isBytes32Hex(handle)) {
+            throw new FhevmHandleError({ handle });
+        }
+        const bytes = hexToBytes(handle);
+        const h = FhevmHandle.fromBytes32(bytes);
+        h._handleBytes32Hex = handle;
+        return h;
+    }
     static fromZKProof(params) {
         assertIsChecksummedAddress(params.aclAddress);
         assertIsUint64(params.chainId);
@@ -1785,7 +2154,7 @@ class FhevmHandle {
             fheTypeIds = params.fheTypeIds;
         }
         else if (params.fheTypeEncryptionBitwidths !== undefined) {
-            fheTypeIds = params.fheTypeEncryptionBitwidths.map((w) => FhevmHandle.FheTypeEncryptionBitwidthsToId[w]);
+            fheTypeIds = params.fheTypeEncryptionBitwidths.map((w) => fheTypeIdFromEncryptionBits(w));
         }
         else {
             throw new InternalError({
@@ -1816,22 +2185,69 @@ class FhevmHandle {
         const handles = [];
         for (let i = 0; i < fheTypeIds.length; ++i) {
             const hash21 = FhevmHandle._computeInputHash21(hexToBytes(blobHashBytes32Hex), params.aclAddress, params.chainId, i);
-            handles.push(new FhevmHandle(hash21, params.chainId, fheTypeIds[i], params.ciphertextVersion, false, i));
+            handles.push(new FhevmHandle({
+                hash21,
+                chainId: params.chainId,
+                fheTypeId: fheTypeIds[i],
+                version: params.ciphertextVersion,
+                computed: false,
+                index: i,
+            }));
         }
         return handles;
     }
+    //////////////////////////////////////////////////////////////////////////////
+    // Static Parsing
+    //////////////////////////////////////////////////////////////////////////////
+    static parse(handle) {
+        if (isBytes(handle)) {
+            return FhevmHandle.fromBytes32(handle);
+        }
+        return FhevmHandle.fromBytes32Hex(handle);
+    }
+    static canParse(handle) {
+        try {
+            FhevmHandle.parse(handle);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Static Assertions
+    //////////////////////////////////////////////////////////////////////////////
+    static assertIsHandleHex(handle) {
+        if (typeof handle !== 'string') {
+            throw new FhevmHandleError({
+                message: 'Invalid bytes32 hexadecimal string',
+            });
+        }
+        if (!FhevmHandle.canParse(handle)) {
+            throw new FhevmHandleError({ handle });
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Static Helpers
+    //////////////////////////////////////////////////////////////////////////////
+    static currentCiphertextVersion() {
+        return FhevmHandle.CURRENT_CIPHERTEXT_VERSION;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Private Helpers
+    //////////////////////////////////////////////////////////////////////////////
     /**
      * blobHashBytes32 = keccak256(ciphertextWithZKProof)
      */
     static _computeInputHash21(blobHashBytes32, aclAddress, chainId, index) {
         /*
             https://github.com/zama-ai/fhevm/blob/8ffbd5906ab3d57af178e049930e3fc065c9d4b3/coprocessor/fhevm-engine/zkproof-worker/src/verifier.rs#L431C7-L431C8
-        
+    
             handle_hash = Bytes("ZK-w_hdl") + blobHash 32 Bytes + index 1 Byte + aclAddress 20 Bytes + chainId 32 bytes
             ===========================================================================================================
     
             const HANDLE_HASH_DOMAIN_SEPARATOR: [u8; 8] = *b"ZK-w_hdl";
-            
+    
             let mut handle_hash = Keccak256::new();
             handle_hash.update(HANDLE_HASH_DOMAIN_SEPARATOR);
             handle_hash.update(blob_hash);
@@ -1852,27 +2268,12 @@ class FhevmHandle {
         assertIsUint64(chainId);
         const encryptionIndexByte1 = new Uint8Array([index]);
         const aclContractAddressBytes20 = checksummedAddressToBytes20(aclAddress);
-        const chainIdBytes32 = uint32ToBytes32(chainId);
+        const chainIdBytes32 = numberToBytes32(chainId);
         const encoder = new TextEncoder();
         const domainSepBytes = encoder.encode(FhevmHandle.HANDLE_HASH_DOMAIN_SEPARATOR);
-        return keccak256(concatBytes(domainSepBytes, blobHashBytes32, encryptionIndexByte1, aclContractAddressBytes20, chainIdBytes32));
-    }
-    toBytes32() {
-        assertRelayer((this._index === undefined && this._computed) ||
-            (this._index !== undefined && this._index < 255 && !this._computed));
-        const chainId32Bytes = uint32ToBytes32(this._chainId);
-        const chainId8Bytes = chainId32Bytes.subarray(24, 32);
-        const handleHash = hexToBytes(this._hash21);
-        const handleBytes32AsBytes = new Uint8Array(32);
-        handleBytes32AsBytes.set(handleHash, 0);
-        handleBytes32AsBytes[21] = this._index === undefined ? 255 : this._index;
-        handleBytes32AsBytes.set(chainId8Bytes, 22);
-        handleBytes32AsBytes[30] = this._fheTypeId;
-        handleBytes32AsBytes[31] = this._version;
-        return handleBytes32AsBytes;
-    }
-    toBytes32Hex() {
-        return bytesToHex(this.toBytes32());
+        const hashBytes32Hex = keccak256(concatBytes(domainSepBytes, blobHashBytes32, encryptionIndexByte1, aclContractAddressBytes20, chainIdBytes32));
+        // Truncate to 21 bytes (0x + 42 hex chars)
+        return hashBytes32Hex.slice(0, 2 + 2 * 21);
     }
 }
 
@@ -1881,6 +2282,89 @@ const getAddress = (value) => getAddress$2(value);
 const currentCiphertextVersion = () => {
     return 0;
 };
+async function requestCiphertextWithZKProofVerification({ bits, ciphertext, contractAddress, userAddress, aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerProvider, coprocessorSigners, thresholdCoprocessorSigners, extraData, options, }) {
+    const payload = {
+        contractAddress,
+        userAddress,
+        ciphertextWithInputVerification: bytesToHexNo0x(ciphertext),
+        contractChainId: ('0x' + chainId.toString(16)),
+        extraData,
+    };
+    const json = await relayerProvider.fetchPostInputProof(payload, options);
+    if (!isFhevmRelayerInputProofResponse(json)) {
+        throwRelayerInternalError('INPUT_PROOF', json);
+    }
+    const fhevmHandles = FhevmHandle.fromZKProof({
+        ciphertextWithZKProof: ciphertext,
+        chainId,
+        aclAddress: aclContractAddress,
+        ciphertextVersion: currentCiphertextVersion(),
+        fheTypeEncryptionBitwidths: bits,
+    });
+    const handles = fhevmHandles.map((h) => h.toBytes32());
+    const result = json;
+    // Note that the hex strings returned by the relayer do have have the 0x prefix
+    if (result.handles && result.handles.length > 0) {
+        const responseHandles = result.handles.map(hexToBytes);
+        if (handles.length != responseHandles.length) {
+            throw new Error(`Incorrect Handles list sizes: (expected) ${handles.length} != ${responseHandles.length} (received)`);
+        }
+        for (let index = 0; index < handles.length; index += 1) {
+            let handle = handles[index];
+            let responseHandle = responseHandles[index];
+            let expected = bytesToHexNo0x(handle);
+            let current = bytesToHexNo0x(responseHandle);
+            if (expected !== current) {
+                throw new Error(`Incorrect Handle ${index}: (expected) ${expected} != ${current} (received)`);
+            }
+        }
+    }
+    const signatures = result.signatures;
+    // verify signatures for inputs:
+    const domain = {
+        name: 'InputVerification',
+        version: '1',
+        chainId: gatewayChainId,
+        verifyingContract: verifyingContractAddressInputVerification,
+    };
+    const types = {
+        CiphertextVerification: [
+            { name: 'ctHandles', type: 'bytes32[]' },
+            { name: 'userAddress', type: 'address' },
+            { name: 'contractAddress', type: 'address' },
+            { name: 'contractChainId', type: 'uint256' },
+            { name: 'extraData', type: 'bytes' },
+        ],
+    };
+    const recoveredAddresses = signatures.map((signature) => {
+        const sig = signature.startsWith('0x') ? signature : `0x${signature}`;
+        const recoveredAddress = ethers.verifyTypedData(domain, types, {
+            ctHandles: handles,
+            userAddress,
+            contractAddress,
+            contractChainId: chainId,
+            extraData,
+        }, sig);
+        return recoveredAddress;
+    });
+    const thresholdReached = isThresholdReached$1(coprocessorSigners, recoveredAddresses, thresholdCoprocessorSigners);
+    if (!thresholdReached) {
+        throw Error('Coprocessor signers threshold is not reached');
+    }
+    // inputProof is len(list_handles) + numCoprocessorSigners + list_handles + signatureCoprocessorSigners (1+1+NUM_HANDLES*32+65*numSigners)
+    let inputProof = numberToHexNo0x(handles.length);
+    const numSigners = signatures.length;
+    inputProof += numberToHexNo0x(numSigners);
+    const listHandlesStr = handles.map((i) => bytesToHexNo0x(i));
+    listHandlesStr.map((handle) => (inputProof += handle));
+    signatures.map((signature) => (inputProof += signature.slice(2))); // removes the '0x' prefix from the `signature` string
+    // Append the extra data to the input proof
+    inputProof += extraData.slice(2);
+    return {
+        handles,
+        inputProof: hexToBytes(inputProof),
+    };
+}
 function isThresholdReached$1(coprocessorSigners, recoveredAddresses, threshold) {
     const addressMap = new Map();
     recoveredAddresses.forEach((address, index) => {
@@ -1912,9 +2396,7 @@ function isFhevmRelayerInputProofResponse(json) {
     return (response.signatures.every((s) => typeof s === 'string') &&
         response.handles.every((h) => typeof h === 'string'));
 }
-const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, 
-//relayerUrl: string,
-relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, instanceOptions) => (contractAddress, userAddress) => {
+const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, defaultOptions) => (contractAddress, userAddress) => {
     if (!isAddress$1(contractAddress)) {
         throw new Error('Contract address is not a valid address.');
     }
@@ -1966,25 +2448,31 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
         getBits() {
             return input.getBits();
         },
+        generateZKProof() {
+            return {
+                chainId,
+                aclContractAddress: aclContractAddress,
+                userAddress: userAddress,
+                contractAddress: contractAddress,
+                ciphertextWithZkProof: input.encrypt(),
+                bits: input.getBits(),
+            };
+        },
         encrypt: async (options) => {
             const extraData = '0x00';
             const bits = input.getBits();
             const ciphertext = input.encrypt();
-            //console.log(`ciphertext=${toHexString(ciphertext)}`);
             const payload = {
                 contractAddress: getAddress(contractAddress),
                 userAddress: getAddress(userAddress),
-                ciphertextWithInputVerification: toHexString(ciphertext),
+                ciphertextWithInputVerification: bytesToHexNo0x(ciphertext),
                 contractChainId: ('0x' + chainId.toString(16)),
                 extraData,
             };
-            const json = await relayerProvider.fetchPostInputProof(payload, options ?? instanceOptions);
-            // const json = await fetchRelayerJsonRpcPost(
-            //   'INPUT_PROOF',
-            //   `${relayerUrl}/v1/input-proof`,
-            //   payload,
-            //   options ?? instanceOptions,
-            // );
+            const json = await relayerProvider.fetchPostInputProof(payload, {
+                ...defaultOptions,
+                ...options,
+            });
             if (!isFhevmRelayerInputProofResponse(json)) {
                 throwRelayerInternalError('INPUT_PROOF', json);
             }
@@ -1996,7 +2484,6 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
                 fheTypeEncryptionBitwidths: bits,
             });
             const handles = fhevmHandles.map((h) => h.toBytes32());
-            //const result = json.response;
             const result = json;
             // Note that the hex strings returned by the relayer do have have the 0x prefix
             if (result.handles && result.handles.length > 0) {
@@ -2007,8 +2494,8 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
                 for (let index = 0; index < handles.length; index += 1) {
                     let handle = handles[index];
                     let responseHandle = responseHandles[index];
-                    let expected = toHexString(handle);
-                    let current = toHexString(responseHandle);
+                    let expected = bytesToHexNo0x(handle);
+                    let current = bytesToHexNo0x(responseHandle);
                     if (expected !== current) {
                         throw new Error(`Incorrect Handle ${index}: (expected) ${expected} != ${current} (received)`);
                     }
@@ -2047,10 +2534,10 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
                 throw Error('Coprocessor signers threshold is not reached');
             }
             // inputProof is len(list_handles) + numCoprocessorSigners + list_handles + signatureCoprocessorSigners (1+1+NUM_HANDLES*32+65*numSigners)
-            let inputProof = numberToHex(handles.length);
+            let inputProof = numberToHexNo0x(handles.length);
             const numSigners = signatures.length;
-            inputProof += numberToHex(numSigners);
-            const listHandlesStr = handles.map((i) => toHexString(i));
+            inputProof += numberToHexNo0x(numSigners);
+            const listHandlesStr = handles.map((i) => bytesToHexNo0x(i));
             listHandlesStr.map((handle) => (inputProof += handle));
             signatures.map((signature) => (inputProof += signature.slice(2))); // removes the '0x' prefix from the `signature` string
             // Append the extra data to the input proof
@@ -2063,15 +2550,30 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
     };
 };
 
-const aclABI = [
-    'function isAllowedForDecryption(bytes32 handle) view returns (bool)',
-];
-function isThresholdReached(kmsSigners, recoveredAddresses, threshold) {
-    const addressMap = new Map();
-    recoveredAddresses.forEach((address, index) => {
-        if (addressMap.has(address)) {
-            const duplicateValue = address;
-            throw new Error(`Duplicate KMS signer address found: ${duplicateValue} appears multiple times in recovered addresses`);
+function ensureError(e) {
+    if (e instanceof Error) {
+        return e;
+    }
+    const message = e.message ?? 'Non-Error value caught in exception handler';
+    const name = e.name ?? 'ErrorWrapper';
+    const cause = e.cause ?? e;
+    const err = new Error(message, { cause });
+    err.name = name;
+    return err;
+}
+function assertNever(value, message) {
+    throw new InternalError({ message });
+}
+
+const aclABI = [
+    'function isAllowedForDecryption(bytes32 handle) view returns (bool)',
+];
+function isThresholdReached(kmsSigners, recoveredAddresses, threshold) {
+    const addressMap = new Map();
+    recoveredAddresses.forEach((address, index) => {
+        if (addressMap.has(address)) {
+            const duplicateValue = address;
+            throw new Error(`Duplicate KMS signer address found: ${duplicateValue} appears multiple times in recovered addresses`);
         }
         addressMap.set(address, index);
     });
@@ -2088,7 +2590,7 @@ function abiEncodeClearValues(clearValues) {
     const abiValues = [];
     for (let i = 0; i < handlesBytes32Hex.length; ++i) {
         const handle = handlesBytes32Hex[i];
-        const handleType = getHandleType(handle);
+        const handleType = FhevmHandle.parse(handle).fheTypeId;
         let clearTextValue = clearValues[handle];
         if (typeof clearTextValue === 'boolean') {
             clearTextValue = clearTextValue ? '0x01' : '0x00';
@@ -2125,7 +2627,7 @@ function abiEncodeClearValues(clearValues) {
                 break;
             }
             default: {
-                throw new Error(`Unsupported Fhevm primitive type id: ${handleType}`);
+                assertNever(handleType, `Unsupported Fhevm primitive type id: ${handleType}`);
             }
         }
     }
@@ -2150,50 +2652,38 @@ function buildDecryptionProof(kmsSignatures, extraData) {
     ]);
     return decryptionProof;
 }
-const CiphertextType = {
-    0: 'bool',
-    2: 'uint256',
-    3: 'uint256',
-    4: 'uint256',
-    5: 'uint256',
-    6: 'uint256',
-    7: 'address',
-    8: 'uint256',
-};
 function deserializeClearValues(handles, decryptedResult) {
-    let typesList = [];
+    let fheTypeIdList = [];
     for (const handle of handles) {
-        const hexPair = handle.slice(-4, -2).toLowerCase();
-        const typeDiscriminant = parseInt(hexPair, 16);
-        typesList.push(typeDiscriminant);
+        const typeDiscriminant = FhevmHandle.parse(handle).fheTypeId;
+        fheTypeIdList.push(typeDiscriminant);
     }
     const restoredEncoded = '0x' +
         '00'.repeat(32) + // dummy requestID (ignored)
         decryptedResult.slice(2) +
         '00'.repeat(32); // dummy empty bytes[] length (ignored)
-    const abiTypes = typesList.map((t) => {
-        const abiType = CiphertextType[t]; // all types are valid because this was supposedly checked already inside the `checkEncryptedBits` function
+    const abiTypes = fheTypeIdList.map((t) => {
+        const abiType = solidityPrimitiveTypeNameFromFheTypeId(t); // all types are valid because this was supposedly checked already inside the `checkEncryptedBits` function
         return abiType;
     });
     const coder = new AbiCoder();
     const decoded = coder.decode(['uint256', ...abiTypes, 'bytes[]'], restoredEncoded);
     // strip dummy first/last element
-    const rawValues = decoded.slice(1, 1 + typesList.length);
+    const rawValues = decoded.slice(1, 1 + fheTypeIdList.length);
     const results = {};
     handles.forEach((handle, idx) => (results[handle] = rawValues[idx]));
     return results;
 }
-const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, 
-//relayerUrl: string,
-relayerProvider, provider, instanceOptions) => async (_handles, options) => {
+const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, relayerProvider, provider, defaultOptions) => async (_handles, options) => {
     const extraData = '0x00';
     const acl = new ethers.Contract(aclContractAddress, aclABI, provider);
+    // This will be replaced by new sanitize classes
     let handles;
     try {
         handles = await Promise.all(_handles.map(async (_handle) => {
             const handle = typeof _handle === 'string'
-                ? toHexString(hexToBytes(_handle), true)
-                : toHexString(_handle, true);
+                ? bytesToHex(hexToBytes(_handle))
+                : bytesToHex(_handle);
             const isAllowedForDecryption = await acl.isAllowedForDecryption(handle);
             if (!isAllowedForDecryption) {
                 throw new Error(`Handle ${handle} is not allowed for public decryption!`);
@@ -2210,13 +2700,10 @@ relayerProvider, provider, instanceOptions) => async (_handles, options) => {
         ciphertextHandles: handles,
         extraData,
     };
-    const json = await relayerProvider.fetchPostPublicDecrypt(payloadForRequest, options ?? instanceOptions);
-    // const json = await fetchRelayerJsonRpcPost(
-    //   'PUBLIC_DECRYPT',
-    //   `${relayerUrl}/v1/public-decrypt`,
-    //   payloadForRequest,
-    //   options ?? instanceOptions,
-    // );
+    const json = await relayerProvider.fetchPostPublicDecrypt(payloadForRequest, {
+        ...defaultOptions,
+        ...options,
+    });
     // verify signatures on decryption:
     const domain = {
         name: 'Decryption',
@@ -2354,8 +2841,8 @@ const createEIP712 = (verifyingContract, contractsChainId) => (publicKey, contra
 const generateKeypair = () => {
     const keypair = TKMS.ml_kem_pke_keygen();
     return {
-        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)),
+        publicKey: bytesToHexNo0x(TKMS.ml_kem_pke_pk_to_u8vec(TKMS.ml_kem_pke_get_pk(keypair))),
+        privateKey: bytesToHexNo0x(TKMS.ml_kem_pke_sk_to_u8vec(keypair)),
     };
 };
 
@@ -2412,7 +2899,7 @@ class RelayerV1Provider extends AbstractRelayerProvider {
         return 1;
     }
     async fetchGetKeyUrl() {
-        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        const response = await fetchRelayerV1Get('KEY_URL', this.keyUrl);
         return response;
     }
     async fetchPostInputProof(payload, options) {
@@ -2430,12 +2917,12 @@ class RelayerV1Provider extends AbstractRelayerProvider {
           }
         }
         */
-        const json = await fetchRelayerJsonRpcPost('INPUT_PROOF', this.inputProof, payload, options);
+        const json = await fetchRelayerV1Post('INPUT_PROOF', this.inputProof, payload, options);
         assertIsRelayerInputProofResult(json.response, 'fetchPostInputProof()');
         return json.response;
     }
     async fetchPostPublicDecrypt(payload, options) {
-        const json = await fetchRelayerJsonRpcPost('PUBLIC_DECRYPT', this.publicDecrypt, payload, options);
+        const json = await fetchRelayerV1Post('PUBLIC_DECRYPT', this.publicDecrypt, payload, options);
         const response = json.response[0];
         const result = {
             signatures: response.signatures,
@@ -2446,24 +2933,12 @@ class RelayerV1Provider extends AbstractRelayerProvider {
         return result;
     }
     async fetchPostUserDecrypt(payload, options) {
-        const json = await fetchRelayerJsonRpcPost('USER_DECRYPT', this.userDecrypt, payload, options);
+        const json = await fetchRelayerV1Post('USER_DECRYPT', this.userDecrypt, payload, options);
         assertIsRelayerUserDecryptResult(json.response, 'RelayerUserDecryptResult()');
         return json.response;
     }
 }
 
-function ensureError(e) {
-    if (e instanceof Error) {
-        return e;
-    }
-    const message = e.message ?? 'Non-Error value caught in exception handler';
-    const name = e.name ?? 'ErrorWrapper';
-    const cause = e.cause ?? e;
-    const err = new Error(message, { cause });
-    err.name = name;
-    return err;
-}
-
 class RelayerV2ProviderError extends RelayerErrorBase {
     _operation;
     constructor(params) {
@@ -2940,22 +3415,6 @@ class RelayerV2RequestInternalError extends RelayerV2RequestErrorBase {
     }
 }
 
-function assertIsRelayerV2ResultQueued(value, name) {
-    assertRecordStringProperty(value, 'jobId', name);
-}
-
-/*
-  type RelayerV2ResponseQueued = {
-    status: "queued";
-    result: RelayerV2ResultQueued;
-  }
-*/
-function assertIsRelayerV2ResponseQueued(value, name) {
-    assertRecordStringProperty(value, 'status', name, 'queued');
-    assertNonNullableRecordProperty(value, 'result', name);
-    assertIsRelayerV2ResultQueued(value.result, `${name}.result`);
-}
-
 class RelayerV2ResponseApiError extends RelayerV2ResponseErrorBase {
     constructor(params) {
         super({
@@ -3017,7 +3476,58 @@ class RelayerV2MaxRetryError extends RelayerV2FetchErrorBase {
     }
 }
 
+function assertIsRelayerV2PostResultQueued(value, name) {
+    assertRecordStringProperty(value, 'jobId', name);
+}
+
+/*
+  {
+    status: 'queued';
+    requestId: string;
+    result: {
+      jobId: string;
+    };
+  }
+*/
+function assertIsRelayerV2PostResponseQueued(value, name) {
+    assertRecordStringProperty(value, 'status', name, 'queued');
+    assertRecordStringProperty(value, 'requestId', name);
+    assertNonNullableRecordProperty(value, 'result', name);
+    assertIsRelayerV2PostResultQueued(value.result, `${name}.result`);
+}
+/*
+  {
+    status: 'queued';
+    requestId: string;
+  }
+*/
+function assertIsRelayerV2GetResponseQueued(value, name) {
+    assertRecordStringProperty(value, 'status', name, 'queued');
+    assertRecordStringProperty(value, 'requestId', name);
+}
+
+class RelayerV2TimeoutError extends RelayerV2RequestErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2TimeoutError',
+            message: `Request timed out after ${params.timeoutMs}ms`,
+        });
+    }
+}
+
+class RelayerV2AbortError extends RelayerV2RequestErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2AbortError',
+            message: `Request aborted`,
+        });
+    }
+}
+
 class RelayerV2AsyncRequest {
+    _fetchMethod;
     _jobId;
     _jobIdTimestamp;
     _state;
@@ -3032,17 +3542,18 @@ class RelayerV2AsyncRequest {
     _retryAfterTimeoutID;
     _url;
     _payload;
-    _fhevmInstanceOptions;
+    _fhevmAuth;
     _retryAfterTimeoutPromiseFuncReject;
     _onProgress;
-    _requestMaxDurationInSecs;
+    _requestMaxDurationInMs;
     _requestStartTimestamp;
     _requestGlobalTimeoutID;
     _throwErrorIfNoRetryAfter;
-    static DEFAULT_RETRY_AFTER_SECS = 2;
-    static DEFAULT_GLOBAL_REQUEST_TIMEOUT_SECS = 60 * 60;
-    static MAX_GET_RETRY = 100;
-    static MAX_POST_RETRY = 100;
+    static DEFAULT_RETRY_AFTER_MS = 2500;
+    static MINIMUM_RETRY_AFTER_MS = 1000;
+    static DEFAULT_GLOBAL_REQUEST_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
+    static MAX_GET_RETRY = 60 * 30; // number of default retries in 1 hour (30 retries/min)
+    static MAX_POST_RETRY = RelayerV2AsyncRequest.MAX_GET_RETRY;
     constructor(params) {
         if (params.relayerOperation !== 'INPUT_PROOF' &&
             params.relayerOperation !== 'PUBLIC_DECRYPT' &&
@@ -3059,14 +3570,14 @@ class RelayerV2AsyncRequest {
         this._internalAbortController = new AbortController();
         this._internalAbortSignal = this._internalAbortController.signal;
         this._internalAbortSignal.addEventListener('abort', this._handleInternalSignalAbort);
-        this._externalAbortSignal = params.signal;
+        this._externalAbortSignal = params.options?.signal;
         if (this._externalAbortSignal) {
             this._externalAbortSignal.addEventListener('abort', this._handleExternalSignalAbort);
         }
         this._url = params.url;
         this._payload = params.payload;
-        this._fhevmInstanceOptions = params.instanceOptions;
-        this._onProgress = params.onProgress;
+        this._fhevmAuth = params.options?.auth;
+        this._onProgress = params.options?.onProgress;
         this._state = {
             aborted: false,
             canceled: false,
@@ -3075,6 +3586,7 @@ class RelayerV2AsyncRequest {
             running: false,
             succeeded: false,
             terminated: false,
+            timeout: false,
         };
         this._retryCount = 0;
         this._retryAfterTimeoutID = undefined;
@@ -3082,9 +3594,9 @@ class RelayerV2AsyncRequest {
         this._terminateReason = undefined;
         this._publicAPINoReentrancy = false;
         this._throwErrorIfNoRetryAfter = params.throwErrorIfNoRetryAfter ?? false;
-        this._requestMaxDurationInSecs =
-            params.timeoutInSeconds ??
-                RelayerV2AsyncRequest.DEFAULT_GLOBAL_REQUEST_TIMEOUT_SECS;
+        this._requestMaxDurationInMs =
+            params.options?.timeout ??
+                RelayerV2AsyncRequest.DEFAULT_GLOBAL_REQUEST_TIMEOUT_MS;
     }
     //////////////////////////////////////////////////////////////////////////////
     // Public API: run
@@ -3126,6 +3638,12 @@ class RelayerV2AsyncRequest {
                 state: { ...this._state },
             });
         }
+        if (this._state.timeout) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already timeout.`,
+                state: { ...this._state },
+            });
+        }
         if (this._externalAbortSignal?.aborted === true) {
             throw new RelayerV2StateError({
                 message: `Relayer.run() failed. External AbortSignal already aborted (reason:${this._externalAbortSignal?.reason}).`,
@@ -3146,7 +3664,7 @@ class RelayerV2AsyncRequest {
         }
         this._state.running = true;
         this._requestStartTimestamp = Date.now();
-        this._setGlobalRequestTimeout(this._requestMaxDurationInSecs * 1000);
+        this._setGlobalRequestTimeout(this._requestMaxDurationInMs);
         try {
             const json = await this._runPostLoop();
             this._state.succeeded = true;
@@ -3217,6 +3735,12 @@ class RelayerV2AsyncRequest {
     get failed() {
         return this._state.failed;
     }
+    get aborted() {
+        return this._state.aborted;
+    }
+    get timeout() {
+        return this._state.timeout;
+    }
     get succeeded() {
         return this._state.succeeded;
     }
@@ -3237,6 +3761,8 @@ class RelayerV2AsyncRequest {
     //////////////////////////////////////////////////////////////////////////////
     // POST : 202 | 400 | 429 | 500 | 503
     async _runPostLoop() {
+        this._assert(this._fetchMethod === undefined, 'this._fetchMethod === undefined');
+        this._fetchMethod = 'POST';
         // No infinite loop!
         let i = 0;
         while (i < RelayerV2AsyncRequest.MAX_POST_RETRY) {
@@ -3261,19 +3787,18 @@ class RelayerV2AsyncRequest {
                     //    - SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2) at JSON.parse (<anonymous>)
                     const bodyJson = await this._getResponseJson(response);
                     try {
-                        assertIsRelayerV2ResponseQueued(bodyJson, 'body');
+                        assertIsRelayerV2PostResponseQueued(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
-                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
-                    if (retry_after_sec < 1)
-                        retry_after_sec = 1;
+                    const retryAfterMs = this._getRetryAfterHeaderValueInMs(response);
                     // Debug: will throw an assert failed error if jobId has already been set
                     this._setJobIdOnce(bodyJson.result.jobId);
                     // Async onProgress callback
@@ -3286,11 +3811,10 @@ class RelayerV2AsyncRequest {
                         jobId: this.jobId,
                         operation: this._relayerOperation,
                         retryCount: this._retryCount,
-                        retryAfter: retry_after_sec,
+                        retryAfterMs,
                         elapsed,
                     });
-                    // Wait if needed (minimum 1s)
-                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    await this._setRetryAfterTimeout(retryAfterMs);
                     const json = await this._runGetLoop();
                     return json;
                 }
@@ -3303,11 +3827,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError400(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3327,29 +3852,28 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError429(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
-                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
-                    if (retry_after_sec < 1)
-                        retry_after_sec = 1;
+                    const retryAfterMs = this._getRetryAfterHeaderValueInMs(response);
                     // Async onProgress callback
                     this._postAsyncOnProgressCallback({
                         type: 'ratelimited',
                         url: this._url,
                         method: 'POST',
                         status: responseStatus,
-                        retryAfter: retry_after_sec,
+                        retryAfterMs,
                         retryCount: this._retryCount,
                         elapsed,
-                        message: bodyJson.error.message,
+                        relayerApiError: bodyJson.error,
                     });
                     // Wait if needed (minimum 1s)
-                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    await this._setRetryAfterTimeout(retryAfterMs);
                     continue;
                 }
                 // RelayerV2ResponseFailed
@@ -3362,11 +3886,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError500(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3386,11 +3911,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError503(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3426,8 +3952,10 @@ class RelayerV2AsyncRequest {
     // GET: 200 | 202 | 404 | 500 | 503 | 504
     // GET is not rate-limited, therefore there is not 429 error
     async _runGetLoop() {
+        this._assert(this._fetchMethod === 'POST', "this._fetchMethod === 'POST'");
         this._assert(this._jobId !== undefined, 'this._jobId !== undefined');
         this._assert(this._jobIdTimestamp !== undefined, 'this._jobIdTimestamp !== undefined');
+        this._fetchMethod = 'GET';
         let i = 0;
         while (i < RelayerV2AsyncRequest.MAX_GET_RETRY) {
             ++i;
@@ -3514,6 +4042,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     // RelayerV2ResultPublicDecrypt
@@ -3525,7 +4054,7 @@ class RelayerV2AsyncRequest {
                 case 202: {
                     const bodyJson = await this._getResponseJson(response);
                     try {
-                        assertIsRelayerV2ResponseQueued(bodyJson, 'body');
+                        assertIsRelayerV2GetResponseQueued(bodyJson, 'body');
                     }
                     catch (cause) {
                         this._throwResponseInvalidBodyError({
@@ -3533,11 +4062,10 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
-                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
-                    if (retry_after_sec < 1)
-                        retry_after_sec = 1;
+                    const retryAfterMs = this._getRetryAfterHeaderValueInMs(response);
                     // Async onProgress callback
                     this._postAsyncOnProgressCallback({
                         type: 'queued',
@@ -3547,12 +4075,12 @@ class RelayerV2AsyncRequest {
                         requestId: bodyJson.requestId,
                         operation: this._relayerOperation,
                         jobId: this.jobId,
-                        retryAfter: retry_after_sec,
+                        retryAfterMs,
                         retryCount: this._retryCount,
                         elapsed,
                     });
                     // Wait if needed (minimum 1s)
-                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    await this._setRetryAfterTimeout(retryAfterMs);
                     continue;
                 }
                 case 400: {
@@ -3568,6 +4096,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3590,6 +4119,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3614,6 +4144,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3638,6 +4169,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3662,6 +4194,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3699,17 +4232,20 @@ class RelayerV2AsyncRequest {
         return bodyJson;
     }
     //////////////////////////////////////////////////////////////////////////////
-    _getRetryAfterHeaderValueInSecs(response) {
+    _getRetryAfterHeaderValueInMs(response) {
         if (!response.headers.has('Retry-After')) {
             if (this._throwErrorIfNoRetryAfter) {
                 throw new Error(`Missing 'Retry-After' header key`);
             }
-            return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_SECS;
+            return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_MS;
         }
         try {
             const n = Number.parseInt(response.headers.get('Retry-After'));
             if (isUint(n)) {
-                return n;
+                const ms = n * 1000;
+                return ms < RelayerV2AsyncRequest.MINIMUM_RETRY_AFTER_MS
+                    ? RelayerV2AsyncRequest.MINIMUM_RETRY_AFTER_MS
+                    : ms;
             }
         }
         catch {
@@ -3718,7 +4254,7 @@ class RelayerV2AsyncRequest {
         if (this._throwErrorIfNoRetryAfter) {
             throw new Error(`Invalid 'Retry-After' header key`);
         }
-        return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_SECS;
+        return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_MS;
     }
     //////////////////////////////////////////////////////////////////////////////
     // JobId
@@ -3757,17 +4293,19 @@ class RelayerV2AsyncRequest {
         this._assert(this._jobId === undefined, 'this._jobId === undefined');
         this._assert(!this._state.terminated, '!this._state.terminated');
         this._assert(!this._state.fetching, '!this._state.fetching');
-        this._trace('_fetchPost', 'enter');
+        this._trace('_fetchPost', this._url);
         const init = setAuth({
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
+                'ZAMA-SDK-VERSION': `${version}`,
+                'ZAMA-SDK-NAME': `${sdkName}`,
             },
             body: JSON.stringify(this._payload),
             ...(this._internalAbortSignal
                 ? { signal: this._internalAbortSignal }
                 : {}),
-        }, this._fhevmInstanceOptions?.auth);
+        }, this._fhevmAuth);
         this._state.fetching = true;
         let response;
         try {
@@ -3811,9 +4349,16 @@ class RelayerV2AsyncRequest {
         this._assert(!this._state.terminated, '!this._state.terminated');
         this._assert(!this._state.fetching, '!this._state.fetching');
         this._trace('_fetchGet', `jobId=${this.jobId}`);
-        const init = this._internalAbortSignal
-            ? { signal: this._internalAbortSignal }
-            : undefined;
+        const init = {
+            method: 'GET',
+            headers: {
+                'ZAMA-SDK-VERSION': `${version}`,
+                'ZAMA-SDK-NAME': `${sdkName}`,
+            },
+            ...(this._internalAbortSignal
+                ? { signal: this._internalAbortSignal }
+                : {}),
+        };
         this._state.fetching = true;
         let response;
         try {
@@ -3887,7 +4432,18 @@ class RelayerV2AsyncRequest {
         if (signal.reason !== 'cancel') {
             this._assert(!this._state.canceled, '!this._state.canceled');
         }
-        this._terminate('abort');
+        this._postAsyncOnProgressCallback({
+            type: 'abort',
+            url: this._url,
+            ...(this._jobId ? { jobId: this._jobId } : {}),
+            operation: this._relayerOperation,
+            retryCount: this._retryCount,
+        });
+        this._terminate('abort', new RelayerV2AbortError({
+            operation: this._relayerOperation,
+            jobId: this._jobId,
+            url: this._url,
+        }));
     };
     //////////////////////////////////////////////////////////////////////////////
     // Terminate
@@ -3911,7 +4467,7 @@ class RelayerV2AsyncRequest {
         this._terminateReason = reason;
         this._terminateError = error;
         this._state.terminated = true;
-        this._tryClearRetryAfterTimeout();
+        this._tryClearRetryAfterTimeout(error);
         this._tryClearGlobalRequestTimeout();
         const is = this._internalAbortSignal;
         const es = this._externalAbortSignal;
@@ -3933,7 +4489,7 @@ class RelayerV2AsyncRequest {
         // Debug
         this._assert(!this._state.terminated, '!this._state.terminated');
         this._assert(this._retryAfterTimeoutID === undefined, 'this._retryAfterTimeoutID === undefined');
-        this._assert(delayMs >= 1000, 'delayMs >= 1000');
+        this._assert(delayMs >= RelayerV2AsyncRequest.MINIMUM_RETRY_AFTER_MS, `delayMs >= ${RelayerV2AsyncRequest.MINIMUM_RETRY_AFTER_MS}`);
         this._trace('_setRetryAfterTimeout', `delayMs=${delayMs}`);
         if (this._retryAfterTimeoutID !== undefined) {
             return Promise.reject(new Error(`retry-after already running.`));
@@ -3953,7 +4509,7 @@ class RelayerV2AsyncRequest {
         return p;
     }
     //////////////////////////////////////////////////////////////////////////////
-    _tryClearRetryAfterTimeout() {
+    _tryClearRetryAfterTimeout(error) {
         if (this._retryAfterTimeoutID === undefined) {
             // Debug
             this._assert(this._retryAfterTimeoutPromiseFuncReject === undefined, 'this._retryAfterTimeoutPromiseFuncReject === undefined');
@@ -3964,7 +4520,8 @@ class RelayerV2AsyncRequest {
         this._retryAfterTimeoutID = undefined;
         this._retryAfterTimeoutPromiseFuncReject = undefined;
         clearTimeout(tid);
-        reject(new Error('_tryClearRetryAfterTimeout'));
+        // Calling reject will
+        reject(error ?? new Error('_tryClearRetryAfterTimeout'));
     }
     //////////////////////////////////////////////////////////////////////////////
     // Global Request Timeout
@@ -3979,7 +4536,24 @@ class RelayerV2AsyncRequest {
         this._requestGlobalTimeoutID = setTimeout(callback, delayMs);
     }
     _handleGlobalRequestTimeout() {
-        this._terminate('timeout');
+        this._state.timeout = true;
+        // Debug state-check guards:
+        this._assert(this instanceof RelayerV2AsyncRequest, `this instanceof RelayerV2AsyncRequest`);
+        this._assert(!this._state.terminated, `!this._state.terminated`);
+        this._assert(!this._state.timeout, '!this._state.timeout');
+        this._postAsyncOnProgressCallback({
+            type: 'timeout',
+            url: this._url,
+            ...(this._jobId ? { jobId: this._jobId } : {}),
+            operation: this._relayerOperation,
+            retryCount: this._retryCount,
+        });
+        this._terminate('timeout', new RelayerV2TimeoutError({
+            operation: this._relayerOperation,
+            jobId: this._jobId,
+            url: this._url,
+            timeoutMs: this._requestMaxDurationInMs,
+        }));
     }
     _tryClearGlobalRequestTimeout() {
         if (this._requestGlobalTimeoutID === undefined) {
@@ -4066,20 +4640,11 @@ class RelayerV2AsyncRequest {
             elapsed,
         });
     }
-    _throwInvalidResponseError(params) {
-        throw new RelayerV2ResponseInvalidBodyError({
-            ...params,
-            url: this._url,
-            operation: this._relayerOperation,
-            state: { ...this._state },
-            retryCount: this._retryCount,
-        });
-    }
     _throwResponseInvalidBodyError(params) {
         throw new RelayerV2ResponseInvalidBodyError({
             ...params,
             url: this._url,
-            jobId: this.jobId,
+            jobId: this._jobId,
             operation: this._relayerOperation,
             state: { ...this._state },
             retryCount: this._retryCount,
@@ -4150,7 +4715,7 @@ function assertIsRelayerV2KeyData(value, name) {
     assertRecordStringProperty(value, 'dataId', name);
     assertRecordStringArrayProperty(value, 'urls', name);
 }
-function toRelayerKeyUrlResponse(response) {
+function toRelayerV1KeyUrlResponse(response) {
     const fheKeyInfoV1 = response.response.fheKeyInfo.map((v2Info) => ({
         fhe_public_key: {
             data_id: v2Info.fhePublicKey.dataId,
@@ -4180,7 +4745,7 @@ class RelayerV2Provider extends AbstractRelayerProvider {
         return 2;
     }
     async fetchGetKeyUrlV2() {
-        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        const response = await fetchRelayerV1Get('KEY_URL', this.keyUrl);
         // Relayer error
         try {
             assertIsRelayerV2GetResponseKeyUrl(response, 'fetchGetKeyUrl()');
@@ -4194,39 +4759,36 @@ class RelayerV2Provider extends AbstractRelayerProvider {
     }
     async fetchGetKeyUrl() {
         const response = await this.fetchGetKeyUrlV2();
-        return toRelayerKeyUrlResponse(response);
+        return toRelayerV1KeyUrlResponse(response);
     }
-    async fetchPostInputProof(payload, instanceOptions, fetchOptions) {
+    async fetchPostInputProof(payload, options) {
         const request = new RelayerV2AsyncRequest({
             relayerOperation: 'INPUT_PROOF',
             url: this.inputProof,
             payload,
-            instanceOptions,
-            ...fetchOptions,
+            options,
         });
         const result = (await request.run());
         assertIsRelayerInputProofResult(result, 'fetchPostInputProof()');
         return result;
     }
-    async fetchPostPublicDecrypt(payload, instanceOptions, fetchOptions) {
+    async fetchPostPublicDecrypt(payload, options) {
         const request = new RelayerV2AsyncRequest({
             relayerOperation: 'PUBLIC_DECRYPT',
             url: this.publicDecrypt,
             payload,
-            instanceOptions,
-            ...fetchOptions,
+            options,
         });
         const result = await request.run();
         assertIsRelayerPublicDecryptResult(result, 'fetchPostPublicDecrypt()');
         return result;
     }
-    async fetchPostUserDecrypt(payload, instanceOptions, fetchOptions) {
+    async fetchPostUserDecrypt(payload, options) {
         const request = new RelayerV2AsyncRequest({
             relayerOperation: 'USER_DECRYPT',
             url: this.userDecrypt,
             payload,
-            instanceOptions,
-            ...fetchOptions,
+            options,
         });
         const result = (await request.run());
         assertIsRelayerUserDecryptResult(result.result, 'fetchPostUserDecrypt()');
@@ -4234,6 +4796,16 @@ class RelayerV2Provider extends AbstractRelayerProvider {
     }
 }
 
+class TFHECrsError extends RelayerErrorBase {
+    constructor({ message, cause }) {
+        super({
+            message,
+            name: 'TFHECrsError',
+            ...(cause ? { cause: ensureError(cause) } : {}),
+        });
+    }
+}
+
 class AbstractRelayerFhevm {
 }
 
@@ -4248,6 +4820,15 @@ class TFHECrs {
         this._bits = params.bits;
         this._srcUrl = params.srcUrl;
     }
+    get id() {
+        return this._id;
+    }
+    get bits() {
+        return this._bits;
+    }
+    get srcUrl() {
+        return this._srcUrl;
+    }
     /*
       {
         id: string,
@@ -4350,20 +4931,58 @@ class TFHECrs {
             return TFHECrs._fromUrl(params);
         }
         else {
-            throw new Error('Invalid public key (deserialization failed)');
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
+            });
         }
     }
+    /*
+      {
+        id: string;
+        data: Uint8Array;
+        bits: number;
+        srcUrl?: string;
+      }
+    */
     static fromBytes(params) {
         try {
             TFHECrs.assertKeyBytesType(params, 'arg');
             return TFHECrs._fromBytes(params);
         }
         catch (e) {
-            throw new Error('Invalid public key (deserialization failed)', {
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
                 cause: e,
             });
         }
     }
+    /*
+      {
+        id: string;
+        data: BytesHex;
+        bits: number;
+        srcUrl?: string;
+      }
+    */
+    static fromBytesHex(params) {
+        let data;
+        try {
+            assertRecordStringProperty(params, 'data', 'arg');
+            data = hexToBytesFaster(params.data, true /* strict */);
+        }
+        catch (e) {
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
+                cause: e,
+            });
+        }
+        return TFHECrs.fromBytes({
+            id: params?.id,
+            bits: params?.bits,
+            srcUrl: params?.srcUrl,
+            data,
+        });
+    }
     static _fromBytes(params) {
         const _params = {
             compactPkeCrs: TFHE.CompactPkeCrs.safe_deserialize(params.data, SERIALIZED_SIZE_LIMIT_CRS),
@@ -4379,7 +4998,50 @@ class TFHECrs {
             return TFHECrs._fromPublicParamsBytes(params);
         }
         catch (e) {
-            throw new Error('Invalid public key (deserialization failed)', {
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
+                cause: e,
+            });
+        }
+    }
+    static fromBitsPublicParamsBytes(bits, params) {
+        if (bits === undefined) {
+            throw new TFHECrsError({ message: 'Missing PublicParams bits format' });
+        }
+        if (bits !== 2048) {
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '${bits}'`,
+            });
+        }
+        try {
+            assertRecordStringProperty(params, 'publicParamsId', `arg`);
+            assertUint8ArrayProperty(params, 'publicParams', `arg`);
+            return TFHECrs._fromPublicParamsBytes({
+                2048: params,
+            });
+        }
+        catch (e) {
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
+                cause: e,
+            });
+        }
+    }
+    static fromPublicParamsBytesHex(params) {
+        try {
+            assertNonNullableRecordProperty(params, '2048', 'arg');
+            assertRecordStringProperty(params['2048'], 'publicParamsId', `arg.2048`);
+            assertRecordStringProperty(params['2048'], 'publicParams', `arg.2048`);
+            return TFHECrs._fromPublicParamsBytes({
+                2048: {
+                    publicParams: hexToBytesFaster(params['2048'].publicParams, true /* strict */),
+                    publicParamsId: params['2048'].publicParamsId,
+                },
+            });
+        }
+        catch (e) {
+            throw new TFHECrsError({
+                message: 'Invalid public key (deserialization failed)',
                 cause: e,
             });
         }
@@ -4397,7 +5059,8 @@ class TFHECrs {
             return TFHECrs._fromUrl(params);
         }
         catch (e) {
-            throw new Error('Impossible to fetch public key: wrong relayer url.', {
+            throw new TFHECrsError({
+                message: 'Impossible to fetch public key: wrong relayer url.',
                 cause: e,
             });
         }
@@ -4428,6 +5091,22 @@ class TFHECrs {
             ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
         };
     }
+    /*
+      {
+        id: string,
+        bits: number,
+        data: BytesHex,
+        srcUrl?: string
+      }
+    */
+    toBytesHex() {
+        return {
+            data: bytesToHexLarge(this._compactPkeCrs.safe_serialize(SERIALIZED_SIZE_LIMIT_CRS)),
+            id: this._id,
+            bits: this._bits,
+            ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
+        };
+    }
     /*
       {
         2048: {
@@ -4436,9 +5115,11 @@ class TFHECrs {
         }
       }
     */
-    toPublicParamsWasm() {
+    toPublicParams2048Wasm() {
         if (this._bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${this._bits}`);
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '2048'`,
+            });
         }
         const pp = {
             2048: {
@@ -4456,9 +5137,11 @@ class TFHECrs {
         }
       }
     */
-    toPublicParamsBytes() {
+    toPublicParams2048Bytes() {
         if (this._bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${this._bits}`);
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '2048'`,
+            });
         }
         const pp = {
             2048: {
@@ -4468,6 +5151,64 @@ class TFHECrs {
         };
         return pp;
     }
+    /*
+      {
+        2048: {
+          publicParamsId: string,
+          publicParams: BytesHex
+        }
+      }
+    */
+    toPublicParams2048BytesHex() {
+        if (this._bits === undefined) {
+            throw new TFHECrsError({ message: 'Missing PublicParams bits format' });
+        }
+        if (this._bits !== 2048) {
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '${this._bits}'`,
+            });
+        }
+        const pp = {
+            2048: {
+                publicParams: this.toBytesHex().data,
+                publicParamsId: this._id,
+            },
+        };
+        return pp;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // JSON
+    //////////////////////////////////////////////////////////////////////////////
+    /*
+      {
+        __type: 'TFHECrs',
+        id: string,
+        data: BytesHex,
+        srcUrl?: string
+      }
+    */
+    toJSON() {
+        return {
+            __type: 'TFHECrs',
+            ...this.toBytesHex(),
+        };
+    }
+    static fromJSON(json) {
+        if (json.__type !== 'TFHECrs') {
+            throw new TFHECrsError({ message: 'Invalid TFHECrs JSON.' });
+        }
+        return TFHECrs.fromBytesHex(json);
+    }
+}
+
+class TFHEPublicKeyError extends RelayerErrorBase {
+    constructor({ message, cause }) {
+        super({
+            message,
+            name: 'TFHEPublicKeyError',
+            ...(cause ? { cause: ensureError(cause) } : {}),
+        });
+    }
 }
 
 class TFHEPublicKey {
@@ -4479,6 +5220,12 @@ class TFHEPublicKey {
         this._tfheCompactPublicKey = params.tfheCompactPublicKey;
         this._srcUrl = params.srcUrl;
     }
+    get id() {
+        return this._id;
+    }
+    get srcUrl() {
+        return this._srcUrl;
+    }
     /*
       {
         id: string,
@@ -4563,6 +5310,30 @@ class TFHEPublicKey {
             });
         }
     }
+    /*
+      {
+        id: string,
+        data: BytesHex,
+        srcUrl?: string
+      }
+    */
+    static fromBytesHex(params) {
+        let data;
+        try {
+            assertRecordStringProperty(params, 'data', 'arg');
+            data = hexToBytesFaster(params.data, true /* strict */);
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+        return TFHEPublicKey.fromBytes({
+            id: params?.id,
+            srcUrl: params?.srcUrl,
+            data,
+        });
+    }
     /*
       {
         id: string,
@@ -4623,6 +5394,20 @@ class TFHEPublicKey {
             ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
         };
     }
+    /*
+      {
+        id: string,
+        data: BytesHex,
+        srcUrl?: string
+      }
+    */
+    toBytesHex() {
+        return {
+            data: bytesToHexLarge(this._tfheCompactPublicKey.safe_serialize(SERIALIZED_SIZE_LIMIT_PK)),
+            id: this._id,
+            ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
+        };
+    }
     /*
       {
         publicKey: TFHE.TfheCompactPublicKey
@@ -4647,6 +5432,75 @@ class TFHEPublicKey {
             publicKeyId: this._id,
         };
     }
+    /*
+      {
+        publicKey: Uint8Array
+        publicKeyId: string
+      }
+    */
+    toPublicKeyBytesHex() {
+        return {
+            publicKey: this.toBytesHex().data,
+            publicKeyId: this._id,
+        };
+    }
+    static _fromPublicKeyBytes(params) {
+        return TFHEPublicKey._fromBytes({
+            data: params.publicKey,
+            id: params.publicKeyId,
+            srcUrl: params.srcUrl,
+        });
+    }
+    static fromPublicKeyBytesHex(params) {
+        try {
+            assertRecordStringProperty(params, 'publicKey', `arg`);
+            assertRecordStringProperty(params, 'publicKeyId', `arg`);
+            return TFHEPublicKey._fromPublicKeyBytes({
+                publicKey: hexToBytesFaster(params.publicKey, true /* strict */),
+                publicKeyId: params.publicKeyId,
+            });
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    static fromPublicKeyBytes(params) {
+        try {
+            assertUint8ArrayProperty(params, 'publicKey', `arg`);
+            assertRecordStringProperty(params, 'publicKeyId', `arg`);
+            return TFHEPublicKey._fromPublicKeyBytes(params);
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // JSON
+    //////////////////////////////////////////////////////////////////////////////
+    /*
+      {
+        __type: 'TFHEPublicKey',
+        id: string,
+        data: BytesHex,
+        srcUrl?: string
+      }
+    */
+    toJSON() {
+        return {
+            __type: 'TFHEPublicKey',
+            ...this.toBytesHex(),
+        };
+    }
+    static fromJSON(json) {
+        if (json.__type !== 'TFHEPublicKey') {
+            throw new TFHEPublicKeyError({ message: 'Invalid TFHEPublicKey JSON.' });
+        }
+        return TFHEPublicKey.fromBytesHex(json);
+    }
 }
 
 //const __KEY_URL_CACHE__: Record<string, RelayerV2PublicKey> = {};
@@ -4722,7 +5576,7 @@ class RelayerV2PublicKey {
     toBytes() {
         return {
             publicKey: this._publicKey.toBytes(),
-            publicParams: this._crs2048.toPublicParamsBytes(),
+            publicParams: this._crs2048.toPublicParams2048Bytes(),
         };
     }
 }
@@ -4756,23 +5610,46 @@ class RelayerV2Fhevm extends AbstractRelayerFhevm {
     get relayerProvider() {
         return this._relayerProvider;
     }
+    getPublicKeyInfo() {
+        return {
+            id: this._relayerPublicKey.getTFHEPublicKey().id,
+            srcUrl: this._relayerPublicKey.getTFHEPublicKey().srcUrl,
+        };
+    }
     getPublicKeyBytes() {
         return this._relayerPublicKey.getTFHEPublicKey().toPublicKeyBytes();
     }
     getPublicKeyWasm() {
         return this._relayerPublicKey.getTFHEPublicKey().toPublicKeyWasm();
     }
-    getPublicParamsBytes(bits) {
+    getPublicParamsBytesForBits(bits) {
+        if (bits === undefined) {
+            throw new TFHECrsError({ message: `Missing PublicParams bits format` });
+        }
         if (bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '${bits}'`,
+            });
         }
-        return this._relayerPublicKey.getTFHECrs().toPublicParamsBytes()['2048'];
+        return this._relayerPublicKey.getTFHECrs().toPublicParams2048Bytes()['2048'];
     }
-    getPublicParamsWasm(bits) {
+    getPublicParamsWasmForBits(bits) {
+        if (bits === undefined) {
+            throw new TFHECrsError({ message: `Missing PublicParams bits format` });
+        }
         if (bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+            throw new TFHECrsError({
+                message: `Unsupported PublicParams bits format '${bits}'`,
+            });
         }
-        return this._relayerPublicKey.getTFHECrs().toPublicParamsWasm()['2048'];
+        return this._relayerPublicKey.getTFHECrs().toPublicParams2048Wasm()['2048'];
+    }
+    getPublicParamsInfo() {
+        return {
+            id: this._relayerPublicKey.getTFHECrs().id,
+            bits: this._relayerPublicKey.getTFHECrs().bits,
+            srcUrl: this._relayerPublicKey.getTFHECrs().srcUrl,
+        };
     }
 }
 
@@ -4811,24 +5688,42 @@ class RelayerV1Fhevm extends AbstractRelayerFhevm {
             publicKeyId: this._publicKeyData.publicKeyId,
         };
     }
+    getPublicKeyInfo() {
+        return {
+            id: this._publicKeyData.publicKeyId,
+        };
+    }
+    getPublicParamsInfo() {
+        return {
+            id: this._publicParamsData['2048'].publicParamsId,
+            bits: 2048,
+        };
+    }
     getPublicKeyWasm() {
         return {
             publicKey: this._publicKeyData.publicKey,
             publicKeyId: this._publicKeyData.publicKeyId,
         };
     }
-    getPublicParamsBytes(bits) {
+    getPublicParamsBytesForBits(bits) {
+        if (bits === undefined) {
+            throw new Error(`Missing PublicParams bits format`);
+        }
         if (bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+            throw new Error(`Unsupported PublicParams bits format '${bits}'`);
         }
-        return {
+        const res = {
             publicParams: this._publicParamsData['2048'].publicParams.safe_serialize(SERIALIZED_SIZE_LIMIT_CRS),
             publicParamsId: this._publicParamsData['2048'].publicParamsId,
         };
+        return res;
     }
-    getPublicParamsWasm(bits) {
+    getPublicParamsWasmForBits(bits) {
+        if (bits === undefined) {
+            throw new Error(`Missing PublicParams bits format`);
+        }
         if (bits !== 2048) {
-            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+            throw new Error(`Unsupported PublicParams bits format '${bits}'`);
         }
         return {
             publicParams: this._publicParamsData['2048'].publicParams,
@@ -4849,11 +5744,16 @@ async function createRelayerFhevm(config) {
             publicParams: config.publicParams,
         });
     }
-    return RelayerV1Fhevm.fromConfig({
-        relayerVersionUrl: resolved.url,
-        publicKey: config.publicKey,
-        publicParams: config.publicParams,
-    });
+    else if (resolved.version === 1) {
+        return RelayerV1Fhevm.fromConfig({
+            relayerVersionUrl: resolved.url,
+            publicKey: config.publicKey,
+            publicParams: config.publicParams,
+        });
+    }
+    else {
+        throw new Error(`Invalid relayerUrl: ${config.relayerUrl}`);
+    }
 }
 function _resolveRelayerUrl(value, defaultVersion) {
     if (!value || typeof value !== 'string') {
@@ -4884,60 +5784,39 @@ function _resolveRelayerUrl(value, defaultVersion) {
     };
 }
 
-/**
- * **FHE Type Mapping for Input Builders**
- * * Maps the **number of encrypted bits** used by a FHEVM primary type
- * to its corresponding **FheTypeId**. This constant is primarily used by
- * `EncryptedInput` and `RelayerEncryptedInput` builders to determine the correct
- * input type and calculate the total required bit-length.
- *
- * **Structure: \{ Encrypted Bit Length: FheTypeId \}**
- *
- * | Bits | FheTypeId | FHE Type Name | Note |
- * | :--- | :-------- | :------------ | :--- |
- * | 2    | 0         | `ebool`         | The boolean type. |
- * | (N/A)| 1         | `euint4`        | **Deprecated** and omitted from this map. |
- * | 8    | 2         | `euint8`        | |
- * | 16   | 3         | `euint16`       | |
- * | 32   | 4         | `euint32`       | |
- * | 64   | 5         | `euint64`       | |
- * | 128  | 6         | `euint128`      | |
- * | 160  | 7         | `eaddress`      | Used for encrypted Ethereum addresses. |
- * | 256  | 8         | `euint256`      | The maximum supported integer size. |
- */
-const ENCRYPTION_TYPES = {
-    2: 0, // ebool (FheTypeId=0) is using 2 encrypted bits
-    // euint4 (FheTypeId=1) is deprecated
-    8: 2, // euint8 (FheTypeId=2) is using 8 encrypted bits
-    16: 3, // euint16 (FheTypeId=3) is using 16 encrypted bits
-    32: 4, // euint32 (FheTypeId=4) is using 32 encrypted bits
-    64: 5, // euint64 (FheTypeId=5) is using 64 encrypted bits
-    128: 6, // euint128 (FheTypeId=128) is using 128 encrypted bits
-    160: 7, // eaddress (FheTypeId=7) is using 160 encrypted bits
-    256: 8, // euint256 (FheTypeId=8) is using 256 encrypted bits
+////////////////////////////////////////////////////////////////////////////////
+// MainnetConfig
+////////////////////////////////////////////////////////////////////////////////
+const MainnetConfig = {
+    aclContractAddress: '0xcA2E8f1F656CD25C01F05d0b243Ab1ecd4a8ffb6',
+    kmsContractAddress: '0x77627828a55156b04Ac0DC0eb30467f1a552BB03',
+    inputVerifierContractAddress: '0xCe0FC2e05CFff1B719EFF7169f7D80Af770c8EA2',
+    verifyingContractAddressDecryption: '0x0f6024a97684f7d90ddb0fAAD79cB15F2C888D24',
+    verifyingContractAddressInputVerification: '0xcB1bB072f38bdAF0F328CdEf1Fc6eDa1DF029287',
+    chainId: 1,
+    gatewayChainId: 261131,
+    network: 'https://ethereum-rpc.publicnode.com',
+    relayerUrl: 'https://relayer.mainnet.zama.org',
 };
-
+Object.freeze(MainnetConfig);
+////////////////////////////////////////////////////////////////////////////////
+// SepoliaConfig
+////////////////////////////////////////////////////////////////////////////////
 const SepoliaConfig = {
-    // ACL_CONTRACT_ADDRESS (FHEVM Host chain)
     aclContractAddress: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D',
-    // KMS_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
     kmsContractAddress: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A',
-    // INPUT_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
     inputVerifierContractAddress: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0',
-    // DECRYPTION_ADDRESS (Gateway chain)
     verifyingContractAddressDecryption: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478',
-    // INPUT_VERIFICATION_ADDRESS (Gateway chain)
     verifyingContractAddressInputVerification: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955',
-    // FHEVM Host chain id
     chainId: 11155111,
-    // Gateway chain id
     gatewayChainId: 10901,
-    // Optional RPC provider to host chain
     network: 'https://ethereum-sepolia-rpc.publicnode.com',
-    // Relayer URL
     relayerUrl: 'https://relayer.testnet.zama.org',
 };
 Object.freeze(SepoliaConfig);
+////////////////////////////////////////////////////////////////////////////////
+// createInstance
+////////////////////////////////////////////////////////////////////////////////
 const createInstance = async (config) => {
     const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, inputVerifierContractAddress, kmsContractAddress, aclContractAddress, gatewayChainId, auth, } = config;
     if (!isChecksummedAddress(aclContractAddress)) {
@@ -4969,29 +5848,33 @@ const createInstance = async (config) => {
         defaultRelayerVersion: 1,
     });
     const chainId = await getChainId(provider, config);
-    // const relayerVersionUrl = `${config.relayerUrl!}/v1`;
-    // const publicKeyData = await getTfheCompactPublicKey({
-    //   relayerVersionUrl: relayerFhevm.relayerVersionUrl,
-    //   publicKey: config.publicKey,
-    // });
-    //const aaa = relayerFhevm.getPublicKey();
-    // const publicParamsData = await getPublicParams({
-    //   relayerVersionUrl,
-    //   publicParams: config.publicParams,
-    // });
     const kmsSigners = await getKMSSigners(provider, kmsContractAddress);
     const thresholdKMSSigners = await getKMSSignersThreshold(provider, kmsContractAddress);
     const coprocessorSigners = await getCoprocessorSigners(provider, inputVerifierContractAddress);
     const thresholdCoprocessorSigners = await getCoprocessorSignersThreshold(provider, inputVerifierContractAddress);
     return {
-        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, 
-        //cleanURL(config.relayerUrl),
-        //relayerFhevm.relayerVersionUrl,
-        relayerFhevm.relayerProvider, 
-        //publicKeyData.publicKey,
-        relayerFhevm.getPublicKeyWasm().publicKey, 
-        //publicParamsData,
-        { 2048: relayerFhevm.getPublicParamsWasm(2048) }, coprocessorSigners, thresholdCoprocessorSigners),
+        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerFhevm.relayerProvider, relayerFhevm.getPublicKeyWasm().publicKey, { 2048: relayerFhevm.getPublicParamsWasmForBits(2048) }, coprocessorSigners, thresholdCoprocessorSigners, auth && { auth }),
+        requestZKProofVerification: (zkProof, options) => {
+            if (zkProof.chainId !== chainId ||
+                zkProof.aclContractAddress !== aclContractAddress) {
+                throw new Error('Invalid ZKProof');
+            }
+            return requestCiphertextWithZKProofVerification({
+                ciphertext: zkProof.ciphertextWithZkProof,
+                aclContractAddress: aclContractAddress,
+                contractAddress: zkProof.contractAddress,
+                userAddress: zkProof.userAddress,
+                chainId,
+                gatewayChainId,
+                bits: zkProof.bits,
+                coprocessorSigners,
+                extraData: '0x00',
+                thresholdCoprocessorSigners,
+                relayerProvider: relayerFhevm.relayerProvider,
+                verifyingContractAddressInputVerification: verifyingContractAddressInputVerification,
+                options,
+            });
+        },
         generateKeypair,
         createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
         publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, 
@@ -5001,7 +5884,7 @@ const createInstance = async (config) => {
         //cleanURL(config.relayerUrl),
         relayerFhevm.relayerProvider, provider, auth && { auth }),
         getPublicKey: () => relayerFhevm.getPublicKeyBytes(),
-        getPublicParams: (bits) => relayerFhevm.getPublicParamsBytes(bits),
+        getPublicParams: (bits) => relayerFhevm.getPublicParamsBytesForBits(bits),
         // getPublicKey: () =>
         //   publicKeyData.publicKey
         //     ? {
@@ -5039,10 +5922,10 @@ const createTfheKeypair = () => {
 };
 const createTfhePublicKey = () => {
     const { publicKey } = createTfheKeypair();
-    return toHexString(publicKey.serialize());
+    return bytesToHexNo0x(publicKey.serialize());
 };
 
 global.TFHE = TFHEPkg;
 global.TKMS = TKMSPkg;
 
-export { ENCRYPTION_TYPES, SepoliaConfig, createEIP712, createInstance, createTfheKeypair, createTfhePublicKey, generateKeypair, getErrorCauseCode, getErrorCauseStatus };
+export { MainnetConfig, SepoliaConfig, createEIP712, createInstance, createTfheKeypair, createTfhePublicKey, generateKeypair, getErrorCauseCode, getErrorCauseStatus };