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

package/lib/node.cjs

@@ -28,31 +28,9 @@ const SERIALIZED_SIZE_LIMIT_CIPHERTEXT = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_PK = BigInt(1024 * 1024 * 512);
 const SERIALIZED_SIZE_LIMIT_CRS = BigInt(1024 * 1024 * 512);
 
-function setAuth(init, auth) {
-    if (auth) {
-        switch (auth.__type) {
-            case 'BearerToken':
-                init.headers['Authorization'] =
-                    `Bearer ${auth.token}`;
-                break;
-            case 'ApiKeyHeader':
-                init.headers[auth.header || 'x-api-key'] =
-                    auth.value;
-                break;
-            case 'ApiKeyCookie':
-                if (typeof window !== 'undefined') {
-                    document.cookie = `${auth.cookie || 'x-api-key'}=${auth.value}; path=/; SameSite=Lax; Secure; HttpOnly;`;
-                    init.credentials = 'include';
-                }
-                else {
-                    let cookie = `${auth.cookie || 'x-api-key'}=${auth.value};`;
-                    init.headers['Cookie'] = cookie;
-                }
-                break;
-        }
-    }
-    return init;
-}
+// This file is auto-generated
+const version = '0.4.0-alpha.1';
+const sdkName = '@zama-fhe/relayer-sdk';
 
 function getErrorCause(e) {
     if (e instanceof Error && typeof e.cause === 'object' && e.cause !== null) {
@@ -234,7 +212,39 @@ function throwRelayerUnknownError(operation, error, message) {
     });
 }
 
-////////////////////////////////////////////////////////////////////////////////
+/**
+ * Set the authentication method for the request. The default is no authentication.
+ * It supports:
+ * - Bearer Token
+ * - Custom header
+ * - Custom cookie
+ */
+function setAuth(init, auth) {
+    if (auth) {
+        switch (auth.__type) {
+            case 'BearerToken':
+                init.headers['Authorization'] =
+                    `Bearer ${auth.token}`;
+                break;
+            case 'ApiKeyHeader':
+                init.headers[auth.header || 'x-api-key'] =
+                    auth.value;
+                break;
+            case 'ApiKeyCookie':
+                if (typeof window !== 'undefined') {
+                    document.cookie = `${auth.cookie || 'x-api-key'}=${auth.value}; path=/; SameSite=Lax; Secure; HttpOnly;`;
+                    init.credentials = 'include';
+                }
+                else {
+                    let cookie = `${auth.cookie || 'x-api-key'}=${auth.value};`;
+                    init.headers['Cookie'] = cookie;
+                }
+                break;
+        }
+    }
+    return init;
+}
+
 function assertIsRelayerV1FetchResponseJson(json) {
     if (!json || typeof json !== 'object') {
         throw new Error('Unexpected response JSON.');
@@ -245,11 +255,13 @@ function assertIsRelayerV1FetchResponseJson(json) {
         throw new Error("Unexpected response JSON format: missing 'response' property.");
     }
 }
-async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options) {
+async function fetchRelayerV1Post(relayerOperation, url, payload, options) {
     const init = setAuth({
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
+            'ZAMA-SDK-VERSION': `${version}`,
+            'ZAMA-SDK-NAME': `${sdkName}`,
         },
         body: JSON.stringify(payload),
     }, options?.auth);
@@ -280,14 +292,20 @@ async function fetchRelayerJsonRpcPost(relayerOperation, url, payload, options)
     }
     return json;
 }
