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

package/bin/commands/config.js

@@ -0,0 +1,13 @@
+'use strict';
+
+import { parseCommonOptions } from '../utils.js';
+
+// npx . config
+// npx . config --name testnet
+// npx . config --name devnet
+// npx . config --contract-address 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9 --user-address 0x37AC010c1c566696326813b840319B58Bb5840E4
+export async function configCommand(options) {
+  const { config } = parseCommonOptions(options);
+
+  console.log(JSON.stringify(config, null, 2));
+}

package/bin/commands/handle.js

@@ -0,0 +1,22 @@
+'use strict';
+
+import { parseCommonOptions, parseHandles } from '../utils.js';
+
+/*
+  "0x23dbf1687ffafbc15853416621ca14c09fea621d74000000000000aa36a70000"
+  "0xf96aab67148b26af2423a849f18114a39b8d8a7433000000000000aa36a70000"
+  "0x4b8cb305c234bc4a4b7de2fe3f5b121a72f249e1a6000000000000aa36a70000"
+  "0x646315ed2a2153795a011b8091bb1c4e6ae6d7fd4f000000000000aa36a70200"
+  "0xe49cb5d474bde768be1f68b4a144823885db839ffe000000000000aa36a70000"
+  "0x70cae442f5545bb892158b1dac9b036daac2481210000000000000aa36a70000"
+  "0x954859342a33ba51e8ab897f9e5f27e53e9975068f000000000000aa36a70000"
+  "0xb642793478114df3f6c2c04cd49d5ca092c41438b1ff0000000000aa36a70000"
+  "0xe41e81c8d93596bb3c8cbd813e683ab0f21c42a6ecff0000000000aa36a70400"
+  "0x7db07d2c2aed31571bbe4fe62ee84f1e8967c3869a000000000000aa36a70000"
+*/
+// npx . handle "0x36a1f452f2c26d7cbf329d23220d92c342062fa7f7000000000000aa36a70000 0xce6f699529292547e11ad7635537997fef29519ecf010000000000aa36a70200 0x9162215c0789609fb2132615c76e80af78209797d9020000000000aa36a70600 0xa8225e1781cab16dedf1b9a5f5c0ed0f03b64d1fb3030000000000aa36a70700"
+export async function handleCommand(args, options) {
+  const { config } = parseCommonOptions(options);
+  const fhevmHandles = parseHandles(args);
+  console.log(JSON.stringify(fhevmHandles, null, 2));
+}

package/bin/commands/input-proof.js

@@ -0,0 +1,75 @@
+'use strict';
+
+import {
+  isFheTypeName,
+  encryptionBitsFromFheTypeName,
+  FhevmHandle,
+  bytesToHex,
+  safeJSONstringify,
+} from '../../lib/internal.js';
+import { getInstance } from '../instance.js';
+import { loadFhevmPubKey } from '../pubkeyCache.js';
+import {
+  fheTypedValuesToBuilderFunctionWithArg,
+  logCLI,
+  parseCommonOptions,
+  throwError,
+  valueColumnTypeListToFheTypedValues,
+} from '../utils.js';
+
+// npx . input-proof --values 123:euint32 true:ebool 1234567890123456789:euint256 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9:eaddress
+// npx . input-proof --contract-address 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9 --user-address 0x37AC010c1c566696326813b840319B58Bb5840E4 --values 123:euint32
+export async function inputProofCommand(options) {
+  const { config } = parseCommonOptions(options);
+
+  const fheTypedValues = valueColumnTypeListToFheTypedValues(options.values);
+  const arr = fheTypedValuesToBuilderFunctionWithArg(fheTypedValues);
+
+  const { publicKey, publicParams } = await loadFhevmPubKey(config, options);
+
+  try {
+    const instance = await getInstance(
+      {
+        ...config.fhevmInstanceConfig,
+        publicKey,
+        publicParams,
+      },
+      options,
+    );
+
+    const builder = instance.createEncryptedInput(
+      config.contractAddress,
+      config.userAddress,
+    );
+    for (let i = 0; i < arr.length; ++i) {
+      builder[arr[i].funcName](arr[i].arg);
+    }
+
+    logCLI(`🎲 generating zkproof...`, options);
+    const zkproof = builder.generateZKProof();
+
+    logCLI(`🎲 verifying zkproof...`, options);
+    const { handles, inputProof } = await instance.requestZKProofVerification(
+      zkproof,
+      {
+        onProgress: (args) => {
+          logCLI(`onProgress: ${args.type}`, options);
+        },
+      },
+    );
+
+    const o = {
+      values: fheTypedValues,
+      handles: handles.map((h) => FhevmHandle.fromBytes32(h).toBytes32Hex()),
+      inputProof: bytesToHex(inputProof),
+    };
+
+    console.log(safeJSONstringify(o, 2));
+  } catch (e) {
+    console.log(e.message);
+    console.log(e);
+    console.log(JSON.stringify(e.cause, null, 2));
+
+    process.exit(1);
+  }
+}

