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

package/lib/web.js

@@ -16255,7 +16255,7 @@ const SERIALIZED_SIZE_LIMIT_PK = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_CRS = BigInt(1024 * 1024 * 512);
 
 // This file is auto-generated
-const version = '0.4.0-alpha.1';
+const version = '0.4.0-alpha.2';
 const sdkName = '@zama-fhe/relayer-sdk';
 
 function getErrorCause(e) {
@@ -17057,9 +17057,9 @@ function assertRecordStringArrayProperty(o, property, objName) {
         }
     }
 }
-function safeJSONstringify(o) {
+function safeJSONstringify(o, space) {
     try {
-        return JSON.stringify(o, (_, v) => typeof v === 'bigint' ? v.toString() : v);
+        return JSON.stringify(o, (_, v) => (typeof v === 'bigint' ? v.toString() : v), space);
     }
     catch {
         return '';
@@ -17175,6 +17175,17 @@ const NumEncryptedBits = {
     7: 160, // eaddress
     8: 256, // euint256
 };
+// 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) {
@@ -17232,7 +17243,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)) {
@@ -17465,6 +17476,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).
  */
@@ -17484,15 +17543,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
  */
@@ -17506,9 +17599,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) {
@@ -17600,8 +17690,8 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
     const publicKeySanitized = publicKey.replace(/^(0x)/, '');
     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(handleContractPairs.map((h) => h.handle));
@@ -17817,9 +17907,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;
 }
@@ -17853,25 +17942,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) {
@@ -17969,63 +18052,213 @@ function checksummedAddressToBytes20(address) {
 class FhevmHandleError extends RelayerErrorBase {
     constructor({ handle, message }) {
         super({
-            message: message ?? `FHEVM Handle "${handle}" is invalid.`,
+            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 FheTypeIdToSolidityPrimitiveType = {
-        0: 'bool',
-        2: 'uint256',
-        3: 'uint256',
-        4: 'uint256',
-        5: 'uint256',
-        6: 'uint256',
-        7: 'address',
-        8: 'uint256',
-    };
-    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;
@@ -18035,6 +18268,9 @@ class FhevmHandle {
             this._index = index;
         }
     }
+    //////////////////////////////////////////////////////////////////////////////
+    // Instance Getters
+    //////////////////////////////////////////////////////////////////////////////
     get hash21() {
         return this._hash21;
     }
@@ -18044,6 +18280,9 @@ class FhevmHandle {
     get fheTypeId() {
         return this._fheTypeId;
     }
+    get fheTypeName() {
+        return fheTypeNameFromId(this._fheTypeId);
+    }
     get version() {
         return this._version;
     }
@@ -18053,6 +18292,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);
@@ -18062,7 +18401,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({
@@ -18093,22 +18432,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);
@@ -18129,62 +18515,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());
-    }
-    static checkHandleHex(handle) {
-        if (!isBytes32Hex(handle)) {
-            throw new FhevmHandleError({ handle });
-        }
-    }
-    static 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;
-        }
-    }
-    static getFheTypeId(handle) {
-        if (!isBytes32Hex(handle)) {
-            throw new FhevmHandleError({ handle });
-        }
-        const hexPair = handle.slice(-4, -2).toLowerCase();
-        const typeDiscriminant = parseInt(hexPair, 16);
-        if (!FhevmHandle.isFheTypeId(typeDiscriminant)) {
-            throw new FhevmHandleError({
-                handle,
-                message: `FHEVM Handle "${handle}" is invalid. Unknown FheType: ${typeDiscriminant}`,
-            });
-        }
-        return typeDiscriminant;
+        const hashBytes32Hex = keccak256(concatBytes(domainSepBytes, blobHashBytes32, encryptionIndexByte1, aclContractAddressBytes20, chainIdBytes32));
+        // Truncate to 21 bytes (0x + 42 hex chars)
+        return hashBytes32Hex.slice(0, 2 + 2 * 21);
     }
 }
 
@@ -18193,6 +18529,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) => {
@@ -18276,8 +18695,15 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
         getBits() {
             return input.getBits();
         },
-        getCiphertextWithInputVerification() {
-            return input.encrypt();
+        generateZKProof() {
+            return {
+                chainId,
+                aclContractAddress: aclContractAddress,
+                userAddress: userAddress,
+                contractAddress: contractAddress,
+                ciphertextWithZkProof: input.encrypt(),
+                bits: input.getBits(),
+            };
         },
         encrypt: async (options) => {
             const extraData = '0x00';
@@ -18286,7 +18712,7 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
             const payload = {
                 contractAddress: getAddress(contractAddress),
                 userAddress: getAddress(userAddress),
-                ciphertextWithInputVerification: toHexString(ciphertext),
+                ciphertextWithInputVerification: bytesToHexNo0x(ciphertext),
                 contractChainId: ('0x' + chainId.toString(16)),
                 extraData,
             };
@@ -18315,8 +18741,8 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
                 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)`);
                     }
@@ -18355,10 +18781,10 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
                 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
@@ -18411,7 +18837,7 @@ function abiEncodeClearValues(clearValues) {
     const abiValues = [];
     for (let i = 0; i < handlesBytes32Hex.length; ++i) {
         const handle = handlesBytes32Hex[i];
-        const handleType = FhevmHandle.getFheTypeId(handle);
+        const handleType = FhevmHandle.parse(handle).fheTypeId;
         let clearTextValue = clearValues[handle];
         if (typeof clearTextValue === 'boolean') {
             clearTextValue = clearTextValue ? '0x01' : '0x00';
@@ -18474,24 +18900,23 @@ function buildDecryptionProof(kmsSignatures, extraData) {
     return decryptionProof;
 }
 function deserializeClearValues(handles, decryptedResult) {
-    let typesList = [];
+    let fheTypeIdList = [];
     for (const handle of handles) {
-        const typeDiscriminant = FhevmHandle.getFheTypeId(handle);
-        assertRelayer(FhevmHandle.isFheTypeId(typeDiscriminant));
-        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 = FhevmHandle.FheTypeIdToSolidityPrimitiveType[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;
@@ -18499,12 +18924,13 @@ function deserializeClearValues(handles, decryptedResult) {
 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!`);
@@ -18662,8 +19088,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)),
     };
 };
 