-async function fetchRelayerGet(relayerOperation, url) {
+async function fetchRelayerV1Get(relayerOperation, url) {
+    const init = {
+        method: 'GET',
+        headers: {
+            'ZAMA-SDK-VERSION': `${version}`,
+            'ZAMA-SDK-NAME': `${sdkName}`,
+        },
+    };
     let response;
     let json;
     try {
-        response = await fetch(url);
+        response = await fetch(url, init);
     }
     catch (e) {
-        console.log(e);
         throwRelayerUnknownError(relayerOperation, e);
     }
     if (!response.ok) {
@@ -315,7 +333,7 @@ const getKeysFromRelayer = async (versionUrl, publicKeyId) => {
     if (keyurlCache[versionUrl]) {
         return keyurlCache[versionUrl];
     }
-    const data = await fetchRelayerGet('KEY_URL', `${versionUrl}/keyurl`);
+    const data = await fetchRelayerV1Get('KEY_URL', `${versionUrl}/keyurl`);
     try {
         let pubKeyUrl;
         // If no publicKeyId is provided, use the first one
@@ -404,7 +422,7 @@ class RelayerErrorBase extends Error {
     _docsPath;
     _docsUrl;
     _version;
-    static VERSION = '0.3.0-6';
+    static VERSION = version;
     static DEFAULT_DOCS_BASE_URL = 'https//docs.zama.org';
     static FULL_VERSION = `@zama-fhe/relayer-sdk@${RelayerErrorBase.VERSION}`;
     constructor(params) {
@@ -813,6 +831,14 @@ function assertRecordStringArrayProperty(o, property, objName) {
         }
     }
 }
+function safeJSONstringify(o) {
+    try {
+        return JSON.stringify(o, (_, v) => typeof v === 'bigint' ? v.toString() : v);
+    }
+    catch {
+        return '';
+    }
+}
 
 const abiKmsVerifier = [
     'function getKmsSigners() view returns (address[])',
@@ -912,6 +938,7 @@ const getCoprocessorSignersThreshold = async (provider, inputVerifierContractAdd
     return Number(threshold); // threshold is always supposed to fit in a number
 };
 
+// This file contains common utilities for both user and public decryption requests
 const NumEncryptedBits = {
     0: 2, // ebool
     2: 8, // euint8
@@ -922,17 +949,6 @@ const NumEncryptedBits = {
     7: 160, // eaddress
     8: 256, // euint256
 };
-function getHandleType(handle) {
-    if (handle.length !== 66) {
-        throw new Error(`Handle ${handle} is not of valid length`);
-    }
-    const hexPair = handle.slice(-4, -2).toLowerCase();
-    const typeDiscriminant = parseInt(hexPair, 16);
-    if (!(typeDiscriminant in NumEncryptedBits)) {
-        throw new Error(`Handle ${handle} is not of valid type`);
-    }
-    return typeDiscriminant;
-}
 function checkEncryptedBits(handles) {
     let total = 0;
     for (const handle of handles) {
@@ -1342,9 +1358,7 @@ function checkDeadlineValidity(startTimestamp, durationDays) {
         throw Error('User decrypt request has expired');
     }
 }
-const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, 
-//relayerUrl: string,
-relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays, options) => {
+const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContractAddress, aclContractAddress, relayerProvider, provider, defaultOptions) => async (_handles, privateKey, publicKey, signature, contractAddresses, userAddress, startTimestamp, durationDays, options) => {
     const extraData = '0x00';
     let pubKey;
     let privKey;
@@ -1358,16 +1372,16 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
     // Casting handles if string
     const signatureSanitized = signature.replace(/^(0x)/, '');
     const publicKeySanitized = publicKey.replace(/^(0x)/, '');
-    const handles = _handles.map((h) => ({
+    const handleContractPairs = _handles.map((h) => ({
         handle: typeof h.handle === 'string'
             ? toHexString(hexToBytes(h.handle), true)
             : toHexString(h.handle, true),
         contractAddress: getAddress$1(h.contractAddress),
     }));
-    checkEncryptedBits(handles.map((h) => h.handle));
+    checkEncryptedBits(handleContractPairs.map((h) => h.handle));
     checkDeadlineValidity(BigInt(startTimestamp), BigInt(durationDays));
-    const acl = new ethers.ethers.Contract(aclContractAddress, aclABI$1, provider);
-    const verifications = handles.map(async ({ handle, contractAddress }) => {
+    const acl = new ethers.Contract(aclContractAddress, aclABI$1, provider);
+    const verifications = handleContractPairs.map(async ({ handle, contractAddress }) => {
         const userAllowed = await acl.persistAllowed(handle, userAddress);
         const contractAllowed = await acl.persistAllowed(handle, contractAddress);
         if (!userAllowed) {
@@ -1391,7 +1405,7 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
         throw e;
     });
     const payloadForRequest = {
-        handleContractPairs: handles,
+        handleContractPairs,
         requestValidity: {
             startTimestamp: startTimestamp.toString(), // Convert to string
             durationDays: durationDays.toString(), // Convert to string
@@ -1403,13 +1417,10 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
         publicKey: publicKeySanitized,
         extraData,
     };
-    const json = await relayerProvider.fetchPostUserDecrypt(payloadForRequest, options ?? instanceOptions);
-    // const json = await fetchRelayerJsonRpcPost(
-    //   'USER_DECRYPT',
-    //   `${relayerUrl}/v1/user-decrypt`,
-    //   payloadForRequest,
-    //   instanceOptions ?? options,
-    // );
+    const json = await relayerProvider.fetchPostUserDecrypt(payloadForRequest, {
+        ...defaultOptions,
+        ...options,
+    });
     // assume the KMS Signers have the correct order
     let indexedKmsSigners = kmsSigners.map((signer, index) => {
         return TKMS.new_server_id_addr(index + 1, signer);
@@ -1431,13 +1442,13 @@ relayerProvider, provider, instanceOptions) => async (_handles, privateKey, publ
             signature: signatureSanitized,
             client_address: userAddress,
             enc_key: publicKeySanitized,
-            ciphertext_handles: handles.map((h) => h.handle.replace(/^0x/, '')),
+            ciphertext_handles: handleContractPairs.map((h) => h.handle.replace(/^0x/, '')),
             eip712_verifying_contract: verifyingContractAddress,
         };
         const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json, //json.response,
         pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
-        const results = buildUserDecryptResults(handles.map((h) => h.handle), listBigIntDecryptions);
+        const results = buildUserDecryptResults(handleContractPairs.map((h) => h.handle), listBigIntDecryptions);
         return results;
     }
     catch (e) {
@@ -1729,6 +1740,15 @@ function checksummedAddressToBytes20(address) {
     return bytes;
 }
 
+class FhevmHandleError extends RelayerErrorBase {
+    constructor({ handle, message }) {
+        super({
+            message: message ?? `FHEVM Handle "${handle}" is invalid.`,
+            name: 'FhevmHandleError',
+        });
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // FhevmHandle
 ////////////////////////////////////////////////////////////////////////////////
@@ -1761,6 +1781,16 @@ class FhevmHandle {
         160: 7,
         256: 8,
     };
+    static FheTypeIdToSolidityPrimitiveType = {
+        0: 'bool',
+        2: 'uint256',
+        3: 'uint256',
+        4: 'uint256',
+        5: 'uint256',
+        6: 'uint256',
+        7: 'address',
+        8: 'uint256',
+    };
     static {
         Object.freeze(FhevmHandle.FheTypeIdToEncryptionBitwidths);
         Object.freeze(FhevmHandle.FheTypeEncryptionBitwidthsToId);
@@ -1895,6 +1925,41 @@ class FhevmHandle {
     toBytes32Hex() {
         return bytesToHex(this.toBytes32());
     }
+    static checkHandleHex(handle) {
+        if (!isBytes32Hex(handle)) {
+            throw new FhevmHandleError({ handle });
+        }
+    }
+    static isFheTypeId(value) {
+        switch (value) {
+            case 0:
+            // 1: euint4 is deprecated
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                return true;
+            default:
+                return false;
+        }
+    }
+    static getFheTypeId(handle) {
+        if (!isBytes32Hex(handle)) {
+            throw new FhevmHandleError({ handle });
+        }
+        const hexPair = handle.slice(-4, -2).toLowerCase();
+        const typeDiscriminant = parseInt(hexPair, 16);
+        if (!FhevmHandle.isFheTypeId(typeDiscriminant)) {
+            throw new FhevmHandleError({
+                handle,
+                message: `FHEVM Handle "${handle}" is invalid. Unknown FheType: ${typeDiscriminant}`,
+            });
+        }
+        return typeDiscriminant;
+    }
 }
 
 // Add type checking
@@ -1933,9 +1998,7 @@ function isFhevmRelayerInputProofResponse(json) {
     return (response.signatures.every((s) => typeof s === 'string') &&
         response.handles.every((h) => typeof h === 'string'));
 }
-const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, 
-//relayerUrl: string,
-relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, instanceOptions) => (contractAddress, userAddress) => {
+const createRelayerEncryptedInput = (aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresholdCoprocessorSigners, defaultOptions) => (contractAddress, userAddress) => {
     if (!ethers.isAddress(contractAddress)) {
         throw new Error('Contract address is not a valid address.');
     }
@@ -1987,11 +2050,13 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
         getBits() {
             return input.getBits();
         },
+        getCiphertextWithInputVerification() {
+            return input.encrypt();
+        },
         encrypt: async (options) => {
             const extraData = '0x00';
             const bits = input.getBits();
             const ciphertext = input.encrypt();
-            //console.log(`ciphertext=${toHexString(ciphertext)}`);
             const payload = {
                 contractAddress: getAddress(contractAddress),
                 userAddress: getAddress(userAddress),
@@ -1999,13 +2064,10 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
                 contractChainId: ('0x' + chainId.toString(16)),
                 extraData,
             };
-            const json = await relayerProvider.fetchPostInputProof(payload, options ?? instanceOptions);
-            // const json = await fetchRelayerJsonRpcPost(
-            //   'INPUT_PROOF',
-            //   `${relayerUrl}/v1/input-proof`,
-            //   payload,
-            //   options ?? instanceOptions,
-            // );
+            const json = await relayerProvider.fetchPostInputProof(payload, {
+                ...defaultOptions,
+                ...options,
+            });
             if (!isFhevmRelayerInputProofResponse(json)) {
                 throwRelayerInternalError('INPUT_PROOF', json);
             }
@@ -2017,7 +2079,6 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
                 fheTypeEncryptionBitwidths: bits,
             });
             const handles = fhevmHandles.map((h) => h.toBytes32());
-            //const result = json.response;
             const result = json;
             // Note that the hex strings returned by the relayer do have have the 0x prefix
             if (result.handles && result.handles.length > 0) {
@@ -2084,6 +2145,21 @@ relayerProvider, tfheCompactPublicKey, publicParams, coprocessorSigners, thresho
     };
 };
 
+function ensureError(e) {
+    if (e instanceof Error) {
+        return e;
+    }
+    const message = e.message ?? 'Non-Error value caught in exception handler';
+    const name = e.name ?? 'ErrorWrapper';
+    const cause = e.cause ?? e;
+    const err = new Error(message, { cause });
+    err.name = name;
+    return err;
+}
+function assertNever(value, message) {
+    throw new InternalError({ message });
+}
+
 const aclABI = [
     'function isAllowedForDecryption(bytes32 handle) view returns (bool)',
 ];
@@ -2109,7 +2185,7 @@ function abiEncodeClearValues(clearValues) {
     const abiValues = [];
     for (let i = 0; i < handlesBytes32Hex.length; ++i) {
         const handle = handlesBytes32Hex[i];
-        const handleType = getHandleType(handle);
+        const handleType = FhevmHandle.getFheTypeId(handle);
         let clearTextValue = clearValues[handle];
         if (typeof clearTextValue === 'boolean') {
             clearTextValue = clearTextValue ? '0x01' : '0x00';
@@ -2146,7 +2222,7 @@ function abiEncodeClearValues(clearValues) {
                 break;
             }
             default: {
-                throw new Error(`Unsupported Fhevm primitive type id: ${handleType}`);
+                assertNever(handleType, `Unsupported Fhevm primitive type id: ${handleType}`);
             }
         }
     }
@@ -2171,21 +2247,11 @@ function buildDecryptionProof(kmsSignatures, extraData) {
     ]);
     return decryptionProof;
 }
-const CiphertextType = {
-    0: 'bool',
-    2: 'uint256',
-    3: 'uint256',
-    4: 'uint256',
-    5: 'uint256',
-    6: 'uint256',
-    7: 'address',
-    8: 'uint256',
-};
 function deserializeClearValues(handles, decryptedResult) {
     let typesList = [];
     for (const handle of handles) {
-        const hexPair = handle.slice(-4, -2).toLowerCase();
-        const typeDiscriminant = parseInt(hexPair, 16);
+        const typeDiscriminant = FhevmHandle.getFheTypeId(handle);
+        assertRelayer(FhevmHandle.isFheTypeId(typeDiscriminant));
         typesList.push(typeDiscriminant);
     }
     const restoredEncoded = '0x' +
@@ -2193,7 +2259,7 @@ function deserializeClearValues(handles, decryptedResult) {
         decryptedResult.slice(2) +
         '00'.repeat(32); // dummy empty bytes[] length (ignored)
     const abiTypes = typesList.map((t) => {
-        const abiType = CiphertextType[t]; // all types are valid because this was supposedly checked already inside the `checkEncryptedBits` function
+        const abiType = FhevmHandle.FheTypeIdToSolidityPrimitiveType[t]; // all types are valid because this was supposedly checked already inside the `checkEncryptedBits` function
         return abiType;
     });
     const coder = new ethers.AbiCoder();
@@ -2204,9 +2270,7 @@ function deserializeClearValues(handles, decryptedResult) {
     handles.forEach((handle, idx) => (results[handle] = rawValues[idx]));
     return results;
 }
-const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, 
-//relayerUrl: string,
-relayerProvider, provider, instanceOptions) => async (_handles, options) => {
+const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, verifyingContractAddress, aclContractAddress, relayerProvider, provider, defaultOptions) => async (_handles, options) => {
     const extraData = '0x00';
     const acl = new ethers.ethers.Contract(aclContractAddress, aclABI, provider);
     let handles;
@@ -2231,13 +2295,10 @@ relayerProvider, provider, instanceOptions) => async (_handles, options) => {
         ciphertextHandles: handles,
         extraData,
     };
-    const json = await relayerProvider.fetchPostPublicDecrypt(payloadForRequest, options ?? instanceOptions);
-    // const json = await fetchRelayerJsonRpcPost(
-    //   'PUBLIC_DECRYPT',
-    //   `${relayerUrl}/v1/public-decrypt`,
-    //   payloadForRequest,
-    //   options ?? instanceOptions,
-    // );
+    const json = await relayerProvider.fetchPostPublicDecrypt(payloadForRequest, {
+        ...defaultOptions,
+        ...options,
+    });
     // verify signatures on decryption:
     const domain = {
         name: 'Decryption',
@@ -2433,7 +2494,7 @@ class RelayerV1Provider extends AbstractRelayerProvider {
         return 1;
     }
     async fetchGetKeyUrl() {
-        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        const response = await fetchRelayerV1Get('KEY_URL', this.keyUrl);
         return response;
     }
     async fetchPostInputProof(payload, options) {
@@ -2451,12 +2512,12 @@ class RelayerV1Provider extends AbstractRelayerProvider {
           }
         }
         */
-        const json = await fetchRelayerJsonRpcPost('INPUT_PROOF', this.inputProof, payload, options);
+        const json = await fetchRelayerV1Post('INPUT_PROOF', this.inputProof, payload, options);
         assertIsRelayerInputProofResult(json.response, 'fetchPostInputProof()');
         return json.response;
     }
     async fetchPostPublicDecrypt(payload, options) {
-        const json = await fetchRelayerJsonRpcPost('PUBLIC_DECRYPT', this.publicDecrypt, payload, options);
+        const json = await fetchRelayerV1Post('PUBLIC_DECRYPT', this.publicDecrypt, payload, options);
         const response = json.response[0];
         const result = {
             signatures: response.signatures,
@@ -2467,24 +2528,12 @@ class RelayerV1Provider extends AbstractRelayerProvider {
         return result;
     }
     async fetchPostUserDecrypt(payload, options) {
-        const json = await fetchRelayerJsonRpcPost('USER_DECRYPT', this.userDecrypt, payload, options);
+        const json = await fetchRelayerV1Post('USER_DECRYPT', this.userDecrypt, payload, options);
         assertIsRelayerUserDecryptResult(json.response, 'RelayerUserDecryptResult()');
         return json.response;
     }
 }
 
-function ensureError(e) {
-    if (e instanceof Error) {
-        return e;
-    }
-    const message = e.message ?? 'Non-Error value caught in exception handler';
-    const name = e.name ?? 'ErrorWrapper';
-    const cause = e.cause ?? e;
-    const err = new Error(message, { cause });
-    err.name = name;
-    return err;
-}
-
 class RelayerV2ProviderError extends RelayerErrorBase {
     _operation;
     constructor(params) {
@@ -2961,22 +3010,6 @@ class RelayerV2RequestInternalError extends RelayerV2RequestErrorBase {
     }
 }
 
-function assertIsRelayerV2ResultQueued(value, name) {
-    assertRecordStringProperty(value, 'jobId', name);
-}
-
-/*
-  type RelayerV2ResponseQueued = {
-    status: "queued";
-    result: RelayerV2ResultQueued;
-  }
-*/
-function assertIsRelayerV2ResponseQueued(value, name) {
-    assertRecordStringProperty(value, 'status', name, 'queued');
-    assertNonNullableRecordProperty(value, 'result', name);
-    assertIsRelayerV2ResultQueued(value.result, `${name}.result`);
-}
-
 class RelayerV2ResponseApiError extends RelayerV2ResponseErrorBase {
     constructor(params) {
         super({
@@ -3038,6 +3071,36 @@ class RelayerV2MaxRetryError extends RelayerV2FetchErrorBase {
     }
 }
 
+function assertIsRelayerV2PostResultQueued(value, name) {
+    assertRecordStringProperty(value, 'jobId', name);
+}
+
+/*
+  {
+    status: 'queued';
+    requestId: string;
+    result: {
+      jobId: string;
+    };
+  }
+*/
+function assertIsRelayerV2PostResponseQueued(value, name) {
+    assertRecordStringProperty(value, 'status', name, 'queued');
+    assertRecordStringProperty(value, 'requestId', name);
+    assertNonNullableRecordProperty(value, 'result', name);
+    assertIsRelayerV2PostResultQueued(value.result, `${name}.result`);
+}
+/*
+  {
+    status: 'queued';
+    requestId: string;
+  }
+*/
+function assertIsRelayerV2GetResponseQueued(value, name) {
+    assertRecordStringProperty(value, 'status', name, 'queued');
+    assertRecordStringProperty(value, 'requestId', name);
+}
+
 class RelayerV2AsyncRequest {
     _jobId;
     _jobIdTimestamp;
@@ -3282,14 +3345,15 @@ class RelayerV2AsyncRequest {
                     //    - SyntaxError: Expected property name or '}' in JSON at position 1 (line 1 column 2) at JSON.parse (<anonymous>)
                     const bodyJson = await this._getResponseJson(response);
                     try {
-                        assertIsRelayerV2ResponseQueued(bodyJson, 'body');
+                        assertIsRelayerV2PostResponseQueued(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
@@ -3324,11 +3388,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError400(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3348,11 +3413,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError429(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
@@ -3383,11 +3449,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError500(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3407,11 +3474,12 @@ class RelayerV2AsyncRequest {
                         assertIsRelayerV2ResponseFailedWithError503(bodyJson, 'body');
                     }
                     catch (cause) {
-                        this._throwInvalidResponseError({
+                        this._throwResponseInvalidBodyError({
                             fetchMethod: 'POST',
                             status: responseStatus,
                             cause: cause,
                             elapsed,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3535,6 +3603,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     // RelayerV2ResultPublicDecrypt
@@ -3546,7 +3615,7 @@ class RelayerV2AsyncRequest {
                 case 202: {
                     const bodyJson = await this._getResponseJson(response);
                     try {
-                        assertIsRelayerV2ResponseQueued(bodyJson, 'body');
+                        assertIsRelayerV2GetResponseQueued(bodyJson, 'body');
                     }
                     catch (cause) {
                         this._throwResponseInvalidBodyError({
@@ -3554,6 +3623,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     let retry_after_sec = this._getRetryAfterHeaderValueInSecs(response);
@@ -3589,6 +3659,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3611,6 +3682,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3635,6 +3707,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3659,6 +3732,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3683,6 +3757,7 @@ class RelayerV2AsyncRequest {
                             status: responseStatus,
                             elapsed,
                             cause: cause,
+                            bodyJson: safeJSONstringify(bodyJson),
                         });
                     }
                     this._throwRelayerV2ResponseApiError({
@@ -3783,6 +3858,8 @@ class RelayerV2AsyncRequest {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
+                'ZAMA-SDK-VERSION': `${version}`,
+                'ZAMA-SDK-NAME': `${sdkName}`,
             },
             body: JSON.stringify(this._payload),
             ...(this._internalAbortSignal
@@ -3832,9 +3909,16 @@ class RelayerV2AsyncRequest {
         this._assert(!this._state.terminated, '!this._state.terminated');
         this._assert(!this._state.fetching, '!this._state.fetching');
         this._trace('_fetchGet', `jobId=${this.jobId}`);
-        const init = this._internalAbortSignal
-            ? { signal: this._internalAbortSignal }
-            : undefined;
+        const init = {
+            method: 'GET',
+            headers: {
+                'ZAMA-SDK-VERSION': `${version}`,
+                'ZAMA-SDK-NAME': `${sdkName}`,
+            },
+            ...(this._internalAbortSignal
+                ? { signal: this._internalAbortSignal }
+                : {}),
+        };
         this._state.fetching = true;
         let response;
         try {
@@ -4087,20 +4171,11 @@ class RelayerV2AsyncRequest {
             elapsed,
         });
     }
-    _throwInvalidResponseError(params) {
-        throw new RelayerV2ResponseInvalidBodyError({
-            ...params,
-            url: this._url,
-            operation: this._relayerOperation,
-            state: { ...this._state },
-            retryCount: this._retryCount,
-        });
-    }
     _throwResponseInvalidBodyError(params) {
         throw new RelayerV2ResponseInvalidBodyError({
             ...params,
             url: this._url,
-            jobId: this.jobId,
+            jobId: this._jobId,
             operation: this._relayerOperation,
             state: { ...this._state },
             retryCount: this._retryCount,
@@ -4171,7 +4246,7 @@ function assertIsRelayerV2KeyData(value, name) {
     assertRecordStringProperty(value, 'dataId', name);
     assertRecordStringArrayProperty(value, 'urls', name);
 }
-function toRelayerKeyUrlResponse(response) {
+function toRelayerV1KeyUrlResponse(response) {
     const fheKeyInfoV1 = response.response.fheKeyInfo.map((v2Info) => ({
         fhe_public_key: {
             data_id: v2Info.fhePublicKey.dataId,
@@ -4201,7 +4276,7 @@ class RelayerV2Provider extends AbstractRelayerProvider {
         return 2;
     }
     async fetchGetKeyUrlV2() {
-        const response = await fetchRelayerGet('KEY_URL', this.keyUrl);
+        const response = await fetchRelayerV1Get('KEY_URL', this.keyUrl);
         // Relayer error
         try {
             assertIsRelayerV2GetResponseKeyUrl(response, 'fetchGetKeyUrl()');
@@ -4215,7 +4290,7 @@ class RelayerV2Provider extends AbstractRelayerProvider {
     }
     async fetchGetKeyUrl() {
         const response = await this.fetchGetKeyUrlV2();
-        return toRelayerKeyUrlResponse(response);
+        return toRelayerV1KeyUrlResponse(response);
     }
     async fetchPostInputProof(payload, instanceOptions, fetchOptions) {
         const request = new RelayerV2AsyncRequest({
@@ -4905,60 +4980,39 @@ function _resolveRelayerUrl(value, defaultVersion) {
     };
 }
 
-/**
- * **FHE Type Mapping for Input Builders**
- * * Maps the **number of encrypted bits** used by a FHEVM primary type
- * to its corresponding **FheTypeId**. This constant is primarily used by
- * `EncryptedInput` and `RelayerEncryptedInput` builders to determine the correct
- * input type and calculate the total required bit-length.
- *
- * **Structure: \{ Encrypted Bit Length: FheTypeId \}**
- *
- * | Bits | FheTypeId | FHE Type Name | Note |
- * | :--- | :-------- | :------------ | :--- |
- * | 2    | 0         | `ebool`         | The boolean type. |
- * | (N/A)| 1         | `euint4`        | **Deprecated** and omitted from this map. |
- * | 8    | 2         | `euint8`        | |
- * | 16   | 3         | `euint16`       | |
- * | 32   | 4         | `euint32`       | |
- * | 64   | 5         | `euint64`       | |
- * | 128  | 6         | `euint128`      | |
- * | 160  | 7         | `eaddress`      | Used for encrypted Ethereum addresses. |
- * | 256  | 8         | `euint256`      | The maximum supported integer size. |
- */
-const ENCRYPTION_TYPES = {
-    2: 0, // ebool (FheTypeId=0) is using 2 encrypted bits
-    // euint4 (FheTypeId=1) is deprecated
-    8: 2, // euint8 (FheTypeId=2) is using 8 encrypted bits
-    16: 3, // euint16 (FheTypeId=3) is using 16 encrypted bits
-    32: 4, // euint32 (FheTypeId=4) is using 32 encrypted bits
-    64: 5, // euint64 (FheTypeId=5) is using 64 encrypted bits
-    128: 6, // euint128 (FheTypeId=128) is using 128 encrypted bits
-    160: 7, // eaddress (FheTypeId=7) is using 160 encrypted bits
-    256: 8, // euint256 (FheTypeId=8) is using 256 encrypted bits
+////////////////////////////////////////////////////////////////////////////////
+// MainnetConfig
+////////////////////////////////////////////////////////////////////////////////
+const MainnetConfig = {
+    aclContractAddress: '0xcA2E8f1F656CD25C01F05d0b243Ab1ecd4a8ffb6',
+    kmsContractAddress: '0x77627828a55156b04Ac0DC0eb30467f1a552BB03',
+    inputVerifierContractAddress: '0xCe0FC2e05CFff1B719EFF7169f7D80Af770c8EA2',
+    verifyingContractAddressDecryption: '0x0f6024a97684f7d90ddb0fAAD79cB15F2C888D24',
+    verifyingContractAddressInputVerification: '0xcB1bB072f38bdAF0F328CdEf1Fc6eDa1DF029287',
+    chainId: 1,
+    gatewayChainId: 261131,
+    network: 'https://ethereum-rpc.publicnode.com',
+    relayerUrl: 'https://relayer.mainnet.zama.org',
 };
-
+Object.freeze(MainnetConfig);
+////////////////////////////////////////////////////////////////////////////////
+// SepoliaConfig
+////////////////////////////////////////////////////////////////////////////////
 const SepoliaConfig = {
-    // ACL_CONTRACT_ADDRESS (FHEVM Host chain)
     aclContractAddress: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D',
-    // KMS_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
     kmsContractAddress: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A',
-    // INPUT_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
     inputVerifierContractAddress: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0',
-    // DECRYPTION_ADDRESS (Gateway chain)
     verifyingContractAddressDecryption: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478',
-    // INPUT_VERIFICATION_ADDRESS (Gateway chain)
     verifyingContractAddressInputVerification: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955',
-    // FHEVM Host chain id
     chainId: 11155111,
-    // Gateway chain id
     gatewayChainId: 10901,
-    // Optional RPC provider to host chain
     network: 'https://ethereum-sepolia-rpc.publicnode.com',
-    // Relayer URL
     relayerUrl: 'https://relayer.testnet.zama.org',
 };
 Object.freeze(SepoliaConfig);
+////////////////////////////////////////////////////////////////////////////////
+// createInstance
+////////////////////////////////////////////////////////////////////////////////
 const createInstance = async (config) => {
     const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, inputVerifierContractAddress, kmsContractAddress, aclContractAddress, gatewayChainId, auth, } = config;
     if (!isChecksummedAddress(aclContractAddress)) {
@@ -4990,29 +5044,12 @@ const createInstance = async (config) => {
         defaultRelayerVersion: 1,
     });
     const chainId = await getChainId(provider, config);
-    // const relayerVersionUrl = `${config.relayerUrl!}/v1`;
-    // const publicKeyData = await getTfheCompactPublicKey({
-    //   relayerVersionUrl: relayerFhevm.relayerVersionUrl,
-    //   publicKey: config.publicKey,
-    // });
-    //const aaa = relayerFhevm.getPublicKey();
-    // const publicParamsData = await getPublicParams({
-    //   relayerVersionUrl,
-    //   publicParams: config.publicParams,
-    // });
     const kmsSigners = await getKMSSigners(provider, kmsContractAddress);
     const thresholdKMSSigners = await getKMSSignersThreshold(provider, kmsContractAddress);
     const coprocessorSigners = await getCoprocessorSigners(provider, inputVerifierContractAddress);
     const thresholdCoprocessorSigners = await getCoprocessorSignersThreshold(provider, inputVerifierContractAddress);
     return {
-        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, 
-        //cleanURL(config.relayerUrl),
-        //relayerFhevm.relayerVersionUrl,
-        relayerFhevm.relayerProvider, 
-        //publicKeyData.publicKey,
-        relayerFhevm.getPublicKeyWasm().publicKey, 
-        //publicParamsData,
-        { 2048: relayerFhevm.getPublicParamsWasm(2048) }, coprocessorSigners, thresholdCoprocessorSigners),
+        createEncryptedInput: createRelayerEncryptedInput(aclContractAddress, verifyingContractAddressInputVerification, chainId, gatewayChainId, relayerFhevm.relayerProvider, relayerFhevm.getPublicKeyWasm().publicKey, { 2048: relayerFhevm.getPublicParamsWasm(2048) }, coprocessorSigners, thresholdCoprocessorSigners, auth && { auth }),
         generateKeypair,
         createEIP712: createEIP712(verifyingContractAddressDecryption, chainId),
         publicDecrypt: publicDecryptRequest(kmsSigners, thresholdKMSSigners, gatewayChainId, verifyingContractAddressDecryption, aclContractAddress, 
@@ -5066,7 +5103,7 @@ const createTfhePublicKey = () => {
 global.TFHE = TFHEPkg__namespace;
 global.TKMS = TKMSPkg__namespace;
 
-exports.ENCRYPTION_TYPES = ENCRYPTION_TYPES;
+exports.MainnetConfig = MainnetConfig;
 exports.SepoliaConfig = SepoliaConfig;
 exports.createEIP712 = createEIP712;
 exports.createInstance = createInstance;