package/bin/commands/pubkey-clear.js

@@ -0,0 +1,18 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { logCLI } from '../utils';
+
+// npx . pubkey clear
+export async function pubkeyClearCommand(options) {
+  const cacheDir = path.join(homedir(), '.fhevm');
+
+  logCLI(`🎃 FHEVM pubKey cache directory: ${cacheDir}`, options);
+
+  if (fs.existsSync(cacheDir)) {
+    fs.rmSync(cacheDir, { recursive: true });
+    logCLI(`✅ FHEVM pubKey cache cleared.`, options);
+  } else {
+    logCLI(`✅ FHEVM pubKey cache is empty.`, options);
+  }
+}

package/bin/commands/pubkey-fetch.js

@@ -0,0 +1,9 @@
+import { parseCommonOptions } from '../utils.js';
+import { loadFhevmPubKey } from '../pubkeyCache.js';
+
+// npx . pubkey fetch
+export async function pubkeyFetchCommand(options) {
+  const { config } = parseCommonOptions(options);
+
+  await loadFhevmPubKey(config, options);
+}

package/bin/commands/pubkey-info.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { TFHECrs, TFHEPublicKey } from '../../lib/internal.js';
+import { logCLI } from '../utils.js';
+
+// npx . pubkey info
+export async function pubkeyInfoCommand(options) {
+  const cacheDir = path.join(homedir(), '.fhevm');
+
+  const pubKeyFile = path.join(cacheDir, 'pubkey.json');
+  const pubKeyParams2048File = path.join(cacheDir, 'pubkey-params-2048.json');
+
+  logCLI(`cache directory       : ${cacheDir}`, options);
+  logCLI(`pubKey file           : ${pubKeyFile}`, options);
+  logCLI(`pubKeyParams2048 file : ${pubKeyParams2048File}`, options);
+
+  if (fs.existsSync(pubKeyFile)) {
+    logCLI(
+      `✅ pubKey file size : ${fs.statSync(pubKeyFile).size} bytes`,
+      options,
+    );
+    const pk = TFHEPublicKey.fromJSON(
+      JSON.parse(fs.readFileSync(pubKeyFile, 'utf-8')),
+    );
+    logCLI(`✅ pubKey id : ${pk.id}`, options);
+  } else {
+    logCLI(`❌ pubKey file size : file does not exist`, options);
+  }
+
+  if (fs.existsSync(pubKeyParams2048File)) {
+    logCLI(
+      `✅ pubKeyParams2048 file size : ${fs.statSync(pubKeyParams2048File).size} bytes`,
+      options,
+    );
+    const crs = TFHECrs.fromJSON(
+      JSON.parse(fs.readFileSync(pubKeyParams2048File, 'utf-8')),
+    );
+    logCLI(`✅ pubKeyParams2048 bits : ${crs.bits}`, options);
+    logCLI(`✅ pubKeyParams2048 id   : ${crs.id}`, options);
+  } else {
+    logCLI(`❌ pubKeyParams2048 file size : file does not exist`, options);
+  }
+}

package/bin/commands/public-decrypt.js