@@ -19327,7 +19753,28 @@ function assertIsRelayerV2GetResponseQueued(value, name) {
     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;
@@ -19342,17 +19789,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' &&
@@ -19369,14 +19817,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,
@@ -19385,6 +19833,7 @@ class RelayerV2AsyncRequest {
             running: false,
             succeeded: false,
             terminated: false,
+            timeout: false,
         };
         this._retryCount = 0;
         this._retryAfterTimeoutID = undefined;
@@ -19392,9 +19841,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
@@ -19436,6 +19885,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}).`,
@@ -19456,7 +19911,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;
@@ -19527,6 +19982,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;
     }
@@ -19547,6 +20008,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) {
@@ -19582,9 +20045,7 @@ class RelayerV2AsyncRequest {
                             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
@@ -19597,11 +20058,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;
                 }
@@ -19647,22 +20107,20 @@ class RelayerV2AsyncRequest {
                             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
@@ -19741,8 +20199,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;
@@ -19852,9 +20312,7 @@ class RelayerV2AsyncRequest {
                             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',
@@ -19864,12 +20322,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: {
@@ -20021,17 +20479,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 {
@@ -20040,7 +20501,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
@@ -20079,7 +20540,7 @@ 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: {
@@ -20091,7 +20552,7 @@ class RelayerV2AsyncRequest {
             ...(this._internalAbortSignal
                 ? { signal: this._internalAbortSignal }
                 : {}),
-        }, this._fhevmInstanceOptions?.auth);
+        }, this._fhevmAuth);
         this._state.fetching = true;
         let response;
         try {
@@ -20218,7 +20679,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
@@ -20242,7 +20714,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;
@@ -20264,7 +20736,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.`));
@@ -20284,7 +20756,7 @@ class RelayerV2AsyncRequest {
         return p;
     }
     //////////////////////////////////////////////////////////////////////////////
-    _tryClearRetryAfterTimeout() {
+    _tryClearRetryAfterTimeout(error) {
         if (this._retryAfterTimeoutID === undefined) {
             // Debug
             this._assert(this._retryAfterTimeoutPromiseFuncReject === undefined, 'this._retryAfterTimeoutPromiseFuncReject === undefined');
@@ -20295,7 +20767,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
@@ -20310,7 +20783,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) {
@@ -20518,37 +21008,34 @@ class RelayerV2Provider extends AbstractRelayerProvider {
         const response = await this.fetchGetKeyUrlV2();
         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()');
@@ -20556,6 +21043,16 @@ class RelayerV2Provider extends AbstractRelayerProvider {
     }
 }
 
+class TFHECrsError extends RelayerErrorBase {
+    constructor({ message, cause }) {
+        super({
+            message,
+            name: 'TFHECrsError',
+            ...(cause ? { cause: ensureError(cause) } : {}),
+        });
+    }
+}
+
 class AbstractRelayerFhevm {
 }
 
@@ -20570,6 +21067,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,
@@ -20672,19 +21178,57 @@ 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 = {
@@ -20701,7 +21245,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,
             });
         }
@@ -20719,7 +21306,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,
             });
         }
@@ -20750,6 +21338,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: {
@@ -20758,9 +21362,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: {
@@ -20778,9 +21384,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: {
@@ -20790,6 +21398,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 {
@@ -20801,6 +21467,12 @@ class TFHEPublicKey {
         this._tfheCompactPublicKey = params.tfheCompactPublicKey;
         this._srcUrl = params.srcUrl;
     }
+    get id() {
+        return this._id;
+    }
+    get srcUrl() {
+        return this._srcUrl;
+    }
     /*
       {
         id: string,
@@ -20885,6 +21557,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,
@@ -20945,6 +21641,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
@@ -20969,6 +21679,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> = {};
@@ -21044,7 +21823,7 @@ class RelayerV2PublicKey {
     toBytes() {
         return {
             publicKey: this._publicKey.toBytes(),
-            publicParams: this._crs2048.toPublicParamsBytes(),
+            publicParams: this._crs2048.toPublicParams2048Bytes(),
         };
     }
 }
@@ -21078,23 +21857,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,
+        };
     }
 }
 
@@ -21133,24 +21935,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,
@@ -21171,11 +21991,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') {
@@ -21275,7 +22100,28 @@ const createInstance = async (config) => {
     const coprocessorSigners = await getCoprocessorSigners(provider, inputVerifierContractAddress);
     const thresholdCoprocessorSigners = await getCoprocessorSignersThreshold(provider, inputVerifierContractAddress);
     return {
-        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerFhevm.relayerProvider, relayerFhevm.getPublicKeyWasm().publicKey, { 2048: relayerFhevm.getPublicParamsWasm(2048) }, coprocessorSigners, thresholdCoprocessorSigners, auth && { auth }),
+        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, 
@@ -21285,7 +22131,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
         //     ? {