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

package/lib/web.js

@@ -1,6 +1,4 @@
-import { JsonRpcProvider, BrowserProvider, Contract, getAddress as getAddress$2, ethers, isAddress, AbiCoder } from 'ethers';
-import createHash from 'keccak';
-import fetchRetry from 'fetch-retry';
+import { JsonRpcProvider, BrowserProvider, Contract, getAddress as getAddress$2, ethers, isAddress as isAddress$1, keccak256, AbiCoder } from 'ethers';
 import { threads } from 'wasm-feature-detect';
 
 var global$1 = (typeof global !== "undefined" ? global :
@@ -16255,36 +16253,6 @@ async function __wbg_init(module_or_path) {
 const SERIALIZED_SIZE_LIMIT_CIPHERTEXT = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_PK = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_CRS = BigInt(1024 * 1024 * 512);
-const cleanURL = (url) => {
-    if (!url)
-        return '';
-    return url.endsWith('/') ? url.slice(0, -1) : url;
-};
-const numberToHex = (num) => {
-    let hex = num.toString(16);
-    return hex.length % 2 ? '0' + hex : hex;
-};
-const fromHexString = (hexString) => {
-    const arr = hexString.replace(/^(0x)/, '').match(/.{1,2}/g);
-    if (!arr)
-        return new Uint8Array();
-    return Uint8Array.from(arr.map((byte) => parseInt(byte, 16)));
-};
-function toHexString(bytes, with0x = false) {
-    return `${with0x ? '0x' : ''}${bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')}`;
-}
-const bytesToBigInt = function (byteArray) {
-    if (!byteArray || byteArray?.length === 0) {
-        return BigInt(0);
-    }
-    const hex = Array.from(byteArray)
-        .map((b) => b.toString(16).padStart(2, '0')) // byte to hex
-        .join('');
-    return BigInt(`0x${hex}`);
-};
-function ensure0x(s) {
-    return !s.startsWith('0x') ? `0x${s}` : s;
-}
 
 function setAuth(init, auth) {
     if (auth) {
@@ -16365,18 +16333,27 @@ async function throwRelayerResponseError(operation, response) {
             }
         }
     }
+    let responseJson;
+    try {
+        responseJson = await response.json();
+    }
+    catch {
+        responseJson = '';
+    }
     const cause = {
         code: 'RELAYER_FETCH_ERROR',
         operation,
         status: response.status,
         statusText: response.statusText,
         url: response.url,
+        response,
+        responseJson,
     };
     throw new Error(message, {
         cause,
     });
 }
-function throwRelayerJSONError(operation, error) {
+function throwRelayerJSONError(operation, error, response) {
     let message;
     switch (operation) {
         case 'PUBLIC_DECRYPT': {
@@ -16396,6 +16373,7 @@ function throwRelayerJSONError(operation, error) {
         code: 'RELAYER_NO_JSON_ERROR',
         operation,
         error,
+        response,
     };
     throw new Error(message, {
         cause,
@@ -16482,7 +16460,8 @@ function throwRelayerUnknownError(operation, error, message) {
     });
 }
 
-function assertIsRelayerFetchResponseJson(json) {
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV1FetchResponseJson(json) {
     if (!json || typeof json !== 'object') {
         throw new Error('Unexpected response JSON.');
     }
@@ -16516,10 +16495,10 @@ async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options)
         parsed = await response.json();
     }
     catch (e) {
-        throwRelayerJSONError(relayerOperation, e);
+        throwRelayerJSONError(relayerOperation, e, response);
     }
     try {
-        assertIsRelayerFetchResponseJson(parsed);
+        assertIsRelayerV1FetchResponseJson(parsed);
         json = parsed;
     }
     catch (e) {
@@ -16534,6 +16513,7 @@ async function fetchRelayerGet(relayerOperation, url) {
         response = await fetch(url);
     }
     catch (e) {
+        console.log(e);
         throwRelayerUnknownError(relayerOperation, e);
     }
     if (!response.ok) {
@@ -16544,10 +16524,10 @@ async function fetchRelayerGet(relayerOperation, url) {
         parsed = await response.json();
     }
     catch (e) {
-        throwRelayerJSONError(relayerOperation, e);
+        throwRelayerJSONError(relayerOperation, e, response);
     }
     try {
-        assertIsRelayerFetchResponseJson(parsed);
+        assertIsRelayerV1FetchResponseJson(parsed);
         json = parsed;
     }
     catch (e) {
@@ -16556,49 +16536,13 @@ async function fetchRelayerGet(relayerOperation, url) {
     return json;
 }
 
-// export type RelayerKeysItem = {
-//   data_id: string;
-//   param_choice: number;
-//   urls: string[];
-//   signatures: string[];
-// };
-// export type RelayerKey = {
-//   data_id: string;
-//   param_choice: number;
-//   signatures: string[];
-//   urls: string[];
-// };
-// export type RelayerKeys = {
-//   response: {
-//     fhe_key_info: {
-//       fhe_public_key: RelayerKey;
-//       fhe_server_key: RelayerKey;
-//     }[];
-//     verf_public_key: {
-//       key_id: string;
-//       server_id: number;
-//       verf_public_key_address: string;
-//       verf_public_key_url: string;
-//     }[];
-//     crs: {
-//       [key: string]: RelayerKeysItem;
-//     };
-//   };
-//   status: string;
-// };
 const keyurlCache = {};
-const getKeysFromRelayer = async (url, publicKeyId) => {
-    if (keyurlCache[url]) {
-        return keyurlCache[url];
+const getKeysFromRelayer = async (versionUrl, publicKeyId) => {
+    if (keyurlCache[versionUrl]) {
+        return keyurlCache[versionUrl];
     }
-    const data = await fetchRelayerGet('KEY_URL', `${url}/v1/keyurl`);
+    const data = await fetchRelayerGet('KEY_URL', `${versionUrl}/keyurl`);
     try {
-        // const response = await fetch(`${url}/v1/keyurl`);
-        // if (!response.ok) {
-        //   await throwRelayerResponseError("KEY_URL", response);
-        // }
-        //const data: RelayerKeys = await response.json();
-        //if (data) {
         let pubKeyUrl;
         // If no publicKeyId is provided, use the first one
         // Warning: if there are multiple keys available, the first one will most likely never be the
@@ -16670,11 +16614,8 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
                 },
             },
         };
-        keyurlCache[url] = result;
+        keyurlCache[versionUrl] = result;
         return result;
-        // } else {
-        //   throw new Error('No public key available');
-        // }
     }
     catch (e) {
         throw new Error('Impossible to fetch public key: wrong relayer url.', {
@@ -16683,6 +16624,422 @@ const getKeysFromRelayer = async (url, publicKeyId) => {
     }
 };
 
+class RelayerErrorBase extends Error {
+    name = 'RelayerErrorBase';
+    _details;
+    _docsPath;
+    _docsUrl;
+    _version;
+    static VERSION = '0.3.0-6';
+    static DEFAULT_DOCS_BASE_URL = 'https//docs.zama.org';
+    static FULL_VERSION = `@zama-fhe/relayer-sdk@${RelayerErrorBase.VERSION}`;
+    constructor(params) {
+        let details;
+        let docsPath;
+        if (params.cause instanceof RelayerErrorBase) {
+            docsPath = params.docsPath || params.cause.docsPath;
+            details = params.details || params.cause.details;
+        }
+        else {
+            docsPath = params.docsPath;
+            details = params.details || params.cause?.message;
+        }
+        const docsUrl = docsPath
+            ? `${params.docsBaseUrl ?? RelayerErrorBase.DEFAULT_DOCS_BASE_URL}${docsPath}${params.docsSlug ? `#${params.docsSlug}` : ''}`
+            : undefined;
+        const message = [
+            params.message || 'An error occurred.',
+            '',
+            ...(params.metaMessages ? [...params.metaMessages, ''] : []),
+            ...(docsUrl ? [`Docs: ${docsUrl}`] : []),
+            ...(details ? [`Details: ${details}`] : []),
+            `Version: ${RelayerErrorBase.FULL_VERSION}`,
+        ].join('\n');
+        super(message, params.cause ? { cause: params.cause } : undefined);
+        // This line is critical. If removed 'instanceof' will always fail
+        // Restore prototype chain (required when extending Error in TypeScript)
+        Object.setPrototypeOf(this, new.target.prototype);
+        this._details = details;
+        this._docsPath = docsPath;
+        this._docsUrl = docsUrl;
+        this._version = RelayerErrorBase.VERSION;
+        this.name = params.name ?? this.name;
+    }
+    get docsPath() {
+        return this._docsPath;
+    }
+    get docsUrl() {
+        return this._docsUrl;
+    }
+    get details() {
+        return this._details;
+    }
+    get version() {
+        return this._version;
+    }
+}
+
+class InvalidPropertyError extends RelayerErrorBase {
+    _objName;
+    _property;
+    _expectedType;
+    _index;
+    _value;
+    _type;
+    _expectedValue;
+    constructor({ objName, property, index, type, value, expectedValue, expectedType, }) {
+        let missing = type === 'undefined' && expectedValue !== undefined;
+        let varname;
+        if (!property || property === '') {
+            varname = index !== undefined ? `${objName}[${index}]` : `${objName}`;
+        }
+        else {
+            varname =
+                index !== undefined
+                    ? `${objName}.${property}[${index}]`
+                    : `${objName}.${property}`;
+        }
+        let message = missing
+            ? `InvalidPropertyError: Missing '${varname}'`
+            : `InvalidPropertyError: ${varname}`;
+        if (type === expectedType) {
+            if (value !== undefined) {
+                message += ` unexpected value ${value}`;
+            }
+        }
+        else {
+            if (missing) {
+                if (Array.isArray(expectedValue)) {
+                    expectedValue = expectedValue.join('|');
+                }
+                message += `, expected '${varname}: ${expectedValue}'.`;
+            }
+            else if (expectedType !== 'unknown' && type !== 'unknown') {
+                message += ` not a ${expectedType}`;
+                if (type) {
+                    message += `, type is ${type}`;
+                }
+            }
+        }
+        super({
+            message,
+            name: 'InvalidPropertyError',
+        });
+        this._objName = objName;
+        this._property = property;
+        this._value = value;
+        this._type = type;
+        this._expectedValue = expectedValue;
+        this._expectedType = expectedType;
+        this._index = index;
+    }
+    static missingProperty({ objName, property, expectedType, expectedValue, }) {
+        return new InvalidPropertyError({
+            objName,
+            property,
+            expectedType,
+            expectedValue,
+            type: 'undefined',
+        });
+    }
+    static invalidFormat({ objName, property, }) {
+        return new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'unknown',
+        });
+    }
+    static invalidObject({ objName, expectedType, type, }) {
+        return new InvalidPropertyError({
+            objName,
+            property: '',
+            expectedType,
+            type,
+        });
+    }
+}
+
+/**
+ * Type guard that checks if a property exists on an object and is non-null/non-undefined.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to check (can be any type)
+ * @param property - The property name to check for
+ * @returns True if `o` is an object with the specified property that is not null or undefined
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { name: "Alice", age: 30 };
+ * if (isNonNullableRecordProperty(data, 'name')) {
+ *   console.log(data.name); // OK
+ * }
+ * ```
+ */
+function isNonNullableRecordProperty(o, property) {
+    if (!o ||
+        typeof o !== 'object' ||
+        !(property in o) ||
+        o[property] === undefined ||
+        o[property] === null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Assertion function that validates a property exists on an object and is non-null/non-undefined.
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @throws {InvalidPropertyError} When the property is missing, null, or undefined
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * function processUser(data: unknown) {
+ *   assertNonNullableRecordProperty(data, 'userId', 'user');
+ *   console.log(data.userId);
+ * }
+ * ```
+ */
+function assertNonNullableRecordProperty(o, property, objName) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'non-nullable',
+            type: typeofProperty(o, property),
+        });
+    }
+}
+/**
+ * Type guard that checks if a property exists on an object and is an array.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to check (can be any type)
+ * @param property - The property name to check for
+ * @returns True if `o` is an object with the specified property that is a non-null array
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { items: [1, 2, 3], count: 42 };
+ * if (isRecordArrayProperty(data, 'items')) {
+ *   console.log(data.items.length); // OK
+ *   data.items.forEach(item => console.log(item)); // OK
+ * }
+ * ```
+ */
+function isRecordArrayProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return Array.isArray(o[property]);
+}
+/**
+ * Assertion function that validates a property exists on an object and is an array.
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @throws {InvalidPropertyError} When the property is missing, null, or not an array
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * function processResults(data: unknown) {
+ *   assertRecordArrayProperty(data, 'results', 'response');
+ *   console.log(`Found ${data.results.length} results`);
+ *   data.results.forEach(result => processResult(result));
+ * }
+ * ```
+ */
+function assertRecordArrayProperty(o, property, objName) {
+    if (!isRecordArrayProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'Array',
+            type: typeofProperty(o, property),
+        });
+    }
+}
+function isRecordBooleanProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return typeof o[property] === 'boolean';
+}
+function assertRecordBooleanProperty(o, property, objName, expectedValue) {
+    if (!isRecordBooleanProperty(o, property))
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'boolean',
+            type: typeofProperty(o, property),
+        });
+    if (expectedValue !== undefined) {
+        if (o[property] !== expectedValue) {
+            throw new InvalidPropertyError({
+                objName,
+                property,
+                expectedType: 'boolean',
+                expectedValue: String(expectedValue),
+                type: typeof o[property],
+                value: String(o[property]),
+            });
+        }
+    }
+}
+function typeofProperty(o, property) {
+    if (isNonNullableRecordProperty(o, property)) {
+        return typeof o[property];
+    }
+    return 'undefined';
+}
+
+class InternalError extends RelayerErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'InternalError',
+            message: params.message ?? 'internal error',
+        });
+    }
+}
+function assertRelayer(condition) {
+    if (!condition) {
+        throw new InternalError({ message: 'Assertion failed' });
+    }
+}
+
+function removeSuffix(s, suffix) {
+    if (!s) {
+        return '';
+    }
+    if (suffix.length === 0) {
+        return s;
+    }
+    return s.endsWith(suffix) ? s.slice(0, -suffix.length) : s;
+}
+function is0x(s) {
+    return typeof s === 'string' && s.startsWith('0x');
+}
+function isNo0x(s) {
+    return typeof s === 'string' && !s.startsWith('0x');
+}
+function ensure0x(s) {
+    return !s.startsWith('0x') ? `0x${s}` : s;
+}
+function remove0x(s) {
+    return s.startsWith('0x') ? s.substring(2) : s;
+}
+/**
+ * Type guard that checks if a property exists on an object and is a string.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to check (can be any type)
+ * @param property - The property name to check for
+ * @returns True if `o` is an object with the specified property that is a non-null string
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { status: "active", count: 42 };
+ * if (isRecordStringProperty(data, 'status')) {
+ *   console.log(data.status.toUpperCase()); // OK
+ * }
+ * ```
+ */
+function isRecordStringProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return typeof o[property] === 'string';
+}
+/**
+ * Assertion function that validates a property exists on an object, is a string,
+ * and optionally matches specific expected value(s).
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @param expectedValue - Optional specific string value or array of allowed values to match against
+ * @throws {InvalidPropertyError} When the property is missing, not a string, or doesn't match expectedValue
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * // Check property is a string (any value)
+ * assertRecordStringProperty(data, 'name', 'user');
+ *
+ * // Check property equals a specific value
+ * assertRecordStringProperty(data, 'status', 'response', 'active');
+ *
+ * // Check property is one of multiple allowed values
+ * assertRecordStringProperty(data, 'status', 'response', ['queued', 'processing', 'completed']);
+ * ```
+ */
+function assertRecordStringProperty(o, property, objName, expectedValue) {
+    if (!isRecordStringProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'string',
+            expectedValue,
+            type: typeofProperty(o, property),
+        });
+    }
+    if (expectedValue !== undefined) {
+        if (Array.isArray(expectedValue)) {
+            // Check if value matches any of the allowed values
+            for (let i = 0; i < expectedValue.length; ++i) {
+                if (o[property] === expectedValue[i]) {
+                    return;
+                }
+            }
+            throw new InvalidPropertyError({
+                objName,
+                property,
+                expectedType: 'string',
+                expectedValue,
+                type: typeof o[property], // === "string"
+                value: o[property],
+            });
+        }
+        else {
+            if (o[property] !== expectedValue) {
+                throw new InvalidPropertyError({
+                    objName,
+                    property,
+                    expectedType: 'string',
+                    expectedValue,
+                    type: typeof o[property], // === "string"
+                    value: o[property],
+                });
+            }
+        }
+    }
+}
+function assertRecordStringArrayProperty(o, property, objName) {
+    assertRecordArrayProperty(o, property, objName);
+    const arr = o[property];
+    for (let i = 0; i < arr.length; ++i) {
+        if (typeof arr[i] !== 'string') {
+            throw new InvalidPropertyError({
+                objName,
+                property: `${property}[${i}]`,
+                expectedType: 'string',
+                type: typeof arr[i],
+            });
+        }
+    }
+}
+
 const abiKmsVerifier = [
     'function getKmsSigners() view returns (address[])',
     'function getThreshold() view returns (uint256)',
@@ -16691,12 +17048,12 @@ const abiInputVerifier = [
     'function getCoprocessorSigners() view returns (address[])',
     'function getThreshold() view returns (uint256)',
 ];
-const getProvider = (config) => {
-    if (typeof config.network === 'string') {
-        return new JsonRpcProvider(config.network);
+const getProvider = (network) => {
+    if (typeof network === 'string') {
+        return new JsonRpcProvider(network);
     }
-    else if (config.network) {
-        return new BrowserProvider(config.network);
+    else if (network) {
+        return new BrowserProvider(network);
     }
     throw new Error('You must provide a network URL or a EIP1193 object (eg: window.ethereum)');
 };
@@ -16713,8 +17070,8 @@ const getChainId = async (provider, config) => {
     }
 };
 const getTfheCompactPublicKey = async (config) => {
-    if (config.relayerUrl && !config.publicKey) {
-        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
+    if (config.relayerVersionUrl && !config.publicKey) {
+        const inputs = await getKeysFromRelayer(removeSuffix(config.relayerVersionUrl, '/'));
         return { publicKey: inputs.publicKey, publicKeyId: inputs.publicKeyId };
     }
     else if (config.publicKey && config.publicKey.data && config.publicKey.id) {
@@ -16736,8 +17093,8 @@ const getTfheCompactPublicKey = async (config) => {
     }
 };
 const getPublicParams = async (config) => {
-    if (config.relayerUrl && !config.publicParams) {
-        const inputs = await getKeysFromRelayer(cleanURL(config.relayerUrl));
+    if (config.relayerVersionUrl && !config.publicParams) {
+        const inputs = await getKeysFromRelayer(removeSuffix(config.relayerVersionUrl, '/'));
         return inputs.publicParams;
     }
     else if (config.publicParams && config.publicParams['2048']) {
@@ -16760,23 +17117,23 @@ const getPublicParams = async (config) => {
         throw new Error('You must provide a valid CRS with its CRS ID.');
     }
 };
-const getKMSSigners = async (provider, config) => {
-    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
+const getKMSSigners = async (provider, kmsContractAddress) => {
+    const kmsContract = new Contract(kmsContractAddress, abiKmsVerifier, provider);
     const signers = await kmsContract.getKmsSigners();
     return signers;
 };
-const getKMSSignersThreshold = async (provider, config) => {
-    const kmsContract = new Contract(config.kmsContractAddress, abiKmsVerifier, provider);
+const getKMSSignersThreshold = async (provider, kmsContractAddress) => {
+    const kmsContract = new Contract(kmsContractAddress, abiKmsVerifier, provider);
     const threshold = await kmsContract.getThreshold();
     return Number(threshold); // threshold is always supposed to fit in a number
 };
-const getCoprocessorSigners = async (provider, config) => {
-    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
+const getCoprocessorSigners = async (provider, inputVerifierContractAddress) => {
+    const inputContract = new Contract(inputVerifierContractAddress, abiInputVerifier, provider);
     const signers = await inputContract.getCoprocessorSigners();
     return signers;
 };
-const getCoprocessorSignersThreshold = async (provider, config) => {
-    const inputContract = new Contract(config.inputVerifierContractAddress, abiInputVerifier, provider);
+const getCoprocessorSignersThreshold = async (provider, inputVerifierContractAddress) => {
+    const inputContract = new Contract(inputVerifierContractAddress, abiInputVerifier, provider);
     const threshold = await inputContract.getThreshold();
     return Number(threshold); // threshold is always supposed to fit in a number
 };
@@ -16823,119 +17180,465 @@ function checkEncryptedBits(handles) {
     return total;
 }
 
-// Add type checking
-const getAddress$1 = (value) => getAddress$2(value);
-const aclABI$1 = [
-    'function persistAllowed(bytes32 handle, address account) view returns (bool)',
-];
-const MAX_USER_DECRYPT_CONTRACT_ADDRESSES = 10;
-const MAX_USER_DECRYPT_DURATION_DAYS = BigInt(365);
-function formatAccordingToType(clearValueAsBigInt, type) {
-    if (type === 0) {
-        // ebool
-        return clearValueAsBigInt === BigInt(1);
+class InvalidTypeError extends RelayerErrorBase {
+    _objName;
+    _type;
+    _expectedType;
+    _expectedCustomType;
+    constructor({ objName, type, expectedType, expectedCustomType, }) {
+        super({
+            message: `InvalidTypeError ${objName} ${expectedType} ${type}`,
+            name: 'InvalidTypeError',
+        });
+        this._objName = objName;
+        this._type = type;
+        this._expectedType = expectedType;
+        this._expectedCustomType = expectedCustomType;
     }
-    else if (type === 7) {
-        // eaddress
-        return getAddress$1('0x' + clearValueAsBigInt.toString(16).padStart(40, '0'));
+    get objName() {
+        return this._objName;
     }
-    else if (type > 8 || type == 1) {
-        // type == 1 : euint4 (not supported)
-        throw new Error(`Unsupported handle type ${type}`);
+    get type() {
+        return this._type;
+    }
+    get expectedType() {
+        return this._expectedType;
+    }
+    get expectedCustomType() {
+        return this._expectedCustomType;
     }
-    // euintXXX
-    return clearValueAsBigInt;
 }
-function buildUserDecryptResults(handles, listBigIntDecryptions) {
-    let typesList = [];
-    for (const handle of handles) {
-        const hexPair = handle.slice(-4, -2).toLowerCase();
-        const typeDiscriminant = parseInt(hexPair, 16);
-        typesList.push(typeDiscriminant);
+
+function isBytes(value, bytewidth) {
+    if (!value) {
+        return false;
     }
-    const results = {};
-    handles.forEach((handle, idx) => (results[handle] = formatAccordingToType(listBigIntDecryptions[idx], typesList[idx])));
-    return results;
+    if (!(value instanceof Uint8Array)) {
+        return false;
+    }
+    return value.length === bytewidth ;
 }
-function checkDeadlineValidity(startTimestamp, durationDays) {
-    if (durationDays === BigInt(0)) {
-        throw Error('durationDays is null');
+function isBytesHex(value, bytewidth) {
+    if (!is0x(value)) {
+        return false;
     }
-    if (durationDays > MAX_USER_DECRYPT_DURATION_DAYS) {
-        throw Error(`durationDays is above max duration of ${MAX_USER_DECRYPT_DURATION_DAYS}`);
+    if (bytewidth !== undefined && value.length !== 2 * bytewidth + 2) {
+        return false;
     }
-    const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-    if (startTimestamp > currentTimestamp) {
-        throw Error('startTimestamp is set in the future');
+    if ((value.length - 2) % 2 !== 0) {
+        return false;
     }
-    const durationInSeconds = durationDays * BigInt(86400);
-    if (startTimestamp + durationInSeconds < currentTimestamp) {
-        throw Error('User decrypt request has expired');
+    const hexRegex = /^0x[a-fA-F0-9]*$/;
+    if (!hexRegex.test(value)) {
+        return false;
     }
+    return true;
 }
-const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider, instanceOptions) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays, options) => {
-    const extraData = '0x00';
-    let pubKey;
-    let privKey;
-    try {
-        pubKey = TKMS.u8vec_to_ml_kem_pke_pk(fromHexString(publicKey));
-        privKey = TKMS.u8vec_to_ml_kem_pke_sk(fromHexString(privateKey));
+function isBytesHexNo0x(value, bytewidth) {
+    if (!isNo0x(value)) {
+        return false;
     }
-    catch (e) {
-        throw new Error('Invalid public or private key', { cause: e });
+    if ((value.length - 2) % 2 !== 0) {
+        return false;
     }
-    // Casting handles if string
-    const signatureSanitized = signature.replace(/^(0x)/, '');
-    const publicKeySanitized = publicKey.replace(/^(0x)/, '');
-    const handles = _handles.map((h) => ({
-        handle: typeof h.handle === 'string'
-            ? toHexString(fromHexString(h.handle), true)
-            : toHexString(h.handle, true),
-        contractAddress: getAddress$1(h.contractAddress),
-    }));
-    checkEncryptedBits(handles.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 userAllowed = await acl.persistAllowed(handle, userAddress);
-        const contractAllowed = await acl.persistAllowed(handle, contractAddress);
-        if (!userAllowed) {
-            throw new Error(`User ${userAddress} is not authorized to user decrypt handle ${handle}!`);
-        }
-        if (!contractAllowed) {
-            throw new Error(`dapp contract ${contractAddress} is not authorized to user decrypt handle ${handle}!`);
-        }
-        if (userAddress === contractAddress) {
-            throw new Error(`userAddress ${userAddress} should not be equal to contractAddress when requesting user decryption!`);
-        }
-    });
-    const contractAddressesLength = contractAddresses.length;
-    if (contractAddressesLength === 0) {
-        throw Error('contractAddresses is empty');
+    const hexRegex = /^[a-fA-F0-9]*$/;
+    if (!hexRegex.test(value)) {
+        return false;
     }
-    if (contractAddressesLength > MAX_USER_DECRYPT_CONTRACT_ADDRESSES) {
-        throw Error(`contractAddresses max length of ${MAX_USER_DECRYPT_CONTRACT_ADDRESSES} exceeded`);
+    return true;
+}
+function isBytes32Hex(value) {
+    return isBytesHex(value, 32);
+}
+function isBytes65Hex(value) {
+    return isBytesHex(value, 65);
+}
+function isBytes32(value) {
+    return isBytes(value, 32);
+}
+function assertIsBytes32(value) {
+    if (!isBytes32(value)) {
+        throw new InvalidTypeError({
+            type: typeof value,
+            expectedType: 'Bytes32',
+        });
     }
-    await Promise.all(verifications).catch((e) => {
-        throw e;
-    });
-    const payloadForRequest = {
-        handleContractPairs: handles,
-        requestValidity: {
-            startTimestamp: startTimestamp.toString(), // Convert to string
-            durationDays: durationDays.toString(), // Convert to string
-        },
-        contractsChainId: chainId.toString(), // Convert to string
-        contractAddresses: contractAddresses.map((c) => getAddress$1(c)),
-        userAddress: getAddress$1(userAddress),
-        signature: signatureSanitized,
-        publicKey: publicKeySanitized,
-        extraData,
-    };
-    const json = await fetchRelayerJsonRpcPost('USER_DECRYPT', `${relayerUrl}/v1/user-decrypt`, payloadForRequest, instanceOptions ?? options);
-    // assume the KMS Signers have the correct order
-    let indexedKmsSigners = kmsSigners.map((signer, index) => {
-        return TKMS.new_server_id_addr(index + 1, signer);
+}
+/**
+ * Type guard that checks if a property exists on an object and is a valid hex bytes string.
+ * A valid BytesHex string starts with "0x" followed by an even number of hexadecimal characters.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to check (can be any type)
+ * @param property - The property name to check for
+ * @returns True if `o` is an object with the specified property that is a valid BytesHex string
+ *
+ * @example
+ * ```typescript
+ * const data: unknown = { hash: "0x1234abcd", value: 42 };
+ * if (isRecordBytesHexProperty(data, 'hash')) {
+ *   console.log(data.hash); // "0x1234abcd"
+ * }
+ * ```
+ */
+function isRecordBytesHexProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return isBytesHex(o[property]);
+}
+/**
+ * Assertion function that validates a property exists on an object and is a valid hex bytes string.
+ * A valid BytesHex string must start with "0x" followed by an even number of hexadecimal characters.
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @throws {InvalidPropertyError} When the property is missing, not a string, or not valid BytesHex format
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * function processTransaction(data: unknown) {
+ *   assertRecordBytesHexProperty(data, 'txHash', 'transaction');
+ *   console.log(data.txHash); // e.g., "0x1234..."
+ * }
+ * ```
+ */
+function assertRecordBytesHexProperty(o, property, objName) {
+    if (!isRecordBytesHexProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'BytesHex',
+            type: typeofProperty(o, property),
+        });
+    }
+}
+function isRecordBytesHexNo0xProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return isBytesHexNo0x(o[property]);
+}
+function assertRecordBytesHexNo0xProperty(o, property, objName) {
+    if (!isRecordBytesHexNo0xProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'BytesHexNo0x',
+            type: typeofProperty(o, property),
+        });
+    }
+}
+function assertRecordBytes32HexArrayProperty(o, property, objName) {
+    assertRecordArrayProperty(o, property, objName);
+    const arr = o[property];
+    for (let i = 0; i < arr.length; ++i) {
+        if (!isBytes32Hex(arr[i])) {
+            throw new InvalidPropertyError({
+                objName,
+                property: `${property}[${i}]`,
+                expectedType: 'Bytes32Hex',
+                type: typeof arr[i],
+            });
+        }
+    }
+}
+function assertRecordBytes65HexArrayProperty(o, property, objName) {
+    assertRecordArrayProperty(o, property, objName);
+    const arr = o[property];
+    for (let i = 0; i < arr.length; ++i) {
+        if (!isBytes65Hex(arr[i])) {
+            throw new InvalidPropertyError({
+                objName,
+                property: `${property}[${i}]`,
+                expectedType: 'Bytes65Hex',
+                type: typeof arr[i],
+            });
+        }
+    }
+}
+/**
+ * Assertion function that validates a property exists on an object, is an array,
+ * and every element is a valid hex bytes string (with "0x" prefix).
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @throws {InvalidPropertyError} When the property is missing, not an array, or any element is not valid BytesHex
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * function processHashes(data: unknown) {
+ *   assertRecordBytesHexArrayProperty(data, 'txHashes', 'transaction');
+ *   data.txHashes.forEach(hash => {
+ *     console.log(hash); // e.g., "0x1234abcd..."
+ *   });
+ * }
+ * ```
+ */
+function assertRecordBytesHexArrayProperty(o, property, objName) {
+    assertRecordArrayProperty(o, property, objName);
+    const arr = o[property];
+    for (let i = 0; i < arr.length; ++i) {
+        if (!isBytesHex(arr[i])) {
+            throw new InvalidPropertyError({
+                objName,
+                property: `${property}[${i}]`,
+                expectedType: 'BytesHex',
+                type: typeof arr[i],
+            });
+        }
+    }
+}
+/**
+ * Assertion function that validates a property exists on an object, is an array,
+ * and every element is a valid hex bytes string (without "0x" prefix).
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @template K - The property key type (string literal)
+ * @param o - The value to validate (can be any type)
+ * @param property - The property name to check for
+ * @param objName - The name of the object being validated (used in error messages)
+ * @throws {InvalidPropertyError} When the property is missing, not an array, or any element is not valid BytesHexNo0x
+ * @throws {never} No other errors are thrown
+ *
+ * @example
+ * ```typescript
+ * function processSignatures(data: unknown) {
+ *   assertRecordBytesHexNo0xArrayProperty(data, 'signatures', 'response');
+ *   data.signatures.forEach(sig => {
+ *     console.log(sig); // e.g., "1234abcd..." (no 0x prefix)
+ *   });
+ * }
+ * ```
+ */
+function assertRecordBytesHexNo0xArrayProperty(o, property, objName) {
+    assertRecordArrayProperty(o, property, objName);
+    const arr = o[property];
+    for (let i = 0; i < arr.length; ++i) {
+        if (!isBytesHexNo0x(arr[i])) {
+            throw new InvalidPropertyError({
+                objName,
+                property: `${property}[${i}]`,
+                expectedType: 'BytesHexNo0x',
+                type: typeof arr[i],
+            });
+        }
+    }
+}
+function isRecordUint8ArrayProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return o[property] instanceof Uint8Array;
+}
+function assertUint8ArrayProperty(o, property, objName) {
+    if (!isRecordUint8ArrayProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            expectedType: 'Uint8Array',
+            type: typeofProperty(o, property),
+        });
+    }
+}
+/**
+ * Convert a Uint8Array to a hex string (without 0x prefix).
+ */
+function bytesToHexNo0x(bytes) {
+    if (!bytes || bytes?.length === 0) {
+        return '';
+    }
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += bytes[i].toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+/**
+ * Convert a Uint8Array to a 0x prefixed hex string
+ */
+function bytesToHex(bytes) {
+    return `0x${bytesToHexNo0x(bytes)}`;
+}
+/**
+ * Convert a hex string prefixed by 0x or not to a Uint8Array
+ */
+function hexToBytes(hexString) {
+    const arr = hexString.replace(/^(0x)/, '').match(/.{1,2}/g);
+    if (!arr)
+        return new Uint8Array();
+    return Uint8Array.from(arr.map((byte) => parseInt(byte, 16)));
+}
+/**
+ * Convert a Uint8Array to a bigint
+ */
+function bytesToBigInt(byteArray) {
+    if (!byteArray || byteArray.length === 0) {
+        return BigInt(0);
+    }
+    let result = BigInt(0);
+    for (let i = 0; i < byteArray.length; i++) {
+        result = (result << BigInt(8)) | BigInt(byteArray[i]);
+    }
+    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) {
+        throw new Error(`HTTP error! status: ${response.status} on ${response.url}`);
+    }
+    // Warning : bytes is not widely supported yet!
+    const bytes = typeof response.bytes === 'function'
+        ? await response.bytes()
+        : new Uint8Array(await response.arrayBuffer());
+    return bytes;
+}
+function concatBytes(...arrays) {
+    let totalLength = 0;
+    for (const arr of arrays) {
+        totalLength += arr.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+
+// Add type checking
+const getAddress$1 = (value) => getAddress$2(value);
+const aclABI$1 = [
+    'function persistAllowed(bytes32 handle, address account) view returns (bool)',
+];
+const MAX_USER_DECRYPT_CONTRACT_ADDRESSES = 10;
+const MAX_USER_DECRYPT_DURATION_DAYS = BigInt(365);
+function formatAccordingToType(clearValueAsBigInt, type) {
+    if (type === 0) {
+        // ebool
+        return clearValueAsBigInt === BigInt(1);
+    }
+    else if (type === 7) {
+        // eaddress
+        return getAddress$1('0x' + clearValueAsBigInt.toString(16).padStart(40, '0'));
+    }
+    else if (type > 8 || type == 1) {
+        // type == 1 : euint4 (not supported)
+        throw new Error(`Unsupported handle type ${type}`);
+    }
+    // euintXXX
+    return clearValueAsBigInt;
+}
+function buildUserDecryptResults(handles, listBigIntDecryptions) {
+    let typesList = [];
+    for (const handle of handles) {
+        const hexPair = handle.slice(-4, -2).toLowerCase();
+        const typeDiscriminant = parseInt(hexPair, 16);
+        typesList.push(typeDiscriminant);
+    }
+    const results = {};
+    handles.forEach((handle, idx) => (results[handle] = formatAccordingToType(listBigIntDecryptions[idx], typesList[idx])));
+    return results;
+}
+function checkDeadlineValidity(startTimestamp, durationDays) {
+    if (durationDays === BigInt(0)) {
+        throw Error('durationDays is null');
+    }
+    if (durationDays > MAX_USER_DECRYPT_DURATION_DAYS) {
+        throw Error(`durationDays is above max duration of ${MAX_USER_DECRYPT_DURATION_DAYS}`);
+    }
+    const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+    if (startTimestamp > currentTimestamp) {
+        throw Error('startTimestamp is set in the future');
+    }
+    const durationInSeconds = durationDays * BigInt(86400);
+    if (startTimestamp + durationInSeconds < currentTimestamp) {
+        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 extraData = '0x00';
+    let pubKey;
+    let privKey;
+    try {
+        pubKey = TKMS.u8vec_to_ml_kem_pke_pk(hexToBytes(publicKey));
+        privKey = TKMS.u8vec_to_ml_kem_pke_sk(hexToBytes(privateKey));
+    }
+    catch (e) {
+        throw new Error('Invalid public or private key', { cause: e });
+    }
+    // Casting handles if string
+    const signatureSanitized = signature.replace(/^(0x)/, '');
+    const publicKeySanitized = publicKey.replace(/^(0x)/, '');
+    const handles = _handles.map((h) => ({
+        handle: typeof h.handle === 'string'
+            ? toHexString(hexToBytes(h.handle), true)
+            : toHexString(h.handle, true),
+        contractAddress: getAddress$1(h.contractAddress),
+    }));
+    checkEncryptedBits(handles.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 userAllowed = await acl.persistAllowed(handle, userAddress);
+        const contractAllowed = await acl.persistAllowed(handle, contractAddress);
+        if (!userAllowed) {
+            throw new Error(`User ${userAddress} is not authorized to user decrypt handle ${handle}!`);
+        }
+        if (!contractAllowed) {
+            throw new Error(`dapp contract ${contractAddress} is not authorized to user decrypt handle ${handle}!`);
+        }
+        if (userAddress === contractAddress) {
+            throw new Error(`userAddress ${userAddress} should not be equal to contractAddress when requesting user decryption!`);
+        }
+    });
+    const contractAddressesLength = contractAddresses.length;
+    if (contractAddressesLength === 0) {
+        throw Error('contractAddresses is empty');
+    }
+    if (contractAddressesLength > MAX_USER_DECRYPT_CONTRACT_ADDRESSES) {
+        throw Error(`contractAddresses max length of ${MAX_USER_DECRYPT_CONTRACT_ADDRESSES} exceeded`);
+    }
+    await Promise.all(verifications).catch((e) => {
+        throw e;
+    });
+    const payloadForRequest = {
+        handleContractPairs: handles,
+        requestValidity: {
+            startTimestamp: startTimestamp.toString(), // Convert to string
+            durationDays: durationDays.toString(), // Convert to string
+        },
+        contractsChainId: chainId.toString(), // Convert to string
+        contractAddresses: contractAddresses.map((c) => getAddress$1(c)),
+        userAddress: getAddress$1(userAddress),
+        signature: signatureSanitized,
+        publicKey: publicKeySanitized,
+        extraData,
+    };
+    const json = await relayerProvider.fetchPostUserDecrypt(payloadForRequest, options ?? instanceOptions);
+    // const json = await fetchRelayerJsonRpcPost(
+    //   'USER_DECRYPT',
+    //   `${relayerUrl}/v1/user-decrypt`,
+    //   payloadForRequest,
+    //   instanceOptions ?? options,
+    // );
+    // assume the KMS Signers have the correct order
+    let indexedKmsSigners = kmsSigners.map((signer, index) => {
+        return TKMS.new_server_id_addr(index + 1, signer);
     });
     const client = TKMS.new_client(indexedKmsSigners, userAddress, 'default');
     try {
@@ -16957,7 +17660,8 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
             ciphertext_handles: handles.map((h) => h.handle.replace(/^0x/, '')),
             eip712_verifying_contract: verifyingContractAddress,
         };
-        const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
+        const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json, //json.response,
+        pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
         const results = buildUserDecryptResults(handles.map((h) => h.handle), listBigIntDecryptions);
         return results;
@@ -16984,10 +17688,10 @@ const checkEncryptedValue = (value, bits) => {
     }
 };
 const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKey, publicParams, contractAddress, userAddress, }) => {
-    if (!isAddress(contractAddress)) {
+    if (!isAddress$1(contractAddress)) {
         throw new Error('Contract address is not a valid address.');
     }
-    if (!isAddress(userAddress)) {
+    if (!isAddress$1(userAddress)) {
         throw new Error('User address is not a valid address.');
     }
     const publicKey = tfheCompactPublicKey;
@@ -17053,7 +17757,7 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
             return this;
         },
         addAddress(value) {
-            if (!isAddress(value)) {
+            if (!isAddress$1(value)) {
                 throw new Error('The value must be a valid address.');
             }
             checkLimit(160);
@@ -17084,10 +17788,10 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
             };
             const closestPP = getClosestPP();
             const pp = publicParams[closestPP].publicParams;
-            const buffContract = fromHexString(contractAddress);
-            const buffUser = fromHexString(userAddress);
-            const buffAcl = fromHexString(aclContractAddress);
-            const buffChainId = fromHexString(chainId.toString(16).padStart(64, '0'));
+            const buffContract = hexToBytes(contractAddress);
+            const buffUser = hexToBytes(userAddress);
+            const buffAcl = hexToBytes(aclContractAddress);
+            const buffChainId = hexToBytes(chainId.toString(16).padStart(64, '0'));
             const auxData = new Uint8Array(buffContract.length + buffUser.length + buffAcl.length + 32);
             auxData.set(buffContract, 0);
             auxData.set(buffUser, 20);
@@ -17100,93 +17804,340 @@ const createEncryptedInput = ({ aclContractAddress, chainId, tfheCompactPublicKe
     };
 };
 
-/**
- * **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
-};
-
 const MAX_UINT64 = BigInt('18446744073709551615'); // 2^64 - 1
-const RAW_CT_HASH_DOMAIN_SEPARATOR = 'ZK-w_rct';
-const HANDLE_HASH_DOMAIN_SEPARATOR = 'ZK-w_hdl';
-const computeHandles = (ciphertextWithZKProof, bitwidths, aclContractAddress, chainId, ciphertextVersion) => {
-    // Should be identical to:
-    // https://github.com/zama-ai/fhevm-backend/blob/bae00d1b0feafb63286e94acdc58dc88d9c481bf/fhevm-engine/zkproof-worker/src/verifier.rs#L301
-    const blob_hash = createHash('keccak256')
-        .update(Buffer.from(RAW_CT_HASH_DOMAIN_SEPARATOR))
-        .update(Buffer.from(ciphertextWithZKProof))
-        .digest();
-    const aclContractAddress20Bytes = Buffer.from(fromHexString(aclContractAddress));
-    const hex = chainId.toString(16).padStart(64, '0'); // 64 hex chars = 32 bytes
-    const chainId32Bytes = Buffer.from(hex, 'hex');
-    const handles = bitwidths.map((bitwidth, encryptionIndex) => {
-        const encryptionType = ENCRYPTION_TYPES[bitwidth];
-        const encryptionIndex1Byte = Buffer.from([encryptionIndex]);
-        const handleHash = createHash('keccak256')
-            .update(Buffer.from(HANDLE_HASH_DOMAIN_SEPARATOR))
-            .update(blob_hash)
-            .update(encryptionIndex1Byte)
-            .update(aclContractAddress20Bytes)
-            .update(chainId32Bytes)
-            .digest();
-        const dataInput = new Uint8Array(32);
-        dataInput.set(handleHash, 0);
-        // Check if chainId exceeds 8 bytes
-        if (BigInt(chainId) > MAX_UINT64) {
-            throw new Error('ChainId exceeds maximum allowed value (8 bytes)'); // fhevm assumes chainID is only taking up to 8 bytes
-        }
-        const chainId8Bytes = fromHexString(hex).slice(24, 32);
-        dataInput[21] = encryptionIndex;
-        dataInput.set(chainId8Bytes, 22);
-        dataInput[30] = encryptionType;
-        dataInput[31] = ciphertextVersion;
-        return dataInput;
-    });
-    return handles;
-};
-
-// Add type checking
-const getAddress = (value) => getAddress$2(value);
-const currentCiphertextVersion = () => {
-    return 0;
-};
-function isThresholdReached$1(coprocessorSigners, recoveredAddresses, threshold) {
-    const addressMap = new Map();
-    recoveredAddresses.forEach((address, index) => {
-        if (addressMap.has(address)) {
-            const duplicateValue = address;
-            throw new Error(`Duplicate coprocessor signer address found: ${duplicateValue} appears multiple times in recovered addresses`);
+BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+const MAX_UINT32 = 0xffffffff;
+const MAX_UINT8 = 0xff;
+function numberToHex(num) {
+    let hex = num.toString(16);
+    return hex.length % 2 ? '0' + hex : hex;
+}
+function isUintNumber(value) {
+    if (typeof value === 'number') {
+        if (value < 0) {
+            return false;
         }
-        addressMap.set(address, index);
-    });
-    for (const address of recoveredAddresses) {
+        return Number.isInteger(value);
+    }
+    return false;
+}
+function isUintBigInt(value) {
+    if (typeof value === 'bigint') {
+        return value >= 0;
+    }
+    return false;
+}
+function isUint(value) {
+    if (isUintNumber(value)) {
+        return true;
+    }
+    else if (isUintBigInt(value)) {
+        return true;
+    }
+    return false;
+}
+function isUint8(value) {
+    if (!isUint(value)) {
+        return false;
+    }
+    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' });
+    }
+    const buffer = new ArrayBuffer(32);
+    const view = new DataView(buffer);
+    view.setUint32(28, Number(uint32), false);
+    return new Uint8Array(buffer);
+}
+function assertIsUint8(value) {
+    if (!isUint8(value)) {
+        throw new InvalidTypeError({
+            type: typeof value,
+            expectedType: 'Uint8',
+        });
+    }
+}
+function assertIsUint64(value) {
+    if (!isUint64(value)) {
+        throw new InvalidTypeError({
+            type: typeof value,
+            expectedType: 'Uint64',
+        });
+    }
+}
+function isRecordUintProperty(o, property) {
+    if (!isNonNullableRecordProperty(o, property)) {
+        return false;
+    }
+    return isUint(o[property]);
+}
+function assertRecordUintProperty(o, property, objName) {
+    if (!isRecordUintProperty(o, property)) {
+        throw new InvalidPropertyError({
+            objName,
+            property,
+            type: typeofProperty(o, property),
+            expectedType: 'Uint',
+        });
+    }
+}
+
+class ChecksummedAddressError extends RelayerErrorBase {
+    constructor({ address }) {
+        super({
+            message: `Checksummed address "${address}" is invalid.`,
+            name: 'ChecksummedAddressError',
+        });
+    }
+}
+
+function isChecksummedAddress(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    if (!value.startsWith('0x')) {
+        return false;
+    }
+    if (value.length !== 42) {
+        return false;
+    }
+    try {
+        const a = getAddress$2(value);
+        return a === value;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function assertIsChecksummedAddress(value) {
+    if (!isChecksummedAddress(value)) {
+        throw new ChecksummedAddressError({ address: String(value) });
+    }
+}
+function isAddress(value) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    if (!value.startsWith('0x')) {
+        return false;
+    }
+    if (value.length !== 42) {
+        return false;
+    }
+    if (!isAddress$1(value)) {
+        return false;
+    }
+    return true;
+}
+function checksummedAddressToBytes20(address) {
+    if (!isAddress(address)) {
+        throw new InvalidTypeError({ expectedType: 'ChecksummedAddress' });
+    }
+    const hex = remove0x(address);
+    const bytes = new Uint8Array(20);
+    for (let i = 0; i < 20; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FhevmHandle
+////////////////////////////////////////////////////////////////////////////////
+class FhevmHandle {
+    _hash21;
+    _chainId;
+    _fheTypeId;
+    _version;
+    _computed;
+    _index;
+    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) {
+        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)');
+        }
+        this._hash21 = hash21;
+        this._chainId = chainId;
+        this._fheTypeId = fheTypeId;
+        this._version = version;
+        this._computed = computed;
+        if (index !== undefined) {
+            this._index = index;
+        }
+    }
+    get hash21() {
+        return this._hash21;
+    }
+    get chainId() {
+        return this._chainId;
+    }
+    get fheTypeId() {
+        return this._fheTypeId;
+    }
+    get version() {
+        return this._version;
+    }
+    get computed() {
+        return this._computed;
+    }
+    get index() {
+        return this._index;
+    }
+    static fromZKProof(params) {
+        assertIsChecksummedAddress(params.aclAddress);
+        assertIsUint64(params.chainId);
+        assertIsUint8(params.ciphertextVersion);
+        let fheTypeIds;
+        if (params.fheTypeIds !== undefined) {
+            fheTypeIds = params.fheTypeIds;
+        }
+        else if (params.fheTypeEncryptionBitwidths !== undefined) {
+            fheTypeIds = params.fheTypeEncryptionBitwidths.map((w) => FhevmHandle.FheTypeEncryptionBitwidthsToId[w]);
+        }
+        else {
+            throw new InternalError({
+                message: 'createInputHandles requires either fheTypeIds or fheTypeEncryptionBitwidths',
+            });
+        }
+        assertIsUint8(fheTypeIds.length);
+        let ciphertextWithZKProof;
+        if (typeof params.ciphertextWithZKProof === 'string') {
+            ciphertextWithZKProof = hexToBytes(params.ciphertextWithZKProof);
+        }
+        else if (params.ciphertextWithZKProof instanceof Uint8Array) {
+            ciphertextWithZKProof = params.ciphertextWithZKProof;
+        }
+        else {
+            throw new InternalError({
+                message: 'Invalid ciphertextWithZKProof argument',
+            });
+        }
+        if (ciphertextWithZKProof.length === 0) {
+            throw new InternalError({
+                message: 'Invalid ciphertextWithZKProof argument',
+            });
+        }
+        const encoder = new TextEncoder();
+        const domainSepBytes = encoder.encode(FhevmHandle.RAW_CT_HASH_DOMAIN_SEPARATOR);
+        const blobHashBytes32Hex = keccak256(concatBytes(domainSepBytes, ciphertextWithZKProof));
+        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));
+        }
+        return handles;
+    }
+    /**
+     * 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);
+            handle_hash.update([ct_idx as u8]);
+            handle_hash.update(
+                Address::from_str(&aux_data.acl_contract_address)
+                    .expect("valid acl_contract_address")
+                    .into_array(),
+            );
+            handle_hash.update(chain_id_bytes);
+            let mut handle = handle_hash.finalize().to_vec();
+            assert_eq!(handle.len(), 32);
+    
+        */
+        assertIsBytes32(blobHashBytes32);
+        assertIsChecksummedAddress(aclAddress);
+        assertIsUint8(index);
+        assertIsUint64(chainId);
+        const encryptionIndexByte1 = new Uint8Array([index]);
+        const aclContractAddressBytes20 = checksummedAddressToBytes20(aclAddress);
+        const chainIdBytes32 = uint32ToBytes32(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());
+    }
+}
+
+// Add type checking
+const getAddress = (value) => getAddress$2(value);
+const currentCiphertextVersion = () => {
+    return 0;
+};
+function isThresholdReached$1(coprocessorSigners, recoveredAddresses, threshold) {
+    const addressMap = new Map();
+    recoveredAddresses.forEach((address, index) => {
+        if (addressMap.has(address)) {
+            const duplicateValue = address;
+            throw new Error(`Duplicate coprocessor signer address found: ${duplicateValue} appears multiple times in recovered addresses`);
+        }
+        addressMap.set(address, index);
+    });
+    for (const address of recoveredAddresses) {
         if (!coprocessorSigners.includes(address)) {
             throw new Error(`Invalid address found: ${address} is not in the list of coprocessor signers`);
         }
@@ -17194,7 +18145,8 @@ function isThresholdReached$1(coprocessorSigners, recoveredAddresses, threshold)
     return recoveredAddresses.length >= threshold;
 }
 function isFhevmRelayerInputProofResponse(json) {
-    const response = json.response;
+    const response = json;
+    // const response = json.response as unknown;
     if (typeof response !== 'object' || response === null) {
         return false;
     }
@@ -17207,11 +18159,13 @@ 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, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, instanceOptions) => (contractAddress, userAddress) => {
-    if (!isAddress(contractAddress)) {
+const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, 
+//relayerUrl: string,
+relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, instanceOptions) => (contractAddress, userAddress) => {
+    if (!isAddress$1(contractAddress)) {
         throw new Error('Contract address is not a valid address.');
     }
-    if (!isAddress(userAddress)) {
+    if (!isAddress$1(userAddress)) {
         throw new Error('User address is not a valid address.');
     }
     const input = createEncryptedInput({
@@ -17263,6 +18217,7 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
             const extraData = '0x00';
             const bits = input.getBits();
             const ciphertext = input.encrypt();
+            //console.log(`ciphertext=${toHexString(ciphertext)}`);
             const payload = {
                 contractAddress: getAddress(contractAddress),
                 userAddress: getAddress(userAddress),
@@ -17270,14 +18225,29 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
                 contractChainId: ('0x' + chainId.toString(16)),
                 extraData,
             };
-            const json = await fetchRelayerJsonRpcPost('INPUT_PROOF', `${relayerUrl}/v1/input-proof`, payload, options ?? instanceOptions);
+            const json = await relayerProvider.fetchPostInputProof(payload, options ?? instanceOptions);
+            // const json = await fetchRelayerJsonRpcPost(
+            //   'INPUT_PROOF',
+            //   `${relayerUrl}/v1/input-proof`,
+            //   payload,
+            //   options ?? instanceOptions,
+            // );
             if (!isFhevmRelayerInputProofResponse(json)) {
                 throwRelayerInternalError('INPUT_PROOF', json);
             }
-            const handles = computeHandles(ciphertext, bits, aclContractAddress, chainId, currentCiphertextVersion());
+            const fhevmHandles = FhevmHandle.fromZKProof({
+                ciphertextWithZKProof: ciphertext,
+                chainId,
+                aclAddress: aclContractAddress,
+                ciphertextVersion: currentCiphertextVersion(),
+                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 (json.response.handles && json.response.handles.length > 0) {
-                const responseHandles = json.response.handles.map(fromHexString);
+            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)`);
                 }
@@ -17291,7 +18261,7 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
                     }
                 }
             }
-            const signatures = json.response.signatures;
+            const signatures = result.signatures;
             // verify signatures for inputs:
             const domain = {
                 name: 'InputVerification',
@@ -17334,7 +18304,7 @@ const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddres
             inputProof += extraData.slice(2);
             return {
                 handles,
-                inputProof: fromHexString(inputProof),
+                inputProof: hexToBytes(inputProof),
             };
         },
     };
@@ -17460,14 +18430,16 @@ function deserializeClearValues(handles, decryptedResult) {
     handles.forEach((handle, idx) => (results[handle] = rawValues[idx]));
     return results;
 }
-const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, relayerUrl, provider, instanceOptions) => async (_handles, options) => {
+const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, 
+//relayerUrl: string,
+relayerProvider, provider, instanceOptions) => async (_handles, options) => {
     const extraData = '0x00';
     const acl = new ethers.Contract(aclContractAddress, aclABI, provider);
     let handles;
     try {
         handles = await Promise.all(_handles.map(async (_handle) => {
             const handle = typeof _handle === 'string'
-                ? toHexString(fromHexString(_handle), true)
+                ? toHexString(hexToBytes(_handle), true)
                 : toHexString(_handle, true);
             const isAllowedForDecryption = await acl.isAllowedForDecryption(handle);
             if (!isAllowedForDecryption) {
@@ -17485,7 +18457,13 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
         ciphertextHandles: handles,
         extraData,
     };
-    const json = await fetchRelayerJsonRpcPost('PUBLIC_DECRYPT', `${relayerUrl}/v1/public-decrypt`, payloadForRequest, options ?? instanceOptions);
+    const json = await relayerProvider.fetchPostPublicDecrypt(payloadForRequest, options ?? instanceOptions);
+    // const json = await fetchRelayerJsonRpcPost(
+    //   'PUBLIC_DECRYPT',
+    //   `${relayerUrl}/v1/public-decrypt`,
+    //   payloadForRequest,
+    //   options ?? instanceOptions,
+    // );
     // verify signatures on decryption:
     const domain = {
         name: 'Decryption',
@@ -17500,10 +18478,11 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
             { name: 'extraData', type: 'bytes' },
         ],
     };
-    const result = json.response[0];
-    const decryptedResult = ensure0x(result.decrypted_value);
+    //const result = json.response[0];
+    const result = json;
+    const decryptedResult = ensure0x(result.decryptedValue);
     const kmsSignatures = result.signatures.map(ensure0x);
-    // TODO result.extra_data (RelayerPublicDecryptJsonResponse)
+    // TODO result.extraData (RelayerPublicDecryptJsonResponse)
     const signedExtraData = '0x';
     const recoveredAddresses = kmsSignatures.map((kmsSignature) => {
         const recoveredAddress = ethers.verifyTypedData(domain, types, { ctHandles: handles, decryptedResult, extraData: signedExtraData }, kmsSignature);
@@ -17538,12 +18517,12 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
  */
 const createEIP712 = (verifyingContract, contractsChainId) => (publicKey, contractAddresses, startTimestamp, durationDays, delegatedAccount) => {
     const extraData = '0x00';
-    if (delegatedAccount && !isAddress(delegatedAccount))
+    if (delegatedAccount && !isAddress$1(delegatedAccount))
         throw new Error('Invalid delegated account.');
-    if (!isAddress(verifyingContract)) {
+    if (!isAddress$1(verifyingContract)) {
         throw new Error('Invalid verifying contract address.');
     }
-    if (!contractAddresses.every((c) => isAddress(c))) {
+    if (!contractAddresses.every((c) => isAddress$1(c))) {
         throw new Error('Invalid contract address.');
     }
     // Format the public key based on its type
@@ -17627,77 +18606,2669 @@ const generateKeypair = () => {
     };
 };
 
-global.fetch = fetchRetry(global.fetch, { retries: 5, retryDelay: 500 });
-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',
-};
-const createInstance = async (config) => {
-    const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, kmsContractAddress, aclContractAddress, gatewayChainId, auth, } = config;
-    if (!kmsContractAddress || !isAddress(kmsContractAddress)) {
-        throw new Error('KMS contract address is not valid or empty');
+class AbstractRelayerProvider {
+    _relayerUrl;
+    constructor(relayerUrl) {
+        this._relayerUrl = relayerUrl;
     }
-    if (!verifyingContractAddressDecryption ||
-        !isAddress(verifyingContractAddressDecryption)) {
-        throw new Error('Verifying contract for Decryption address is not valid or empty');
+    get url() {
+        return this._relayerUrl;
     }
-    if (!verifyingContractAddressInputVerification ||
-        !isAddress(verifyingContractAddressInputVerification)) {
-        throw new Error('Verifying contract for InputVerification address is not valid or empty');
+    get keyUrl() {
+        return `${this.url}/keyurl`;
     }
-    if (!aclContractAddress || !isAddress(aclContractAddress)) {
-        throw new Error('ACL contract address is not valid or empty');
+    get inputProof() {
+        return `${this.url}/input-proof`;
     }
-    if (publicKey && !(publicKey.data instanceof Uint8Array))
-        throw new Error('publicKey must be a Uint8Array');
-    const provider = getProvider(config);
-    if (!provider) {
-        throw new Error('No network has been provided!');
+    get publicDecrypt() {
+        return `${this.url}/public-decrypt`;
     }
-    const chainId = await getChainId(provider, config);
-    const publicKeyData = await getTfheCompactPublicKey(config);
-    const publicParamsData = await getPublicParams(config);
-    const kmsSigners = await getKMSSigners(provider, config);
-    const thresholdKMSSigners = await getKMSSignersThreshold(provider, config);
-    const coprocessorSigners = await getCoprocessorSigners(provider, config);
-    const thresholdCoprocessorSigners = await getCoprocessorSignersThreshold(provider, config);
-    return {
-        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, cleanURL(config.relayerUrl), publicKeyData.publicKey, publicParamsData, coprocessorSigners, thresholdCoprocessorSigners, auth && { auth }),
-        generateKeypair,
-        createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
-        publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider, auth && { auth }),
-        userDecrypt: userDecryptRequest(kmsSigners, gatewayChainId, chainId, verifyingContractAddressDecryption, aclContractAddress, cleanURL(config.relayerUrl), provider, auth && { auth }),
-        getPublicKey: () => publicKeyData.publicKey
-            ? {
-                publicKey: publicKeyData.publicKey.safe_serialize(SERIALIZED_SIZE_LIMIT_PK),
-                publicKeyId: publicKeyData.publicKeyId,
-            }
-            : null,
-        getPublicParams: (bits) => {
-            if (publicParamsData[bits]) {
-                return {
-                    publicParams: publicParamsData[bits].publicParams.safe_serialize(SERIALIZED_SIZE_LIMIT_CRS),
-                    publicParamsId: publicParamsData[bits].publicParamsId,
-                };
-            }
-            return null;
-        },
+    get userDecrypt() {
+        return `${this.url}/user-decrypt`;
+    }
+}
+function assertIsRelayerInputProofResult(value, name) {
+    assertRecordBytes32HexArrayProperty(value, 'handles', name);
+    assertRecordBytes65HexArrayProperty(value, 'signatures', name);
+}
+function assertIsRelayerPublicDecryptResult(value, name) {
+    assertRecordBytesHexNo0xArrayProperty(value, 'signatures', name);
+    assertRecordStringProperty(value, 'decryptedValue', name);
+    assertRecordBytesHexProperty(value, 'extraData', name);
+}
+function assertIsRelayerUserDecryptResult(value, name) {
+    if (!Array.isArray(value)) {
+        throw InvalidPropertyError.invalidObject({
+            objName: name,
+            expectedType: 'Array',
+            type: typeof value,
+        });
+    }
+    for (let i = 0; i < value.length; ++i) {
+        // Missing extraData
+        assertRecordBytesHexNo0xProperty(value[i], 'payload', `${name}[i]`);
+        assertRecordBytesHexNo0xProperty(value[i], 'signature', `${name}[i]`);
+    }
+}
+
+class RelayerV1Provider extends AbstractRelayerProvider {
+    constructor(relayerUrl) {
+        super(relayerUrl);
+    }
+    get version() {
+        return 1;
+    }
+    async fetchGetKeyUrl() {
+        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        return response;
+    }
+    async fetchPostInputProof(payload, options) {
+        /*
+        Expected v1 format:
+        ===================
+        {
+          "response": {
+            "handles": [
+              "0xb0b1af7734450c2b7d944571af7e5b438cc62a2a26000000000000aa36a70400"
+            ],
+            "signatures": [
+              "0x70dcb78534f05c4448d3441b4704d3ff4a8478af56a3464497533c2e3c476d77165b09028847f0c3ed4b342b1e8b4252a93b521a3d8d07b724bcff740383e1361b"
+            ]
+          }
+        }
+        */
+        const json = await fetchRelayerJsonRpcPost('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 response = json.response[0];
+        const result = {
+            signatures: response.signatures,
+            decryptedValue: response.decrypted_value,
+            extraData: '0x',
+        };
+        assertIsRelayerPublicDecryptResult(result, 'fetchPostPublicDecrypt()');
+        return result;
+    }
+    async fetchPostUserDecrypt(payload, options) {
+        const json = await fetchRelayerJsonRpcPost('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) {
+        super(params);
+        this._operation = params.operation;
+    }
+    get operation() {
+        return this._operation;
+    }
+}
+class RelayerV2GetKeyUrlError extends RelayerV2ProviderError {
+    constructor({ cause }) {
+        super({
+            message: `Invalid relayer response.`,
+            name: 'RelayerV2GetKeyUrlError',
+            operation: 'KEY_URL',
+            cause,
+        });
+    }
+}
+class RelayerV2GetKeyUrlInvalidResponseError extends RelayerV2GetKeyUrlError {
+    constructor({ cause }) {
+        super({ cause });
+    }
+}
+
+function assertIsRelayerV2ApiError400NoDetails(value, name) {
+    assertRecordStringProperty(value, 'label', name);
+    if (!(value.label === 'malformed_json' ||
+        value.label === 'request_error' ||
+        value.label === 'not_ready_for_decryption')) {
+        throw new InvalidPropertyError({
+            objName: name,
+            property: 'label',
+            expectedType: 'string',
+            expectedValue: [
+                'malformed_json',
+                'request_error',
+                'not_ready_for_decryption',
+            ],
+            type: typeof value.label, // === "string"
+            value: value.label,
+        });
+    }
+    assertRecordStringProperty(value, 'message', name);
+}
+
+/*
+    type RelayerV2ApiError400WithDetails = {
+      label: 'missing_fields' | 'validation_failed';
+      message: string;
+      details: Array<RelayerV2ErrorDetail>;
+    };
+    type RelayerV2ErrorDetail = {
+      field: string;
+      issue: string;
+    }
+*/
+function assertIsRelayerV2ApiError400WithDetails(value, name) {
+    assertRecordStringProperty(value, 'label', name);
+    if (!(value.label === 'missing_fields' || value.label === 'validation_failed')) {
+        throw new InvalidPropertyError({
+            objName: name,
+            property: 'label',
+            expectedType: 'string',
+            expectedValue: ['missing_fields', 'validation_failed'],
+            type: typeof value.label,
+            value: value.label,
+        });
+    }
+    assertRecordStringProperty(value, 'message', name);
+    assertRecordArrayProperty(value, 'details', name);
+    const arr = value.details;
+    for (let i = 0; i < arr.length; ++i) {
+        const detail = arr[i];
+        assertRecordStringProperty(detail, 'field', `${name}.details[${i}]`);
+        assertRecordStringProperty(detail, 'issue', `${name}.details[${i}]`);
+    }
+}
+
+/*
+  export type RelayerV2ApiError429 = {
+    label: 'rate_limited';
+    message: string;
+  };
+*/
+function assertIsRelayerV2ApiError429(value, name) {
+    assertRecordStringProperty(value, 'label', name, 'rate_limited');
+    assertRecordStringProperty(value, 'message', name);
+}
+
+/*
+    export type RelayerV2ApiError500 = {
+        label: 'internal_server_error';
+        message: string;
+    };
+*/
+function assertIsRelayerV2ApiError500(value, name) {
+    assertRecordStringProperty(value, 'label', name, 'internal_server_error');
+    assertRecordStringProperty(value, 'message', name);
+}
+
+/*
+  export type RelayerV2ApiError404 = {
+    label: 'not_found';
+    message: string;
+  };
+*/
+function assertIsRelayerV2ApiError404(value, name) {
+    assertRecordStringProperty(value, 'label', name, 'not_found');
+    assertRecordStringProperty(value, 'message', name);
+}
+
+/*
+    export type RelayerV2ApiError503 = {
+      label: "protocol_paused" | "gateway_not_reachable";
+      message: string;
+    };
+*/
+function assertIsRelayerV2ApiError503(value, name) {
+    assertRecordStringProperty(value, 'label', name, [
+        'protocol_paused',
+        'gateway_not_reachable',
+    ]);
+    assertRecordStringProperty(value, 'message', name);
+}
+
+/*
+    export type RelayerV2ApiError504 = {
+      label: 'readiness_check_timedout' | 'response_timedout';
+      message: string;
+    };
+*/
+function assertIsRelayerV2ApiError504(value, name) {
+    assertRecordStringProperty(value, 'label', name, [
+        'readiness_check_timedout',
+        'response_timedout',
+    ]);
+    assertRecordStringProperty(value, 'message', name);
+}
+
+function assertIsRelayerV2ResponseFailed(value, name) {
+    assertRecordStringProperty(value, 'status', name, 'failed');
+    assertNonNullableRecordProperty(value, 'error', name);
+    assertIsRelayerV2ApiError(value.error, `${name}.error`);
+}
+function assertIsRelayerV2ApiError(value, name) {
+    assertRecordStringProperty(value, 'label', name);
+    // 400
+    if (value.label === 'malformed_json' ||
+        value.label === 'request_error' ||
+        value.label === 'not_ready_for_decryption') {
+        assertIsRelayerV2ApiError400NoDetails(value, name);
+    }
+    // 400 (with details)
+    else if (value.label === 'missing_fields' ||
+        value.label === 'validation_failed') {
+        assertIsRelayerV2ApiError400WithDetails(value, name);
+    }
+    // 404
+    else if (value.label === 'not_found') {
+        assertIsRelayerV2ApiError404(value, name);
+    }
+    // 429
+    else if (value.label === 'rate_limited') {
+        assertIsRelayerV2ApiError429(value, name);
+    }
+    // 500
+    else if (value.label === 'internal_server_error') {
+        assertIsRelayerV2ApiError500(value, name);
+    }
+    // 503
+    else if (value.label === 'protocol_paused' ||
+        value.label === 'gateway_not_reachable') {
+        assertIsRelayerV2ApiError503(value, name);
+    }
+    // 504
+    else if (value.label === 'readiness_check_timedout' ||
+        value.label === 'response_timedout') {
+        assertIsRelayerV2ApiError504(value, name);
+    }
+    // Unsupported
+    else {
+        throw new InvalidPropertyError({
+            objName: name,
+            property: 'label',
+            expectedType: 'string',
+            expectedValue: [
+                'malformed_json',
+                'request_error',
+                'not_ready_for_decryption',
+                'missing_fields',
+                'validation_failed',
+                'rate_limited',
+                'internal_server_error',
+                'protocol_paused',
+                'gateway_not_reachable',
+                'readiness_check_timedout',
+                'response_timedout',
+            ],
+            type: typeof value.label,
+            value: value.label,
+        });
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+// 400
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError400(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    if (value.error.label === 'malformed_json' ||
+        value.error.label === 'request_error' ||
+        value.error.label === 'not_ready_for_decryption') {
+        assertIsRelayerV2ApiError400NoDetails(value.error, `${name}.error`);
+    }
+    else if (value.error.label === 'missing_fields' ||
+        value.error.label === 'validation_failed') {
+        assertIsRelayerV2ApiError400WithDetails(value.error, `${name}.error`);
+    }
+    else {
+        throw new InvalidPropertyError({
+            objName: `${name}.error`,
+            property: 'label',
+            expectedType: 'string',
+            expectedValue: [
+                'malformed_json',
+                'request_error',
+                'not_ready_for_decryption',
+                'missing_fields',
+                'validation_failed',
+            ],
+            type: typeof value.error.label,
+            value: value.error.label,
+        });
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+// 404
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError404(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    assertIsRelayerV2ApiError404(value.error, `${name}.error`);
+}
+////////////////////////////////////////////////////////////////////////////////
+// 429
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError429(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    assertIsRelayerV2ApiError429(value.error, `${name}.error`);
+}
+////////////////////////////////////////////////////////////////////////////////
+// 500
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError500(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    assertIsRelayerV2ApiError500(value.error, `${name}.error`);
+}
+////////////////////////////////////////////////////////////////////////////////
+// 503
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError503(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    assertIsRelayerV2ApiError503(value.error, `${name}.error`);
+}
+////////////////////////////////////////////////////////////////////////////////
+// 504
+////////////////////////////////////////////////////////////////////////////////
+function assertIsRelayerV2ResponseFailedWithError504(value, name) {
+    assertIsRelayerV2ResponseFailed(value, name);
+    assertIsRelayerV2ApiError504(value.error, `${name}.error`);
+}
+
+class RelayerV2FetchErrorBase extends RelayerErrorBase {
+    _fetchMethod;
+    _url;
+    _jobId;
+    _operation;
+    _retryCount;
+    _elapsed;
+    _state;
+    constructor(params) {
+        super({
+            ...params,
+            name: params.name ?? 'RelayerV2FetchErrorBase',
+        });
+        this._fetchMethod = params.fetchMethod;
+        this._url = params.url;
+        this._operation = params.operation;
+        this._elapsed = params.elapsed;
+        this._retryCount = params.retryCount;
+        this._state = params.state;
+        this._jobId = params.jobId;
+    }
+    get url() {
+        return this._url;
+    }
+    get operation() {
+        return this._operation;
+    }
+    get fetchMethod() {
+        return this._fetchMethod;
+    }
+    get jobId() {
+        return this._jobId;
+    }
+    get retryCount() {
+        return this._retryCount;
+    }
+    get elapsed() {
+        return this._elapsed;
+    }
+    get state() {
+        return this._state;
+    }
+    get isAbort() {
+        // AbortError is not an instance of Error!
+        return this.cause ? this.cause.name === 'AbortError' : false;
+    }
+}
+
+class RelayerV2ResponseErrorBase extends RelayerV2FetchErrorBase {
+    _status;
+    constructor(params) {
+        super({
+            ...params,
+            name: params.name ?? 'RelayerV2ResponseErrorBase',
+        });
+        this._status = params.status;
+    }
+    get status() {
+        return this._status;
+    }
+}
+
+class RelayerV2ResponseInvalidBodyError extends RelayerV2ResponseErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            cause: ensureError(params.cause),
+            name: 'RelayerV2ResponseInvalidBodyError',
+            message: `fetchMethod: ${params.fetchMethod} status:${params.status} url:${params.url} operation:${params.operation}`,
+        });
+    }
+}
+
+class RelayerV2ResponseStatusError extends RelayerV2ResponseErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2ResponseStatusError',
+            message: `fetchMethod: ${params.fetchMethod} status:${params.status} url:${params.url} operation:${params.operation}`,
+        });
+    }
+}
+
+function assertIsRelayerV2ResultInputProof(value, name) {
+    assertRecordBooleanProperty(value, 'accepted', name);
+    if (value.accepted) {
+        assertIsRelayerV2ResultInputProofAccepted(value, name);
+    }
+    else {
+        assertIsRelayerV2ResultInputProofRejected(value, name);
+    }
+}
+/*
+    type RelayerV2ResultInputProofAccepted = {
+        accepted: true;
+        extra_data: BytesHex;
+        handles: Bytes32Hex[];
+        signatures: BytesHex[];
+    }
+*/
+function assertIsRelayerV2ResultInputProofAccepted(value, name) {
+    assertRecordBooleanProperty(value, 'accepted', name, true);
+    assertRecordBytes32HexArrayProperty(value, 'handles', name);
+    assertRecordBytesHexArrayProperty(value, 'signatures', name);
+    assertRecordBytesHexProperty(value, 'extraData', name);
+}
+/*
+    type RelayerV2ResultInputProofRejected = {
+        accepted: false;
+        extra_data: BytesHex;
+    }
+*/
+function assertIsRelayerV2ResultInputProofRejected(value, name) {
+    assertRecordBooleanProperty(value, 'accepted', name, false);
+    assertRecordBytesHexProperty(value, 'extraData', name);
+}
+
+function assertIsRelayerV2GetResponseInputProofSucceeded(value, name) {
+    assertNonNullableRecordProperty(value, 'result', name);
+    assertRecordStringProperty(value, 'status', name, 'succeeded');
+    assertRecordStringProperty(value, 'requestId', name);
+    assertIsRelayerV2ResultInputProof(value.result, `${name}.result`);
+}
+
+function assertIsRelayerV2ResultPublicDecrypt(value, name) {
+    assertRecordBytesHexNo0xArrayProperty(value, 'signatures', name);
+    assertRecordBytesHexNo0xProperty(value, 'decryptedValue', name);
+    assertRecordBytesHexProperty(value, 'extraData', name);
+}
+
+function assertIsRelayerV2GetResponsePublicDecryptSucceeded(value, name) {
+    assertNonNullableRecordProperty(value, 'result', name);
+    assertRecordStringProperty(value, 'status', name, 'succeeded');
+    assertRecordStringProperty(value, 'requestId', name);
+    assertIsRelayerV2ResultPublicDecrypt(value.result, `${name}.result`);
+}
+
+/**
+ * Assertion function that validates a value is a valid `RelayerV2ResultUserDecrypt` object.
+ * Validates the structure returned from the relayer for user decryption operations.
+ * Throws an `InvalidPropertyError` if validation fails.
+ *
+ * @param value - The value to validate (can be any type)
+ * @param name - The name of the value being validated (used in error messages)
+ * @throws {InvalidPropertyError} When any required property is missing or has an invalid format
+ * @throws {never} No other errors are thrown
+ */
+function assertIsRelayerV2ResultUserDecrypt(value, name) {
+    assertRecordArrayProperty(value, 'result', name);
+    for (let i = 0; i < value.result.length; ++i) {
+        // Missing extraData
+        assertRecordBytesHexNo0xProperty(value.result[i], 'payload', `${name}.result[${i}]`);
+        assertRecordBytesHexNo0xProperty(value.result[i], 'signature', `${name}.result[${i}]`);
+    }
+}
+
+function assertIsRelayerV2GetResponseUserDecryptSucceeded(value, name) {
+    assertNonNullableRecordProperty(value, 'result', name);
+    assertRecordStringProperty(value, 'status', name, 'succeeded');
+    assertRecordStringProperty(value, 'requestId', name);
+    assertIsRelayerV2ResultUserDecrypt(value.result, `${name}.result`);
+}
+
+class RelayerV2RequestErrorBase extends RelayerErrorBase {
+    _url;
+    _operation;
+    _jobId;
+    constructor(params) {
+        super({ ...params, name: params.name ?? 'RelayerV2RequestErrorBase' });
+        this._url = params.url;
+        this._operation = params.operation;
+        this._jobId = params.jobId;
+    }
+    get url() {
+        return this._url;
+    }
+    get jobId() {
+        return this._jobId;
+    }
+    get operation() {
+        return this._operation;
+    }
+}
+
+class RelayerV2RequestInternalError extends RelayerV2RequestErrorBase {
+    _status;
+    _state;
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2RequestInternalError',
+            message: params.message ?? 'internal error',
+        });
+        this._status = params.status;
+        this._state = params.state;
+    }
+    get status() {
+        return this._status;
+    }
+    get state() {
+        return this._state;
+    }
+}
+
+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({
+            ...params,
+            name: 'RelayerV2ResponseApiError',
+            message: params.relayerApiError.message,
+        });
+    }
+}
+
+class RelayerV2FetchError extends RelayerV2FetchErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2FetchError',
+            message: `Fetch ${params.fetchMethod} error`,
+            cause: ensureError(params.cause),
+        });
+    }
+}
+
+class RelayerV2ResponseInputProofRejectedError extends RelayerV2ResponseErrorBase {
+    _result;
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2ResponseInputProofRejectedError',
+            message: `InputProof rejected`,
+        });
+        this._result = params.result;
+    }
+    get result() {
+        return this._result;
+    }
+}
+
+class RelayerV2StateError extends RelayerErrorBase {
+    _state;
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2StateError',
+        });
+        this._state = { ...params.state };
+        Object.freeze(this._state);
+    }
+    get state() {
+        return this._state;
+    }
+}
+
+class RelayerV2MaxRetryError extends RelayerV2FetchErrorBase {
+    constructor(params) {
+        super({
+            ...params,
+            name: 'RelayerV2MaxRetryError',
+            message: 'max retry error',
+        });
+    }
+}
+
+class RelayerV2AsyncRequest {
+    _jobId;
+    _jobIdTimestamp;
+    _state;
+    _relayerOperation;
+    _publicAPINoReentrancy;
+    _internalAbortController;
+    _internalAbortSignal;
+    _externalAbortSignal;
+    _terminateReason;
+    _terminateError;
+    _retryCount;
+    _retryAfterTimeoutID;
+    _url;
+    _payload;
+    _fhevmInstanceOptions;
+    _retryAfterTimeoutPromiseFuncReject;
+    _onProgress;
+    _requestMaxDurationInSecs;
+    _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;
+    constructor(params) {
+        if (params.relayerOperation !== 'INPUT_PROOF' &&
+            params.relayerOperation !== 'PUBLIC_DECRYPT' &&
+            params.relayerOperation !== 'USER_DECRYPT') {
+            throw new InvalidPropertyError({
+                objName: 'RelayerV2AsyncRequestParams',
+                property: 'relayerOperation',
+                expectedType: 'string',
+                value: params.relayerOperation,
+                expectedValue: 'INPUT_PROOF | PUBLIC_DECRYPT | USER_DECRYPT',
+            });
+        }
+        this._relayerOperation = params.relayerOperation;
+        this._internalAbortController = new AbortController();
+        this._internalAbortSignal = this._internalAbortController.signal;
+        this._internalAbortSignal.addEventListener('abort', this._handleInternalSignalAbort);
+        this._externalAbortSignal = params.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._state = {
+            aborted: false,
+            canceled: false,
+            failed: false,
+            fetching: false,
+            running: false,
+            succeeded: false,
+            terminated: false,
+        };
+        this._retryCount = 0;
+        this._retryAfterTimeoutID = undefined;
+        this._requestGlobalTimeoutID = undefined;
+        this._terminateReason = undefined;
+        this._publicAPINoReentrancy = false;
+        this._throwErrorIfNoRetryAfter = params.throwErrorIfNoRetryAfter ?? false;
+        this._requestMaxDurationInSecs =
+            params.timeoutInSeconds ??
+                RelayerV2AsyncRequest.DEFAULT_GLOBAL_REQUEST_TIMEOUT_SECS;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Public API: run
+    //////////////////////////////////////////////////////////////////////////////
+    async run() {
+        if (this._publicAPINoReentrancy) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Call not permitted.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.terminated) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already terminated.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.canceled) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already canceled.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.succeeded) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already succeeded.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.failed) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already failed.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.aborted) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already aborted.`,
+                state: { ...this._state },
+            });
+        }
+        if (this._externalAbortSignal?.aborted === true) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. External AbortSignal already aborted (reason:${this._externalAbortSignal?.reason}).`,
+                state: { ...this._state },
+            });
+        }
+        if (this._internalAbortSignal?.aborted === true) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Internal AbortSignal already aborted (reason:${this._internalAbortSignal?.reason}).`,
+                state: { ...this._state },
+            });
+        }
+        if (this._state.running) {
+            throw new RelayerV2StateError({
+                message: `Relayer.run() failed. Request already running.`,
+                state: { ...this._state },
+            });
+        }
+        this._state.running = true;
+        this._requestStartTimestamp = Date.now();
+        this._setGlobalRequestTimeout(this._requestMaxDurationInSecs * 1000);
+        try {
+            const json = await this._runPostLoop();
+            this._state.succeeded = true;
+            this._terminate('succeeded');
+            return json;
+        }
+        catch (e) {
+            this._state.failed = true;
+            if (e.name === 'AbortError') {
+                this._assert(this._state.aborted, 'this._state.aborted');
+                this._assert(this._state.terminated, 'this._state.terminated');
+            }
+            // Ignored if already terminated. For example, if abort has been previously called.
+            this._terminate('failed', e);
+            throw e;
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Public API: cancel
+    //////////////////////////////////////////////////////////////////////////////
+    _canContinue() {
+        return !(this._state.canceled ||
+            this._state.terminated ||
+            this._state.succeeded ||
+            this._state.aborted);
+    }
+    cancel() {
+        if (this._publicAPINoReentrancy) {
+            throw new RelayerV2StateError({
+                message: `Relayer.cancel() failed. Call not permitted.`,
+                state: { ...this._state },
+            });
+        }
+        if (!this._canContinue()) {
+            this._trace('cancel', '!this._canContinue()');
+            return;
+        }
+        this._state.canceled = true;
+        this._internalAbortController?.abort('cancel');
+        // Debug
+        this._assert(this._state.aborted, 'this._state.aborted');
+        this._assert(this._state.terminated, 'this._state.terminated');
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Public API: getters
+    //////////////////////////////////////////////////////////////////////////////
+    get state() {
+        return { ...this._state };
+    }
+    get canceled() {
+        return this._state.canceled;
+    }
+    get terminated() {
+        return this._state.terminated;
+    }
+    get terminateReason() {
+        return this._terminateReason;
+    }
+    get terminateError() {
+        return this._terminateError;
+    }
+    get running() {
+        return this._state.running;
+    }
+    get fetching() {
+        return this._state.fetching;
+    }
+    get failed() {
+        return this._state.failed;
+    }
+    get succeeded() {
+        return this._state.succeeded;
+    }
+    get startTimeMs() {
+        return this._requestStartTimestamp;
+    }
+    get elapsedTimeMs() {
+        if (this._requestStartTimestamp === undefined) {
+            return undefined;
+        }
+        return Date.now() - this._requestStartTimestamp;
+    }
+    get retryCount() {
+        return this._retryCount;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Post Loop
+    //////////////////////////////////////////////////////////////////////////////
+    // POST : 202 | 400 | 429 | 500 | 503
+    async _runPostLoop() {
+        // No infinite loop!
+        let i = 0;
+        while (i < RelayerV2AsyncRequest.MAX_POST_RETRY) {
+            ++i;
+            this._assertCanContinueAfterAwait();
+            // At this stage: `terminated` is guaranteed to be `false`.
+            // However, the `fetch` call can potentially throw an `AbortError`. In this case
+            // in the error catch the `terminated` flag will be `true`! But, that's ok because the
+            // next part of the function will never be executed (thrown error).
+            const elapsed = this._jobId ? Date.now() - this._jobIdTimestamp : 0;
+            const response = await this._fetchPost(elapsed);
+            // At this stage: `terminated` is guaranteed to be `false`.
+            const responseStatus = response.status;
+            switch (responseStatus) {
+                // RelayerV2ResponseQueued
+                case 202: {
+                    // response.json() errors:
+                    // 1. if body is already read (call json() 2 times)
+                    //    - TypeError: Body is unusable: Body has already been read
+                    // 2. if body is invalid JSON
+                    //    - SyntaxError: Unexpected end of JSON input
+                    //    - 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');
+                    }
+                    catch (cause) {
+                        this._throwInvalidResponseError({
+                            fetchMethod: 'POST',
+                            status: responseStatus,
+                            cause: cause,
+                            elapsed,
+                        });
+                    }
+                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
+                    if (retry_after_sec < 1)
+                        retry_after_sec = 1;
+                    // Debug: will throw an assert failed error if jobId has already been set
+                    this._setJobIdOnce(bodyJson.result.jobId);
+                    // Async onProgress callback
+                    this._postAsyncOnProgressCallback({
+                        type: 'queued',
+                        url: this._url,
+                        method: 'POST',
+                        status: responseStatus,
+                        requestId: bodyJson.requestId,
+                        jobId: this.jobId,
+                        operation: this._relayerOperation,
+                        retryCount: this._retryCount,
+                        retryAfter: retry_after_sec,
+                        elapsed,
+                    });
+                    // Wait if needed (minimum 1s)
+                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    const json = await this._runGetLoop();
+                    return json;
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError400
+                // RelayerV2ApiError400WithDetails
+                case 400: {
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError400(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwInvalidResponseError({
+                            fetchMethod: 'POST',
+                            status: responseStatus,
+                            cause: cause,
+                            elapsed,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'POST',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError429
+                case 429: {
+                    // Retry
+                    // Rate Limit error (Cloudflare/Kong/Relayer), reason in message
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError429(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwInvalidResponseError({
+                            fetchMethod: 'POST',
+                            status: responseStatus,
+                            cause: cause,
+                            elapsed,
+                        });
+                    }
+                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
+                    if (retry_after_sec < 1)
+                        retry_after_sec = 1;
+                    // Async onProgress callback
+                    this._postAsyncOnProgressCallback({
+                        type: 'ratelimited',
+                        url: this._url,
+                        method: 'POST',
+                        status: responseStatus,
+                        retryAfter: retry_after_sec,
+                        retryCount: this._retryCount,
+                        elapsed,
+                        message: bodyJson.error.message,
+                    });
+                    // Wait if needed (minimum 1s)
+                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    continue;
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError500
+                case 500: {
+                    // Abort
+                    // Relayer internal error
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError500(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwInvalidResponseError({
+                            fetchMethod: 'POST',
+                            status: responseStatus,
+                            cause: cause,
+                            elapsed,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'POST',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError503
+                case 503: {
+                    // Abort
+                    // Possible Reasons: Gateway has some internal error (unknown)
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError503(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwInvalidResponseError({
+                            fetchMethod: 'POST',
+                            status: responseStatus,
+                            cause: cause,
+                            elapsed,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'POST',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                default: {
+                    // Use TS compiler + `never` to guarantee the switch integrity
+                    const throwUnsupportedStatus = (unsupportedStatus) => {
+                        throw new RelayerV2ResponseStatusError({
+                            fetchMethod: 'POST',
+                            status: unsupportedStatus,
+                            url: this._url,
+                            operation: this._relayerOperation,
+                            elapsed,
+                            retryCount: this._retryCount,
+                            state: { ...this._state },
+                        });
+                    };
+                    throwUnsupportedStatus(responseStatus);
+                }
+            }
+        }
+        // Max retry error
+        this._throwMaxRetryError({ fetchMethod: 'POST' });
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Get Loop
+    //////////////////////////////////////////////////////////////////////////////
+    // GET: 200 | 202 | 404 | 500 | 503 | 504
+    // GET is not rate-limited, therefore there is not 429 error
+    async _runGetLoop() {
+        this._assert(this._jobId !== undefined, 'this._jobId !== undefined');
+        this._assert(this._jobIdTimestamp !== undefined, 'this._jobIdTimestamp !== undefined');
+        let i = 0;
+        while (i < RelayerV2AsyncRequest.MAX_GET_RETRY) {
+            ++i;
+            this._assertCanContinueAfterAwait();
+            const elapsed = Date.now() - this._jobIdTimestamp;
+            const response = await this._fetchGet(elapsed);
+            // At this stage: `terminated` is guaranteed to be `false`.
+            const responseStatus = response.status;
+            switch (responseStatus) {
+                // RelayerV2GetResponseSucceeded
+                case 200: {
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        if (this._relayerOperation === 'INPUT_PROOF') {
+                            assertIsRelayerV2GetResponseInputProofSucceeded(bodyJson, 'body');
+                            // Async onProgress callback
+                            this._postAsyncOnProgressCallback({
+                                type: 'succeeded',
+                                url: this._url,
+                                method: 'GET',
+                                status: responseStatus,
+                                jobId: this.jobId,
+                                requestId: bodyJson.requestId,
+                                operation: this._relayerOperation,
+                                retryCount: this._retryCount,
+                                elapsed,
+                                result: bodyJson.result,
+                            });
+                            if (!bodyJson.result.accepted) {
+                                const e = new RelayerV2ResponseInputProofRejectedError({
+                                    url: this._url,
+                                    fetchMethod: 'GET',
+                                    jobId: this.jobId,
+                                    operation: this._relayerOperation,
+                                    retryCount: this._retryCount,
+                                    status: responseStatus,
+                                    state: { ...this._state },
+                                    elapsed,
+                                    result: bodyJson.result,
+                                });
+                                throw e;
+                            }
+                        }
+                        else if (this._relayerOperation === 'PUBLIC_DECRYPT') {
+                            assertIsRelayerV2GetResponsePublicDecryptSucceeded(bodyJson, 'body');
+                            // Async onProgress callback
+                            this._postAsyncOnProgressCallback({
+                                type: 'succeeded',
+                                url: this._url,
+                                method: 'GET',
+                                status: responseStatus,
+                                jobId: this.jobId,
+                                requestId: bodyJson.requestId,
+                                operation: this._relayerOperation,
+                                retryCount: this._retryCount,
+                                elapsed,
+                                result: bodyJson.result,
+                            });
+                        }
+                        else if (this._relayerOperation === 'USER_DECRYPT') {
+                            assertIsRelayerV2GetResponseUserDecryptSucceeded(bodyJson, 'body');
+                            // Async onProgress callback
+                            this._postAsyncOnProgressCallback({
+                                type: 'succeeded',
+                                url: this._url,
+                                method: 'GET',
+                                status: responseStatus,
+                                jobId: this.jobId,
+                                requestId: bodyJson.requestId,
+                                operation: this._relayerOperation,
+                                retryCount: this._retryCount,
+                                elapsed,
+                                result: bodyJson.result,
+                            });
+                        }
+                    }
+                    catch (cause) {
+                        // Special case for InputProof rejected
+                        if (cause instanceof RelayerV2ResponseInputProofRejectedError) {
+                            throw cause;
+                        }
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    // RelayerV2ResultPublicDecrypt
+                    // RelayerV2ResultUserDecrypt
+                    // RelayerV2ResultInputProof;
+                    return bodyJson.result;
+                }
+                // RelayerV2ResponseQueued
+                case 202: {
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseQueued(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
+                    if (retry_after_sec < 1)
+                        retry_after_sec = 1;
+                    // Async onProgress callback
+                    this._postAsyncOnProgressCallback({
+                        type: 'queued',
+                        url: this._url,
+                        method: 'GET',
+                        status: responseStatus,
+                        requestId: bodyJson.requestId,
+                        operation: this._relayerOperation,
+                        jobId: this.jobId,
+                        retryAfter: retry_after_sec,
+                        retryCount: this._retryCount,
+                        elapsed,
+                    });
+                    // Wait if needed (minimum 1s)
+                    await this._setRetryAfterTimeout(retry_after_sec * 1000);
+                    continue;
+                }
+                case 400: {
+                    // Abort
+                    // Wrong jobId, incorrect format or unknown value etc.
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError400(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'GET',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                case 404: {
+                    // Abort
+                    // Wrong jobId, incorrect format or unknown value etc.
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError404(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'GET',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError500
+                case 500: {
+                    // Abort
+                    // Relayer internal error
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError500(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'GET',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError503
+                case 503: {
+                    // Abort
+                    // Possible Reasons: Gateway has some internal error (unknown)
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError503(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'GET',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                // RelayerV2ResponseFailed
+                // RelayerV2ApiError504
+                case 504: {
+                    // Abort
+                    // Possible Reasons: Gateway has not responded in time (gateway timeout)
+                    const bodyJson = await this._getResponseJson(response);
+                    try {
+                        assertIsRelayerV2ResponseFailedWithError504(bodyJson, 'body');
+                    }
+                    catch (cause) {
+                        this._throwResponseInvalidBodyError({
+                            fetchMethod: 'GET',
+                            status: responseStatus,
+                            elapsed,
+                            cause: cause,
+                        });
+                    }
+                    this._throwRelayerV2ResponseApiError({
+                        fetchMethod: 'GET',
+                        status: responseStatus,
+                        relayerApiError: bodyJson.error,
+                        elapsed,
+                    });
+                }
+                default: {
+                    // Use TS compiler + `never` to guarantee the switch integrity
+                    const throwUnsupportedStatus = (unsupportedStatus) => {
+                        throw new RelayerV2ResponseStatusError({
+                            fetchMethod: 'GET',
+                            status: unsupportedStatus,
+                            url: this._url,
+                            jobId: this.jobId,
+                            operation: this._relayerOperation,
+                            elapsed,
+                            retryCount: this._retryCount,
+                            state: { ...this._state },
+                        });
+                    };
+                    throwUnsupportedStatus(responseStatus);
+                }
+            }
+        }
+        // Max retry error
+        this._throwMaxRetryError({ fetchMethod: 'GET' });
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    async _getResponseJson(response) {
+        const bodyJson = await response.json();
+        this._assertCanContinueAfterAwait();
+        return bodyJson;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    _getRetryAfterHeaderValueInSecs(response) {
+        if (!response.headers.has('Retry-After')) {
+            if (this._throwErrorIfNoRetryAfter) {
+                throw new Error(`Missing 'Retry-After' header key`);
+            }
+            return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_SECS;
+        }
+        try {
+            const n = Number.parseInt(response.headers.get('Retry-After'));
+            if (isUint(n)) {
+                return n;
+            }
+        }
+        catch {
+            //
+        }
+        if (this._throwErrorIfNoRetryAfter) {
+            throw new Error(`Invalid 'Retry-After' header key`);
+        }
+        return RelayerV2AsyncRequest.DEFAULT_RETRY_AFTER_SECS;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // JobId
+    //////////////////////////////////////////////////////////////////////////////
+    /**
+     * Sets the unique job identifier for this request.
+     *
+     * This function enforces a strict initialization constraint: the jobId must be
+     * set exactly once during the entire lifecycle of the state machine instance.
+     *
+     * This immutability ensures that all subsequent operations, logging, and state
+     * transitions are consistently associated with the correct external request.
+     *
+     * @param jobId - The unique identifier associated with the asynchronous job request.
+     * @private
+     * @throws {RelayerV2RequestInternalError} Thrown if jobId is undefined or if the jobId has already been set.
+     */
+    _setJobIdOnce(jobId) {
+        this._assert(jobId !== undefined, 'jobId !== undefined');
+        this._assert(this._jobId === undefined, 'this._jobId === undefined');
+        this._jobId = jobId;
+        this._jobIdTimestamp = Date.now();
+    }
+    get jobId() {
+        this._assert(this._jobId !== undefined, 'this._jobId !== undefined');
+        return this._jobId;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Fetch functions
+    //////////////////////////////////////////////////////////////////////////////
+    async _fetchPost(elapsed) {
+        // Debug state-check guards:
+        // - the jobId is guaranteed to be undefined.
+        // - `terminated` is guaranteed to be `false`
+        // - `fetching` is guaranteed to be `false`
+        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');
+        const init = setAuth({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(this._payload),
+            ...(this._internalAbortSignal
+                ? { signal: this._internalAbortSignal }
+                : {}),
+        }, this._fhevmInstanceOptions?.auth);
+        this._state.fetching = true;
+        let response;
+        try {
+            response = await fetch(this._url, init);
+        }
+        catch (cause) {
+            this._state.fetching = false;
+            // Warning: `terminated` can be `true` here!
+            // (ex: if `controller.abort()` has been called from the outside while still executing `fetch`)
+            this._trace('_fetchPost', 'catch(e) + throw e: ' + cause);
+            // Keep the standard 'AbortError'
+            if (cause.name === 'AbortError') {
+                throw cause;
+            }
+            else {
+                this._throwFetchError({
+                    fetchMethod: 'POST',
+                    cause,
+                    elapsed,
+                });
+            }
+        }
+        this._state.fetching = false;
+        // Debug state-check guards:
+        // - the jobId is guaranteed to be undefined.
+        // - `terminated` is guaranteed to be `false`
+        this._assert(this._jobId === undefined, 'this._jobId === undefined');
+        this._assert(!this._state.terminated, '!this._state.terminated');
+        // Debug
+        this._assertCanContinueAfterAwait();
+        this._trace('_fetchPost', 'return response Ok');
+        return response;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    async _fetchGet(elapsed) {
+        // Debug state-check guards:
+        // - the jobId is guaranteed to be set.
+        // - `terminated` is guaranteed to be `false`
+        // - `fetching` is guaranteed to be `false`
+        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('_fetchGet', `jobId=${this.jobId}`);
+        const init = this._internalAbortSignal
+            ? { signal: this._internalAbortSignal }
+            : undefined;
+        this._state.fetching = true;
+        let response;
+        try {
+            response = await fetch(`${this._url}/${this.jobId}`, init);
+        }
+        catch (cause) {
+            this._state.fetching = false;
+            // Warning: `terminated` can be `true` here!
+            // (ex: if `controller.abort()` has been called from the outside while still executing `fetch`)
+            this._trace('_fetchGet', `jobId=${this.jobId}, catch(e) + throw e: ${cause}`);
+            // Keep the standard 'AbortError'
+            if (cause.name === 'AbortError') {
+                throw cause;
+            }
+            else {
+                this._throwFetchError({
+                    fetchMethod: 'GET',
+                    cause,
+                    elapsed,
+                });
+            }
+        }
+        this._state.fetching = false;
+        // Debug state-check guards:
+        // - the jobId is guaranteed to be set.
+        // - `terminated` is guaranteed to be `false`
+        this._assert(this._jobId !== undefined, 'this._jobId !== undefined');
+        this._assert(!this._state.terminated, '!this._state.terminated');
+        // Debug
+        this._assertCanContinueAfterAwait();
+        this._trace('_fetchGet', `jobId=${this.jobId}, return response Ok, status=${response.status}`);
+        return response;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // AbortSignal
+    //////////////////////////////////////////////////////////////////////////////
+    // Warning: Use arrow function only!
+    _handleExternalSignalAbort = (ev) => {
+        const signal = ev.currentTarget;
+        // TESTING: the following sequences must be extensively tested:
+        // ============================================================
+        //
+        // Each steps could potentially be called synchronously one after the other
+        // or asynchronously: step 2 is called from the next microtick
+        //
+        // 1. externalSignal.abort();
+        // 2. request.cancel();
+        //
+        // 1. externalSignal.abort();
+        // 2. externalSignal.abort();
+        //
+        // 1. request.cancel();
+        // 2. externalSignal.abort();
+        // Debug state-check guards:
+        this._assert(this instanceof RelayerV2AsyncRequest, `this instanceof RelayerV2AsyncRequest`);
+        this._assert(signal === this._externalAbortSignal, 'signal === this._externalAbortSignal');
+        this._assert(!this._state.terminated, `!this._state.terminated`);
+        this._assert(!this._state.aborted, '!this._state.aborted');
+        this._assert(!this._state.canceled, '!this._state.canceled');
+        this.cancel();
+    };
+    // Warning: Use arrow function only!
+    _handleInternalSignalAbort = (ev) => {
+        const signal = ev.currentTarget;
+        // Debug state-check guards:
+        this._assert(this instanceof RelayerV2AsyncRequest, `this instanceof RelayerV2AsyncRequest`);
+        this._assert(signal === this._internalAbortSignal, 'signal === this._internalAbortSignal');
+        this._assert(!this._state.terminated, `!this._state.terminated`);
+        this._assert(!this._state.aborted, '!this._state.aborted');
+        this._state.aborted = true;
+        if (signal.reason !== 'cancel') {
+            this._assert(!this._state.canceled, '!this._state.canceled');
+        }
+        this._terminate('abort');
+    };
+    //////////////////////////////////////////////////////////////////////////////
+    // Terminate
+    //////////////////////////////////////////////////////////////////////////////
+    /**
+     * Can be called multiple times
+     */
+    _terminate(reason, error) {
+        // Warning: this._state.fetching can be true
+        // ex: call cancel while fetch is running
+        if (this._state.terminated) {
+            this._trace(`_terminate`, `reason=${reason}. Already terminated with reason='${this._terminateReason}'. IGNORE`);
+            this._assert(this._terminateReason !== undefined, 'this._terminateReason !== undefined');
+            this._assert(this._internalAbortSignal === undefined, 'this._signal === undefined');
+            this._assert(this._requestGlobalTimeoutID === undefined, 'this._requestGlobalTimeoutID === undefined');
+            this._assert(this._retryAfterTimeoutID === undefined, 'this._retryAfterTimeoutID === undefined');
+            this._assert(this._retryAfterTimeoutPromiseFuncReject === undefined, 'this._retryAfterTimeoutPromiseFuncReject === undefined');
+            return;
+        }
+        this._trace('_terminate', `reason=${reason}`);
+        this._terminateReason = reason;
+        this._terminateError = error;
+        this._state.terminated = true;
+        this._tryClearRetryAfterTimeout();
+        this._tryClearGlobalRequestTimeout();
+        const is = this._internalAbortSignal;
+        const es = this._externalAbortSignal;
+        this._externalAbortSignal = undefined;
+        this._internalAbortSignal = undefined;
+        this._internalAbortController = undefined;
+        if (es) {
+            es.removeEventListener('abort', this._handleExternalSignalAbort);
+        }
+        if (is) {
+            is.removeEventListener('abort', this._handleInternalSignalAbort);
+        }
+        this._trace('_terminate', `reason=${reason} completed.`);
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Retry-After timeout
+    //////////////////////////////////////////////////////////////////////////////
+    async _setRetryAfterTimeout(delayMs) {
+        // Debug
+        this._assert(!this._state.terminated, '!this._state.terminated');
+        this._assert(this._retryAfterTimeoutID === undefined, 'this._retryAfterTimeoutID === undefined');
+        this._assert(delayMs >= 1000, 'delayMs >= 1000');
+        this._trace('_setRetryAfterTimeout', `delayMs=${delayMs}`);
+        if (this._retryAfterTimeoutID !== undefined) {
+            return Promise.reject(new Error(`retry-after already running.`));
+        }
+        const p = new Promise((resolve, reject) => {
+            this._retryAfterTimeoutPromiseFuncReject = reject;
+            const callback = () => {
+                this._retryAfterTimeoutID = undefined;
+                this._retryAfterTimeoutPromiseFuncReject = undefined;
+                resolve();
+            };
+            this._retryCount++;
+            this._retryAfterTimeoutID = setTimeout(callback, delayMs);
+        });
+        this._assert(this._retryAfterTimeoutID !== undefined, 'this._retryAfterTimeoutID !== undefined');
+        this._assert(this._retryAfterTimeoutPromiseFuncReject !== undefined, 'this._retryAfterTimeoutPromiseFuncReject !== undefined');
+        return p;
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    _tryClearRetryAfterTimeout() {
+        if (this._retryAfterTimeoutID === undefined) {
+            // Debug
+            this._assert(this._retryAfterTimeoutPromiseFuncReject === undefined, 'this._retryAfterTimeoutPromiseFuncReject === undefined');
+            return;
+        }
+        const reject = this._retryAfterTimeoutPromiseFuncReject;
+        const tid = this._retryAfterTimeoutID;
+        this._retryAfterTimeoutID = undefined;
+        this._retryAfterTimeoutPromiseFuncReject = undefined;
+        clearTimeout(tid);
+        reject(new Error('_tryClearRetryAfterTimeout'));
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Global Request Timeout
+    //////////////////////////////////////////////////////////////////////////////
+    _setGlobalRequestTimeout(delayMs) {
+        // Debug
+        this._assert(this._requestGlobalTimeoutID === undefined, 'this._requestGlobalTimeoutID === undefined');
+        const callback = () => {
+            this._requestGlobalTimeoutID = undefined;
+            this._handleGlobalRequestTimeout();
+        };
+        this._requestGlobalTimeoutID = setTimeout(callback, delayMs);
+    }
+    _handleGlobalRequestTimeout() {
+        this._terminate('timeout');
+    }
+    _tryClearGlobalRequestTimeout() {
+        if (this._requestGlobalTimeoutID === undefined) {
+            return;
+        }
+        const tid = this._requestGlobalTimeoutID;
+        this._requestGlobalTimeoutID = undefined;
+        clearTimeout(tid);
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Progress
+    //////////////////////////////////////////////////////////////////////////////
+    _postAsyncOnProgressCallback(args) {
+        const onProgressFunc = this._onProgress;
+        if (onProgressFunc) {
+            // setTimeout(() => {
+            //   onProgressFunc(args);
+            // }, 0);
+            // onProgressFunc() will execute asynchronously in the next cycle of
+            // the JavaScript event loop (the microtask queue).
+            // Promise.resolve().then(() => {
+            //   onProgressFunc(args);
+            // });
+            queueMicrotask(() => {
+                onProgressFunc(args);
+            });
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Errors
+    //////////////////////////////////////////////////////////////////////////////
+    _throwRelayerV2ResponseApiError(params) {
+        // Clone
+        const clonedRelayerApiError = JSON.parse(JSON.stringify(params.relayerApiError));
+        // Async onProgress callback
+        this._postAsyncOnProgressCallback({
+            type: 'failed',
+            url: this._url,
+            method: params.fetchMethod,
+            status: params.status,
+            ...(this._jobId ? { jobId: this._jobId } : {}),
+            operation: this._relayerOperation,
+            retryCount: this._retryCount,
+            elapsed: params.elapsed,
+            relayerApiError: clonedRelayerApiError,
+        });
+        throw new RelayerV2ResponseApiError({
+            url: this._url,
+            fetchMethod: params.fetchMethod,
+            status: params.status,
+            jobId: this._jobId,
+            operation: this._relayerOperation,
+            retryCount: this._retryCount,
+            elapsed: params.elapsed,
+            relayerApiError: params.relayerApiError,
+            state: { ...this._state },
+        });
+    }
+    _assert(condition, message) {
+        if (!condition) {
+            this._throwInternalError(`Assertion failed: ${message}`);
+        }
+    }
+    _throwInternalError(message) {
+        throw new RelayerV2RequestInternalError({
+            operation: this._relayerOperation,
+            url: this._url,
+            message,
+            state: JSON.stringify(this._state),
+            jobId: this._jobId, // internal value
+        });
+    }
+    _throwMaxRetryError(params) {
+        const elapsed = this._jobIdTimestamp
+            ? Date.now() - this._jobIdTimestamp
+            : 0;
+        throw new RelayerV2MaxRetryError({
+            operation: this._relayerOperation,
+            url: this._url,
+            state: { ...this._state },
+            retryCount: this._retryCount,
+            jobId: this._jobId, // internal value
+            fetchMethod: params.fetchMethod,
+            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,
+            operation: this._relayerOperation,
+            state: { ...this._state },
+            retryCount: this._retryCount,
+        });
+    }
+    _throwFetchError(params) {
+        throw new RelayerV2FetchError({
+            ...params,
+            url: this._url,
+            jobId: this._jobId,
+            operation: this._relayerOperation,
+            state: { ...this._state },
+            retryCount: this._retryCount,
+        });
+    }
+    /**
+     * Assert Continuation Guard
+     *
+     * This internal method implements a state-check guard to ensure the state machine
+     * can safely proceed after an asynchronous operation has completed.
+     *
+     * In a state machine with asynchronous calls (e.g., fetch, timer delays), the system's
+     * state (e.g., this._state) might change externally during the 'await' pause
+     * (e.g., due to a timeout, an external abort signal, or a concurrent state transition).
+     *
+     * If the internal check (this._canContinue()) returns false, it means the current
+     * operation is no longer valid, and execution must stop immediately to prevent state corruption.
+     * This pattern is essential for reliable asynchronous state machines.
+     *
+     * @throws {RelayerV2RequestInternalError} Thrown if the state check fails (i.e., this._canContinue() is false).
+     * The error includes relevant state information (like current state and jobId)
+     * to aid in debugging the exact point of the integrity failure.
+     */
+    _assertCanContinueAfterAwait() {
+        if (!this._canContinue()) {
+            this._throwInternalError('cannot continue.');
+        }
+    }
+    //////////////////////////////////////////////////////////////////////////////
+    // Trace
+    //////////////////////////////////////////////////////////////////////////////
+    _trace(functionName, message) {
+        console.log(`[RelayerV2AsyncRequest]:${functionName}: ${message}`);
+    }
+}
+
+function assertIsRelayerV2GetResponseKeyUrl(value, name) {
+    assertNonNullableRecordProperty(value, 'response', name);
+    // crs
+    assertNonNullableRecordProperty(value.response, 'crs', `${name}.response`);
+    const crs = value.response.crs;
+    const keys = Object.keys(crs);
+    for (let i = 0; i < keys.length; ++i) {
+        // RelayerV2KeyData
+        assertIsRelayerV2KeyData(crs[keys[i]], `${name}.response.crs.${keys[i]}`);
+    }
+    // fhe_key_info
+    assertRecordArrayProperty(value.response, 'fheKeyInfo', `${name}.response`);
+    const fheKeyInfo = value.response.fheKeyInfo;
+    for (let i = 0; i < fheKeyInfo.length; ++i) {
+        const ki = fheKeyInfo[i];
+        const kiName = `${name}.response.fheKeyInfo[${i}]`;
+        assertNonNullableRecordProperty(ki, 'fhePublicKey', kiName);
+        assertIsRelayerV2KeyData(ki.fhePublicKey, `${kiName}.fhePublicKey`);
+    }
+}
+function assertIsRelayerV2KeyData(value, name) {
+    assertRecordStringProperty(value, 'dataId', name);
+    assertRecordStringArrayProperty(value, 'urls', name);
+}
+function toRelayerKeyUrlResponse(response) {
+    const fheKeyInfoV1 = response.response.fheKeyInfo.map((v2Info) => ({
+        fhe_public_key: {
+            data_id: v2Info.fhePublicKey.dataId,
+            urls: v2Info.fhePublicKey.urls,
+        },
+    }));
+    const crsV1 = {};
+    for (const [key, v2Data] of Object.entries(response.response.crs)) {
+        crsV1[key] = {
+            data_id: v2Data.dataId,
+            urls: v2Data.urls,
+        };
+    }
+    return {
+        response: {
+            fhe_key_info: fheKeyInfoV1,
+            crs: crsV1,
+        },
+    };
+}
+
+class RelayerV2Provider extends AbstractRelayerProvider {
+    constructor(relayerUrl) {
+        super(relayerUrl);
+    }
+    get version() {
+        return 2;
+    }
+    async fetchGetKeyUrlV2() {
+        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        // Relayer error
+        try {
+            assertIsRelayerV2GetResponseKeyUrl(response, 'fetchGetKeyUrl()');
+        }
+        catch (e) {
+            throw new RelayerV2GetKeyUrlInvalidResponseError({
+                cause: ensureError(e),
+            });
+        }
+        return response;
+    }
+    async fetchGetKeyUrl() {
+        const response = await this.fetchGetKeyUrlV2();
+        return toRelayerKeyUrlResponse(response);
+    }
+    async fetchPostInputProof(payload, instanceOptions, fetchOptions) {
+        const request = new RelayerV2AsyncRequest({
+            relayerOperation: 'INPUT_PROOF',
+            url: this.inputProof,
+            payload,
+            instanceOptions,
+            ...fetchOptions,
+        });
+        const result = (await request.run());
+        assertIsRelayerInputProofResult(result, 'fetchPostInputProof()');
+        return result;
+    }
+    async fetchPostPublicDecrypt(payload, instanceOptions, fetchOptions) {
+        const request = new RelayerV2AsyncRequest({
+            relayerOperation: 'PUBLIC_DECRYPT',
+            url: this.publicDecrypt,
+            payload,
+            instanceOptions,
+            ...fetchOptions,
+        });
+        const result = await request.run();
+        assertIsRelayerPublicDecryptResult(result, 'fetchPostPublicDecrypt()');
+        return result;
+    }
+    async fetchPostUserDecrypt(payload, instanceOptions, fetchOptions) {
+        const request = new RelayerV2AsyncRequest({
+            relayerOperation: 'USER_DECRYPT',
+            url: this.userDecrypt,
+            payload,
+            instanceOptions,
+            ...fetchOptions,
+        });
+        const result = (await request.run());
+        assertIsRelayerUserDecryptResult(result.result, 'fetchPostUserDecrypt()');
+        return result.result;
+    }
+}
+
+class AbstractRelayerFhevm {
+}
+
+class TFHECrs {
+    _id;
+    _compactPkeCrs;
+    _bits;
+    _srcUrl;
+    constructor(params) {
+        this._id = params.id;
+        this._compactPkeCrs = params.compactPkeCrs;
+        this._bits = params.bits;
+        this._srcUrl = params.srcUrl;
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        bits: number
+        srcUrl?: string
+      }
+    */
+    static isKeyBytesType(value) {
+        try {
+            TFHECrs.assertKeyBytesType(value, '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /*
+      {
+        id: string,
+        bits: number
+        srcUrl: string
+      }
+    */
+    static isKeyUrlType(value) {
+        try {
+            TFHECrs.assertKeyUrlType(value, '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        bits: number
+        srcUrl?: string
+      }
+    */
+    static assertKeyBytesType(value, name) {
+        assertRecordStringProperty(value, 'id', name);
+        assertUint8ArrayProperty(value, 'data', name);
+        assertRecordUintProperty(value, 'bits', name);
+        if (isNonNullableRecordProperty(value, 'srcUrl')) {
+            assertRecordStringProperty(value, 'srcUrl', name);
+        }
+    }
+    /*
+      {
+        id: string,
+        bits: number
+        srcUrl: string
+      }
+    */
+    static assertKeyUrlType(value, name) {
+        assertRecordStringProperty(value, 'id', name);
+        assertRecordUintProperty(value, 'bits', name);
+        assertRecordStringProperty(value, 'srcUrl', name);
+    }
+    /*
+      {
+        2048: {
+          publicParamsId: string,
+          publicParams: Uint8Array
+        }
+      }
+    */
+    static assertIsPublicParams2048BytesType(value, name) {
+        assertNonNullableRecordProperty(value, '2048', name);
+        assertRecordStringProperty(value['2048'], 'publicParamsId', `${name}.2048`);
+        assertUint8ArrayProperty(value['2048'], 'publicParams', `${name}.2048`);
+    }
+    /*
+      {
+        2048: {
+          publicParamsId: string,
+          publicParams: Uint8Array
+        }
+      }
+    */
+    static isPublicParams2048BytesType(value) {
+        try {
+            TFHECrs.assertIsPublicParams2048BytesType(value, '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async fromBytesOrUrl(params) {
+        if (TFHECrs.isKeyBytesType(params)) {
+            return TFHECrs._fromBytes(params);
+        }
+        else if (TFHECrs.isPublicParams2048BytesType(params)) {
+            return TFHECrs._fromPublicParamsBytes(params);
+        }
+        else if (TFHECrs.isKeyUrlType(params)) {
+            return TFHECrs._fromUrl(params);
+        }
+        else {
+            throw new Error('Invalid public key (deserialization failed)');
+        }
+    }
+    static fromBytes(params) {
+        try {
+            TFHECrs.assertKeyBytesType(params, 'arg');
+            return TFHECrs._fromBytes(params);
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    static _fromBytes(params) {
+        const _params = {
+            compactPkeCrs: TFHE.CompactPkeCrs.safe_deserialize(params.data, SERIALIZED_SIZE_LIMIT_CRS),
+            id: params.id,
+            bits: params.bits,
+            srcUrl: params.srcUrl,
+        };
+        return new TFHECrs(_params);
+    }
+    static fromPublicParamsBytes(params) {
+        try {
+            TFHECrs.assertIsPublicParams2048BytesType(params, 'arg');
+            return TFHECrs._fromPublicParamsBytes(params);
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    static _fromPublicParamsBytes(params) {
+        return TFHECrs._fromBytes({
+            bits: 2048,
+            data: params['2048'].publicParams,
+            id: params['2048'].publicParamsId,
+        });
+    }
+    static async fromUrl(params) {
+        try {
+            TFHECrs.assertKeyUrlType(params, 'arg');
+            return TFHECrs._fromUrl(params);
+        }
+        catch (e) {
+            throw new Error('Impossible to fetch public key: wrong relayer url.', {
+                cause: e,
+            });
+        }
+    }
+    static async _fromUrl(params) {
+        TFHECrs.assertKeyUrlType(params, 'arg');
+        const compactPkeCrsBytes = await fetchBytes(params.srcUrl);
+        return TFHECrs.fromBytes({
+            data: compactPkeCrsBytes,
+            id: params.id,
+            bits: params.bits,
+            srcUrl: params.srcUrl,
+        });
+    }
+    /*
+      {
+        id: string,
+        bits: number,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    toBytes() {
+        return {
+            data: this._compactPkeCrs.safe_serialize(SERIALIZED_SIZE_LIMIT_CRS),
+            id: this._id,
+            bits: this._bits,
+            ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
+        };
+    }
+    /*
+      {
+        2048: {
+          publicParamsId: string,
+          publicParams: TFHE.CompactPkeCrs
+        }
+      }
+    */
+    toPublicParamsWasm() {
+        if (this._bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${this._bits}`);
+        }
+        const pp = {
+            2048: {
+                publicParams: this._compactPkeCrs,
+                publicParamsId: this._id,
+            },
+        };
+        return pp;
+    }
+    /*
+      {
+        2048: {
+          publicParamsId: string,
+          publicParams: Uint8Array
+        }
+      }
+    */
+    toPublicParamsBytes() {
+        if (this._bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${this._bits}`);
+        }
+        const pp = {
+            2048: {
+                publicParams: this.toBytes().data,
+                publicParamsId: this._id,
+            },
+        };
+        return pp;
+    }
+}
+
+class TFHEPublicKey {
+    _id;
+    _tfheCompactPublicKey;
+    _srcUrl;
+    constructor(params) {
+        this._id = params.id;
+        this._tfheCompactPublicKey = params.tfheCompactPublicKey;
+        this._srcUrl = params.srcUrl;
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    static isKeyBytesType(value) {
+        try {
+            TFHEPublicKey.assertKeyBytesType(value, '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /*
+      {
+        id: string,
+        srcUrl: string
+      }
+    */
+    static isKeyUrlType(value) {
+        try {
+            TFHEPublicKey.assertKeyUrlType(value, '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    static assertKeyBytesType(value, name) {
+        assertRecordStringProperty(value, 'id', name);
+        assertUint8ArrayProperty(value, 'data', name);
+        if (isNonNullableRecordProperty(value, 'srcUrl')) {
+            assertRecordStringProperty(value, 'srcUrl', name);
+        }
+    }
+    /*
+      {
+        id: string,
+        srcUrl: string
+      }
+    */
+    static assertKeyUrlType(value, name) {
+        assertRecordStringProperty(value, 'id', name);
+        assertRecordStringProperty(value, 'srcUrl', name);
+    }
+    static async fromBytesOrUrl(params) {
+        if (TFHEPublicKey.isKeyBytesType(params)) {
+            return TFHEPublicKey._fromBytes(params);
+        }
+        else if (TFHEPublicKey.isKeyUrlType(params)) {
+            return TFHEPublicKey._fromUrl(params);
+        }
+        else {
+            throw new Error('Invalid public key (deserialization failed)');
+        }
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    static fromBytes(params) {
+        try {
+            TFHEPublicKey.assertKeyBytesType(params, 'arg');
+            return TFHEPublicKey._fromBytes(params);
+        }
+        catch (e) {
+            throw new Error('Invalid public key (deserialization failed)', {
+                cause: e,
+            });
+        }
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    static _fromBytes(params) {
+        const _params = {
+            tfheCompactPublicKey: TFHE.TfheCompactPublicKey.safe_deserialize(params.data, SERIALIZED_SIZE_LIMIT_PK),
+            id: params.id,
+            srcUrl: params.srcUrl,
+        };
+        return new TFHEPublicKey(_params);
+    }
+    /*
+      {
+        id: string,
+        srcUrl: string
+      }
+    */
+    static async fromUrl(params) {
+        try {
+            TFHEPublicKey.assertKeyUrlType(params, 'arg');
+            return TFHEPublicKey._fromUrl(params);
+        }
+        catch (e) {
+            throw new Error('Impossible to fetch public key: wrong relayer url.', {
+                cause: e,
+            });
+        }
+    }
+    /*
+      {
+        id: string,
+        srcUrl: string
+      }
+    */
+    static async _fromUrl(params) {
+        const tfheCompactPublicKeyBytes = await fetchBytes(params.srcUrl);
+        return TFHEPublicKey.fromBytes({
+            data: tfheCompactPublicKeyBytes,
+            id: params.id,
+            srcUrl: params.srcUrl,
+        });
+    }
+    /*
+      {
+        id: string,
+        data: Uint8Array,
+        srcUrl?: string
+      }
+    */
+    toBytes() {
+        return {
+            data: this._tfheCompactPublicKey.safe_serialize(SERIALIZED_SIZE_LIMIT_PK),
+            id: this._id,
+            ...(this._srcUrl ? { srcUrl: this._srcUrl } : {}),
+        };
+    }
+    /*
+      {
+        publicKey: TFHE.TfheCompactPublicKey
+        publicKeyId: string
+      }
+    */
+    toPublicKeyWasm() {
+        return {
+            publicKey: this._tfheCompactPublicKey,
+            publicKeyId: this._id,
+        };
+    }
+    /*
+      {
+        publicKey: Uint8Array
+        publicKeyId: string
+      }
+    */
+    toPublicKeyBytes() {
+        return {
+            publicKey: this.toBytes().data,
+            publicKeyId: this._id,
+        };
+    }
+}
+
+//const __KEY_URL_CACHE__: Record<string, RelayerV2PublicKey> = {};
+class RelayerV2PublicKey {
+    _crs2048;
+    _publicKey;
+    constructor(params) {
+        this._publicKey = params.publicKey;
+        this._crs2048 = params.crs2048;
+    }
+    static tryFromBytes(value) {
+        if (!isNonNullableRecordProperty(value, 'publicParams')) {
+            return null;
+        }
+        if (!TFHECrs.isPublicParams2048BytesType(value.publicParams)) {
+            return null;
+        }
+        if (!isNonNullableRecordProperty(value, 'publicKey')) {
+            return null;
+        }
+        if (!TFHEPublicKey.isKeyBytesType(value.publicKey)) {
+            return null;
+        }
+        const publicKey = value.publicKey;
+        const publicParams = value.publicParams;
+        return RelayerV2PublicKey.fromBytes({
+            publicKey,
+            publicParams,
+        });
+    }
+    static fromBytes(params) {
+        TFHECrs.assertIsPublicParams2048BytesType(params.publicParams, 'arg.publicParams');
+        const publicKey = TFHEPublicKey.fromBytes(params.publicKey);
+        const crs2048 = TFHECrs.fromBytes({
+            id: params.publicParams[2048].publicParamsId,
+            data: params.publicParams[2048].publicParams,
+            bits: 2048,
+        });
+        return new RelayerV2PublicKey({ publicKey, crs2048 });
+    }
+    static async fromRelayerResponse(response) {
+        try {
+            assertIsRelayerV2GetResponseKeyUrl(response, 'RelayerV2GetResponseKeyUrl');
+            const pub_key_0 = response.response.fheKeyInfo[0].fhePublicKey;
+            const tfheCompactPublicKeyId = pub_key_0.dataId;
+            const tfheCompactPublicKeyUrl = pub_key_0.urls[0];
+            const crs_2048 = response.response.crs['2048'];
+            const compactPkeCrs2048Id = crs_2048.dataId;
+            const compactPkeCrs2048Url = crs_2048.urls[0];
+            const publicKey = await TFHEPublicKey.fromUrl({
+                id: tfheCompactPublicKeyId,
+                srcUrl: tfheCompactPublicKeyUrl,
+            });
+            const crs = await TFHECrs.fromUrl({
+                id: compactPkeCrs2048Id,
+                bits: 2048,
+                srcUrl: compactPkeCrs2048Url,
+            });
+            return new RelayerV2PublicKey({ publicKey, crs2048: crs });
+        }
+        catch (e) {
+            throw new Error('Impossible to fetch public key: wrong relayer url.', {
+                cause: e,
+            });
+        }
+    }
+    getTFHEPublicKey() {
+        return this._publicKey;
+    }
+    getTFHECrs() {
+        return this._crs2048;
+    }
+    toBytes() {
+        return {
+            publicKey: this._publicKey.toBytes(),
+            publicParams: this._crs2048.toPublicParamsBytes(),
+        };
+    }
+}
+
+class RelayerV2Fhevm extends AbstractRelayerFhevm {
+    _relayerProvider;
+    _relayerPublicKey;
+    constructor(params) {
+        super();
+        this._relayerProvider = params.relayerProvider;
+        this._relayerPublicKey = params.relayerPublicKey;
+    }
+    get version() {
+        return 2;
+    }
+    get relayerVersionUrl() {
+        return this.relayerProvider.url;
+    }
+    static async fromConfig(config) {
+        const relayerProvider = new RelayerV2Provider(config.relayerVersionUrl);
+        let relayerPublicKey = RelayerV2PublicKey.tryFromBytes(config);
+        if (!relayerPublicKey) {
+            const response = await relayerProvider.fetchGetKeyUrlV2();
+            relayerPublicKey = await RelayerV2PublicKey.fromRelayerResponse(response);
+        }
+        return new RelayerV2Fhevm({
+            relayerProvider,
+            relayerPublicKey,
+        });
+    }
+    get relayerProvider() {
+        return this._relayerProvider;
+    }
+    getPublicKeyBytes() {
+        return this._relayerPublicKey.getTFHEPublicKey().toPublicKeyBytes();
+    }
+    getPublicKeyWasm() {
+        return this._relayerPublicKey.getTFHEPublicKey().toPublicKeyWasm();
+    }
+    getPublicParamsBytes(bits) {
+        if (bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+        }
+        return this._relayerPublicKey.getTFHECrs().toPublicParamsBytes()['2048'];
+    }
+    getPublicParamsWasm(bits) {
+        if (bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+        }
+        return this._relayerPublicKey.getTFHECrs().toPublicParamsWasm()['2048'];
+    }
+}
+
+class RelayerV1Fhevm extends AbstractRelayerFhevm {
+    _relayerProvider;
+    _publicKeyData;
+    _publicParamsData;
+    constructor(params) {
+        super();
+        this._relayerProvider = params.relayerProvider;
+        this._publicKeyData = params.publicKeyData;
+        this._publicParamsData = params.publicParamsData;
+    }
+    get version() {
+        return 1;
+    }
+    get relayerVersionUrl() {
+        return this.relayerProvider.url;
+    }
+    static async fromConfig(config) {
+        const relayerProvider = new RelayerV1Provider(config.relayerVersionUrl);
+        const publicKeyData = await getTfheCompactPublicKey(config);
+        const publicParamsData = await getPublicParams(config);
+        return new RelayerV1Fhevm({
+            relayerProvider,
+            publicKeyData,
+            publicParamsData,
+        });
+    }
+    get relayerProvider() {
+        return this._relayerProvider;
+    }
+    getPublicKeyBytes() {
+        return {
+            publicKey: this._publicKeyData.publicKey.safe_serialize(SERIALIZED_SIZE_LIMIT_PK),
+            publicKeyId: this._publicKeyData.publicKeyId,
+        };
+    }
+    getPublicKeyWasm() {
+        return {
+            publicKey: this._publicKeyData.publicKey,
+            publicKeyId: this._publicKeyData.publicKeyId,
+        };
+    }
+    getPublicParamsBytes(bits) {
+        if (bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+        }
+        return {
+            publicParams: this._publicParamsData['2048'].publicParams.safe_serialize(SERIALIZED_SIZE_LIMIT_CRS),
+            publicParamsId: this._publicParamsData['2048'].publicParamsId,
+        };
+    }
+    getPublicParamsWasm(bits) {
+        if (bits !== 2048) {
+            throw new Error(`Unsupported PublicParams bits format ${bits}`);
+        }
+        return {
+            publicParams: this._publicParamsData['2048'].publicParams,
+            publicParamsId: this._publicParamsData['2048'].publicParamsId,
+        };
+    }
+}
+
+async function createRelayerFhevm(config) {
+    const resolved = _resolveRelayerUrl(config.relayerUrl, config.defaultRelayerVersion);
+    if (!resolved) {
+        throw new Error(`Invalid relayerUrl: ${config.relayerUrl}`);
+    }
+    if (resolved.version === 2) {
+        return RelayerV2Fhevm.fromConfig({
+            relayerVersionUrl: resolved.url,
+            publicKey: config.publicKey,
+            publicParams: config.publicParams,
+        });
+    }
+    return RelayerV1Fhevm.fromConfig({
+        relayerVersionUrl: resolved.url,
+        publicKey: config.publicKey,
+        publicParams: config.publicParams,
+    });
+}
+function _resolveRelayerUrl(value, defaultVersion) {
+    if (!value || typeof value !== 'string') {
+        return null;
+    }
+    const urlNoSlash = removeSuffix(value, '/');
+    if (!URL.canParse(urlNoSlash)) {
+        return null;
+    }
+    if (urlNoSlash.endsWith('/v1')) {
+        return {
+            url: value,
+            version: 1,
+        };
+    }
+    if (urlNoSlash.endsWith('/v2')) {
+        return {
+            url: value,
+            version: 2,
+        };
+    }
+    if (typeof defaultVersion !== 'number') {
+        throw new Error(`relayerUrl cannot be resolved. (value=${value})`);
+    }
+    return {
+        url: `${urlNoSlash}/v${defaultVersion}`,
+        version: 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
+};
+
+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);
+const createInstance = async (config) => {
+    const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, inputVerifierContractAddress, kmsContractAddress, aclContractAddress, gatewayChainId, auth, } = config;
+    if (!isChecksummedAddress(aclContractAddress)) {
+        throw new Error('ACL contract address is not valid or empty');
+    }
+    if (!isChecksummedAddress(inputVerifierContractAddress)) {
+        throw new Error('InputVerifier contract address is not valid or empty');
+    }
+    if (!isChecksummedAddress(kmsContractAddress)) {
+        throw new Error('KMS contract address is not valid or empty');
+    }
+    if (!isChecksummedAddress(verifyingContractAddressDecryption)) {
+        throw new Error('Verifying contract for Decryption address is not valid or empty');
+    }
+    if (!isChecksummedAddress(verifyingContractAddressInputVerification)) {
+        throw new Error('Verifying contract for InputVerification address is not valid or empty');
+    }
+    if (publicKey && !(publicKey.data instanceof Uint8Array)) {
+        throw new Error('publicKey must be a Uint8Array');
+    }
+    // TODO change argument
+    // provider is never undefined | null here!
+    const provider = getProvider(config.network);
+    const relayerUrl = config.relayerUrl ?? SepoliaConfig.relayerUrl;
+    const relayerFhevm = await createRelayerFhevm({
+        relayerUrl,
+        publicKey: config.publicKey,
+        publicParams: config.publicParams,
+        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),
+        generateKeypair,
+        createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
+        publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, 
+        //cleanURL(config.relayerUrl),
+        relayerFhevm.relayerProvider, provider, auth && { auth }),
+        userDecrypt: userDecryptRequest(kmsSigners, gatewayChainId, chainId, verifyingContractAddressDecryption, aclContractAddress, 
+        //cleanURL(config.relayerUrl),
+        relayerFhevm.relayerProvider, provider, auth && { auth }),
+        getPublicKey: () => relayerFhevm.getPublicKeyBytes(),
+        getPublicParams: (bits) => relayerFhevm.getPublicParamsBytes(bits),
+        // getPublicKey: () =>
+        //   publicKeyData.publicKey
+        //     ? {
+        //         publicKey: publicKeyData.publicKey.safe_serialize(
+        //           SERIALIZED_SIZE_LIMIT_PK,
+        //         ),
+        //         publicKeyId: publicKeyData.publicKeyId,
+        //       }
+        //     : null,
+        // getPublicParams: (bits: keyof PublicParams) => {
+        //   if (publicParamsData[bits]) {
+        //     return {
+        //       publicParams: publicParamsData[bits]!.publicParams.safe_serialize(
+        //         SERIALIZED_SIZE_LIMIT_CRS,
+        //       ),
+        //       publicParamsId: publicParamsData[bits]!.publicParamsId,
+        //     };
+        //   }
+        //   return null;
+        // },
     };
 };