@@ -0,0 +1,64 @@
+'use strict';
+
+import { safeJSONstringify } from '../../lib/internal.js';
+import { getInstance } from '../instance.js';
+import { loadFhevmPubKey } from '../pubkeyCache.js';
+import { logCLI, parseCommonOptions, parseHandles } from '../utils.js';
+
+// Old devnet handles publicly decryptable
+// =======================================
+// 0xc49cf03ffa2768ee7ca49fb8b1fe930c6b43075ed0000000000000aa36a70000
+// 0xfd82b3d4bc3318f57189a5841e248e24b59453a168ff0000000000aa36a70400
+
+// npx . public-decrypt --handles 0xfd82b3d4bc3318f57189a5841e248e24b59453a168ff0000000000aa36a70400
+// npx . public-decrypt --version 2 --handles 0xfd82b3d4bc3318f57189a5841e248e24b59453a168ff0000000000aa36a70400
+// npx . public-decrypt --version 2 --handles 0xc49cf03ffa2768ee7ca49fb8b1fe930c6b43075ed0000000000000aa36a70000
+export async function publicDecryptCommand(options) {
+  const { config } = parseCommonOptions(options);
+
+  const fhevmHandles = parseHandles(options.handles);
+  const handles = fhevmHandles.map((h) => {
+    return h.toBytes32Hex();
+  });
+
+  const { publicKey, publicParams } = await loadFhevmPubKey(config, options);
+
+  try {
+    const instance = await getInstance(
+      {
+        ...config.fhevmInstanceConfig,
+        publicKey,
+        publicParams,
+      },
+      options,
+    );
+
+    logCLI('Running public decrypt...', options);
+
+    // setTimeout(() => {
+    //   abortController.abort();
+    // }, 3000);
+
+    const res = await instance.publicDecrypt(handles, {
+      timeout: 5000,
+      //signal: abortController.signal,
+      onProgress: (args) => {
+        logCLI('progress=' + args.type, options);
+      },
+    });
+
+    console.log(safeJSONstringify(res, 2));
+  } catch (e) {
+    console.log('');
+    console.log('===================== ❌ ERROR ❌ ========================');
+    console.log(`[Error message]: '${e.message}'`);
+    console.log('');
+    console.log(`[Error log]:`);
+    console.log(e);
+    if (e.cause) {
+      console.log('[ERROR cause]:');
+      console.log(JSON.stringify(e.cause, null, 2));
+    }
+    console.log('========================================================');
+  }
+}

package/bin/commands/test-fhecounter-getcount.js

@@ -0,0 +1,49 @@
+'use strict';
+
+import {
+  isFheTypeName,
+  encryptionBitsFromFheTypeName,
+  FhevmHandle,
+  bytesToHex,
+} from '../../lib/internal.js';
+import { getInstance } from '../instance.js';
+import { loadFhevmPubKey } from '../pubkeyCache.js';
+import { logCLI, parseCommonOptions, throwError } from '../utils.js';
+import { ethers } from 'ethers';
+
+// npx . test fhecounter-get-count
+export async function testFheCounterGetCountCommand(options) {
+  const { config, provider } = parseCommonOptions(options);
+
+  const contractAddress =
+    config.name === 'testnet'
+      ? '0x69c4511f85E9acBb9a3D4Be7098d1d2232Ed1F7f'
+      : '0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9';
+  // Devnet
+  // const FHE_COUNTER_PUBLIC_DECRYPT_ADDRESS =
+  //   '0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9';
+  // const FHE_COUNTER_USER_DECRYPT_ADDRESS =
+  //   '0xE4DdA6c4C007e24fcebF95073d8Cd7b2a3db1A40';
+  // const FHE_COUNTER_DEPLOYER_ADDRESS =
+  //   '0x37AC010c1c566696326813b840319B58Bb5840E4';
+
+  // Testnet
+  // FHE_COUNTER_USER_DECRYPT_ADDRESS=0x9F3fd46B454D35cc4c661a97FB5e6FaBb70A18C2
+  // const FHE_COUNTER_PUBLIC_DECRYPT_ADDRESS =
+  //   '0x69c4511f85E9acBb9a3D4Be7098d1d2232Ed1F7f';
+  // FHE_COUNTER_DEPLOYER_ADDRESS=0x37AC010c1c566696326813b840319B58Bb5840E4
+  // handle(testnet): 0x8f0e50f96fa55c3d7e4abe9db89ff72c0fb4f58c6a000000000000aa36a70400
+  const contract = new ethers.Contract(
+    contractAddress,
+    ['function getCount() view returns (bytes32)'],
+    provider,
+  );
+
+  const eCount = await contract.getCount();
+  const handle = FhevmHandle.fromBytes32Hex(eCount);
+
+  logCLI('🚚 network: ' + config.name, options);
+  logCLI('🤖 contractAddress: ' + contractAddress, options);
+
+  console.log(JSON.stringify(handle, null, 2));
+}

