@zama-fhe/relayer-sdk 0.3.0-2 → 0.3.0-4

package/lib/web.js

@@ -16282,6 +16282,9 @@ const bytesToBigInt = function (byteArray) {
         .join('');
     return BigInt(`0x${hex}`);
 };
+function ensure0x(s) {
+    return !s.startsWith('0x') ? `0x${s}` : s;
+}
 
 function setAuth(init, auth) {
     if (auth) {
@@ -16788,6 +16791,17 @@ const NumEncryptedBits = {
     7: 160, // eaddress
     8: 256, // euint256
 };
+function getHandleType(handle) {
+    if (handle.length !== 66) {
+        throw new Error(`Handle ${handle} is not of valid length`);
+    }
+    const hexPair = handle.slice(-4, -2).toLowerCase();
+    const typeDiscriminant = parseInt(hexPair, 16);
+    if (!(typeDiscriminant in NumEncryptedBits)) {
+        throw new Error(`Handle ${handle} is not of valid type`);
+    }
+    return typeDiscriminant;
+}
 function checkEncryptedBits(handles) {
     let total = 0;
     for (const handle of handles) {
@@ -16816,37 +16830,30 @@ const aclABI$1 = [
 ];
 const MAX_USER_DECRYPT_CONTRACT_ADDRESSES = 10;
 const MAX_USER_DECRYPT_DURATION_DAYS = BigInt(365);
-function formatAccordingToType(decryptedBigInt, type) {
+function formatAccordingToType(clearValueAsBigInt, type) {
     if (type === 0) {
         // ebool
-        return decryptedBigInt === BigInt(1);
+        return clearValueAsBigInt === BigInt(1);
     }
     else if (type === 7) {
         // eaddress
-        return getAddress$1('0x' + decryptedBigInt.toString(16).padStart(40, '0'));
-    }
-    else if (type === 9) {
-        // ebytes64
-        return '0x' + decryptedBigInt.toString(16).padStart(128, '0');
+        return getAddress$1('0x' + clearValueAsBigInt.toString(16).padStart(40, '0'));
     }
-    else if (type === 10) {
-        // ebytes128
-        return '0x' + decryptedBigInt.toString(16).padStart(256, '0');
+    else if (type > 8 || type == 1) {
+        // type == 1 : euint4 (not supported)
+        throw new Error(`Unsupported handle type ${type}`);
     }
-    else if (type === 11) {
-        // ebytes256
-        return '0x' + decryptedBigInt.toString(16).padStart(512, '0');
-    } // euintXXX
-    return decryptedBigInt;
+    // euintXXX
+    return clearValueAsBigInt;
 }
-function buildUserDecryptedResult(handles, listBigIntDecryptions) {
+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);
     }
-    let results = {};
+    const results = {};
     handles.forEach((handle, idx) => (results[handle] = formatAccordingToType(listBigIntDecryptions[idx], typesList[idx])));
     return results;
 }
@@ -16952,7 +16959,7 @@ const userDecryptRequest = (kmsSigners, gatewayChainId, chainId, verifyingContra
         };
         const decryption = TKMS.process_user_decryption_resp_from_js(client, payloadForVerification, eip712Domain, json.response, pubKey, privKey, true);
         const listBigIntDecryptions = decryption.map((d) => bytesToBigInt(d.bytes));
-        const results = buildUserDecryptedResult(handles.map((h) => h.handle), listBigIntDecryptions);
+        const results = buildUserDecryptResults(handles.map((h) => h.handle), listBigIntDecryptions);
         return results;
     }
     catch (e) {
@@ -17363,6 +17370,74 @@ function isThresholdReached(kmsSigners, recoveredAddresses, threshold) {
     }
     return recoveredAddresses.length >= threshold;
 }
+function abiEncodeClearValues(clearValues) {
+    const handlesBytes32Hex = Object.keys(clearValues);
+    const abiTypes = [];
+    const abiValues = [];
+    for (let i = 0; i < handlesBytes32Hex.length; ++i) {
+        const handle = handlesBytes32Hex[i];
+        const handleType = getHandleType(handle);
+        let clearTextValue = clearValues[handle];
+        if (typeof clearTextValue === 'boolean') {
+            clearTextValue = clearTextValue ? '0x01' : '0x00';
+        }
+        const clearTextValueBigInt = BigInt(clearTextValue);
+        //abiTypes.push(fhevmTypeInfo.solidityTypeName);
+        abiTypes.push('uint256');
+        switch (handleType) {
+            // eaddress
+            case 7: {
+                // string
+                abiValues.push(`0x${clearTextValueBigInt.toString(16).padStart(40, '0')}`);
+                break;
+            }
+            // ebool
+            case 0: {
+                // bigint (0 or 1)
+                if (clearTextValueBigInt !== BigInt(0) &&
+                    clearTextValueBigInt !== BigInt(1)) {
+                    throw new Error(`Invalid ebool clear text value ${clearTextValueBigInt}. Expecting 0 or 1.`);
+                }
+                abiValues.push(clearTextValueBigInt);
+                break;
+            }
+            case 2: //euint8
+            case 3: //euint16
+            case 4: //euint32
+            case 5: //euint64
+            case 6: //euint128
+            case 7: {
+                //euint256
+                // bigint
+                abiValues.push(clearTextValueBigInt);
+                break;
+            }
+            default: {
+                throw new Error(`Unsupported Fhevm primitive type id: ${handleType}`);
+            }
+        }
+    }
+    const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+    // ABI encode the decryptedResult as done in the KMS, since all decrypted values
+    // are native static types, thay have same abi-encoding as uint256:
+    const abiEncodedClearValues = abiCoder.encode(abiTypes, abiValues);
+    return {
+        abiTypes,
+        abiValues,
+        abiEncodedClearValues,
+    };
+}
+function buildDecryptionProof(kmsSignatures, extraData) {
+    // Build the decryptionProof as numSigners + KMS signatures + extraData
+    const packedNumSigners = ethers.solidityPacked(['uint8'], [kmsSignatures.length]);
+    const packedSignatures = ethers.solidityPacked(Array(kmsSignatures.length).fill('bytes'), kmsSignatures);
+    const decryptionProof = ethers.concat([
+        packedNumSigners,
+        packedSignatures,
+        extraData,
+    ]);
+    return decryptionProof;
+}
 const CiphertextType = {
     0: 'bool',
     2: 'uint256',
@@ -17373,7 +17448,7 @@ const CiphertextType = {
     7: 'address',
     8: 'uint256',
 };
-function deserializeDecryptedResult(handles, decryptedResult) {
+function deserializeClearValues(handles, decryptedResult) {
     let typesList = [];
     for (const handle of handles) {
         const hexPair = handle.slice(-4, -2).toLowerCase();
@@ -17392,7 +17467,7 @@ function deserializeDecryptedResult(handles, decryptedResult) {
     const decoded = coder.decode(['uint256', ...abiTypes, 'bytes[]'], restoredEncoded);
     // strip dummy first/last element
     const rawValues = decoded.slice(1, 1 + typesList.length);
-    let results = {};
+    const results = {};
     handles.forEach((handle, idx) => (results[handle] = rawValues[idx]));
     return results;
 }
@@ -17437,22 +17512,25 @@ const publicDecryptRequest = (kmsSigners, thresholdSigners, gatewayChainId, veri
         ],
     };
     const result = json.response[0];
-    const decryptedResult = result.decrypted_value.startsWith('0x')
-        ? result.decrypted_value
-        : `0x${result.decrypted_value}`;
-    const signatures = result.signatures;
+    const decryptedResult = ensure0x(result.decrypted_value);
+    const kmsSignatures = result.signatures.map(ensure0x);
     const signedExtraData = '0x';
-    const recoveredAddresses = signatures.map((signature) => {
-        const sig = signature.startsWith('0x') ? signature : `0x${signature}`;
-        const recoveredAddress = ethers.verifyTypedData(domain, types, { ctHandles: handles, decryptedResult, extraData: signedExtraData }, sig);
+    const recoveredAddresses = kmsSignatures.map((kmsSignature) => {
+        const recoveredAddress = ethers.verifyTypedData(domain, types, { ctHandles: handles, decryptedResult, extraData: signedExtraData }, kmsSignature);
         return recoveredAddress;
     });
     const thresholdReached = isThresholdReached(kmsSigners, recoveredAddresses, thresholdSigners);
     if (!thresholdReached) {
         throw Error('KMS signers threshold is not reached');
     }
-    const results = deserializeDecryptedResult(handles, decryptedResult);
-    return results;
+    const clearValues = deserializeClearValues(handles, decryptedResult);
+    const abiEnc = abiEncodeClearValues(clearValues);
+    const decryptionProof = buildDecryptionProof(kmsSignatures, signedExtraData);
+    return {
+        clearValues,
+        abiEncodedClearValues: abiEnc.abiEncodedClearValues,
+        decryptionProof,
+    };
 };
 
 /**
@@ -17562,23 +17640,23 @@ const generateKeypair = () => {
 global.fetch = fetchRetry(global.fetch, { retries: 5, retryDelay: 500 });
 const SepoliaConfig = {
     // ACL_CONTRACT_ADDRESS (FHEVM Host chain)
-    aclContractAddress: '0x687820221192C5B662b25367F70076A37bc79b6c',
+    aclContractAddress: '0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D',
     // KMS_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
-    kmsContractAddress: '0x1364cBBf2cDF5032C47d8226a6f6FBD2AFCDacAC',
+    kmsContractAddress: '0xbE0E383937d564D7FF0BC3b46c51f0bF8d5C311A',
     // INPUT_VERIFIER_CONTRACT_ADDRESS (FHEVM Host chain)
-    inputVerifierContractAddress: '0xbc91f3daD1A5F19F8390c400196e58073B6a0BC4',
+    inputVerifierContractAddress: '0xBBC1fFCdc7C316aAAd72E807D9b0272BE8F84DA0',
     // DECRYPTION_ADDRESS (Gateway chain)
-    verifyingContractAddressDecryption: '0xb6E160B1ff80D67Bfe90A85eE06Ce0A2613607D1',
+    verifyingContractAddressDecryption: '0x5D8BD78e2ea6bbE41f26dFe9fdaEAa349e077478',
     // INPUT_VERIFICATION_ADDRESS (Gateway chain)
-    verifyingContractAddressInputVerification: '0x7048C39f048125eDa9d678AEbaDfB22F7900a29F',
+    verifyingContractAddressInputVerification: '0x483b9dE06E4E4C7D35CCf5837A1668487406D955',
     // FHEVM Host chain id
     chainId: 11155111,
     // Gateway chain id
-    gatewayChainId: 55815,
+    gatewayChainId: 10901,
     // Optional RPC provider to host chain
     network: 'https://eth-sepolia.public.blastapi.io',
     // Relayer URL
-    relayerUrl: 'https://relayer.testnet.zama.cloud',
+    relayerUrl: 'https://relayer.testnet.zama.org',
 };
 const createInstance = async (config) => {
     const { verifyingContractAddressDecryption, verifyingContractAddressInputVerification, publicKey, kmsContractAddress, aclContractAddress, gatewayChainId, auth, } = config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zama-fhe/relayer-sdk",
-  "version": "0.3.0-2",
+  "version": "0.3.0-4",
   "description": "fhevm Relayer SDK",
   "main": "lib/node.js",
   "types": "lib/node.d.ts",
@@ -24,7 +24,8 @@
       "import": "./lib/node.js",
       "require": "./lib/node.cjs",
       "types": "./lib/node.d.ts"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
     "lint": "eslint src/",