package/bin/commands/zkproof-generate.js

@@ -0,0 +1,68 @@
+'use strict';
+
+import {
+  isFheTypeName,
+  encryptionBitsFromFheTypeName,
+  FhevmHandle,
+  bytesToHex,
+  safeJSONstringify,
+  bytesToHexLarge,
+} from '../../lib/internal.js';
+import { getInstance } from '../instance.js';
+import { loadFhevmPubKey } from '../pubkeyCache.js';
+import {
+  fheTypedValuesToBuilderFunctionWithArg,
+  logCLI,
+  parseCommonOptions,
+  throwError,
+  valueColumnTypeListToFheTypedValues,
+} from '../utils.js';
+
+// npx . zkproof generate --values 123:euint32 true:ebool 1234567890123456789:euint256 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9:eaddress
+// npx . zkproof generate --contract-address 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9 --user-address 0x37AC010c1c566696326813b840319B58Bb5840E4 --values 123:euint32
+export async function zkProofGenerateCommand(options) {
+  const { config } = parseCommonOptions(options);
+
+  const fheTypedValues = valueColumnTypeListToFheTypedValues(options.values);
+  const arr = fheTypedValuesToBuilderFunctionWithArg(fheTypedValues);
+
+  const { publicKey, publicParams } = await loadFhevmPubKey(config, options);
+
+  try {
+    const instance = await getInstance(
+      {
+        ...config.fhevmInstanceConfig,
+        publicKey,
+        publicParams,
+      },
+      options,
+    );
+
+    const builder = instance.createEncryptedInput(
+      config.contractAddress,
+      config.userAddress,
+    );
+    for (let i = 0; i < arr.length; ++i) {
+      builder[arr[i].funcName](arr[i].arg);
+    }
+
+    logCLI(`🎲 generating zkproof...`, options);
+    const zkProof = builder.generateZKProof();
+    zkProof.ciphertextWithZkProof = bytesToHexLarge(
+      zkProof.ciphertextWithZkProof,
+    );
+
+    const o = {
+      values: fheTypedValues,
+      zkProof,
+    };
+
+    console.log(safeJSONstringify(o, 2));
+  } catch (e) {
+    console.log(e.message);
+    console.log(e);
+    console.log(JSON.stringify(e.cause, null, 2));
+
+    process.exit(1);
+  }
+}

package/bin/instance.js

@@ -0,0 +1,15 @@
+import { createInstance } from '../lib/node.cjs';
+import { logCLI } from './utils.js';
+
+let __instance;
+
+export async function getInstance(config, options) {
+  if (!__instance) {
+    if (!config) {
+      throw new Error('Missing FhevmInstanceConfig');
+    }
+    logCLI(`create FHEVM instance...`, options);
+    __instance = await createInstance(config);
+  }
+  return __instance;
+}

package/bin/pubkeyCache.js

@@ -0,0 +1,126 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { createRelayerFhevm, TFHECrs, TFHEPublicKey } from '../lib/internal.js';
+import { logCLI } from './utils.js';
+
+export function getFhevmPubKeyCacheInfo() {
+  const cacheDir = path.join(homedir(), '.fhevm');
+  const pubKeyFile = path.join(cacheDir, 'pubkey.json');
+  const pubKeyParams2048File = path.join(cacheDir, 'pubkey-params-2048.json');
+  return {
+    cacheDir,
+    pubKeyFile,
+    pubKeyParams2048File,
+  };
+}
+
+export async function loadFhevmPubKey(config, options) {
+  const res = loadFhevmPubKeyFromCache(options);
+  if (res) {
+    return {
+      publicKey: res.pk.toBytes(),
+      publicParams: res.crs.toPublicParams2048Bytes(),
+    };
+  }
+
+  const startTime = Date.now();
+
+  logCLI(
+    `Fetching pub keys from ${config.fhevmInstanceConfig.relayerUrl}...`,
+    options,
+  );
+
+  const fhevm = await createRelayerFhevm({
+    ...config.fhevmInstanceConfig,
+    defaultRelayerVersion: config.version,
+  });
+
+  logCLI(`Relayer url: ${fhevm.relayerVersionUrl}`, options);
+
+  const pubKeyBytes = fhevm.getPublicKeyBytes();
+  const publicParams2048Bytes = fhevm.getPublicParamsBytesForBits(2048);
+
+  const pk = TFHEPublicKey.fromPublicKeyBytes(pubKeyBytes);
+  const crs = TFHECrs.fromBitsPublicParamsBytes(2048, publicParams2048Bytes);
+
+  saveFhevmPubKeyToCache({ startTime, pk, crs });
+
+  return {
+    publicKey: pk.toBytes(),
+    publicParams: crs.toPublicParams2048Bytes(),
+  };
+}
+
+export function loadFhevmPubKeyFromCache({ clearCache, json, verbose }) {
+  const { pubKeyFile, pubKeyParams2048File } = getFhevmPubKeyCacheInfo();
+
+  const pubKeyFileExists = fs.existsSync(pubKeyFile);
+  const pubKeyParams2048FileExists = fs.existsSync(pubKeyParams2048File);
+
+  if (!pubKeyFileExists) {
+    logCLI(`❌ pubKey file does not exist.`, { json, verbose });
+  }
+  if (!pubKeyParams2048FileExists) {
+    logCLI(`❌ pubKeyParams2048 file does not exist.`, { json, verbose });
+  }
+
+  if (!pubKeyParams2048FileExists || !pubKeyFileExists) {
+    clearCache = true;
+  }
+
+  if (clearCache) {
+    if (pubKeyFileExists) {
+      logCLI(`delete ${pubKeyFile}.`, { json, verbose });
+      fs.rmSync(pubKeyFile);
+    }
+    if (pubKeyParams2048FileExists) {
+      logCLI(`delete ${pubKeyParams2048File}.`, { json, verbose });
+      fs.rmSync(pubKeyParams2048File);
+    }
+
+    return null;
+  }
+
+  logCLI(`✅ load pubKey from cache...`, { json, verbose });
+  const pk = TFHEPublicKey.fromJSON(
+    JSON.parse(fs.readFileSync(pubKeyFile, 'utf-8')),
+  );
+
+  logCLI(`✅ load pubKeyParams2048 from cache...`, { json, verbose });
+  const crs = TFHECrs.fromJSON(
+    JSON.parse(fs.readFileSync(pubKeyParams2048File, 'utf-8')),
+  );
+
+  return { pk, crs };
+}
+
+export function saveFhevmPubKeyToCache({ startTime, pk, crs, json, verbose }) {
+  const { cacheDir, pubKeyFile, pubKeyParams2048File } =
+    getFhevmPubKeyCacheInfo();
+
+  const pkJson = pk.toJSON();
+  const crsJson = crs.toJSON();
+
+  logCLI(`FHEVM pubKey cache directory: ${cacheDir}`, { json, verbose });
+
+  if (!fs.existsSync(cacheDir)) {
+    logCLI(`create directory ${cacheDir}...`, { json, verbose });
+    fs.mkdirSync(cacheDir);
+  }
+
+  fs.writeFileSync(pubKeyFile, JSON.stringify(pkJson), 'utf-8');
+  logCLI(
+    `🍟 TFHEPublicKey saved at ${pubKeyFile} (${Date.now() - startTime}ms)`,
+    {
+      json,
+      verbose,
+    },
+  );
+
+  fs.writeFileSync(pubKeyParams2048File, JSON.stringify(crsJson), 'utf-8');
+  logCLI(
+    `🥬 TFHECrs saved at ${pubKeyParams2048File} (${Date.now() - startTime}ms)`,
+    { json, verbose },
+  );
+}