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

package/bin/relayer.js

@@ -2,67 +2,140 @@
 'use strict';
 
 import { program } from 'commander';
-import { toHexString, prependHttps, throwError } from './utils.js';
-import { createInstance, SepoliaConfig } from '../lib/node.cjs';
-
-const allowedBits = [1, 4, 8, 16, 32, 64];
-
-let _instance;
-
-const getInstance = async (networkUrl) => {
-  if (_instance) return _instance;
-
-  try {
-    // NOTE: hack to get the instance created
-    const config = { ...SepoliaConfig, network: networkUrl };
-    console.debug(`Using network ${config.network}`);
-    _instance = await createInstance(config);
-  } catch (e) {
-    return throwError(
-      `This network (${networkUrl}) doesn't seem to use Fhevm or use an incompatible version.`,
-      e,
-    );
-  }
-  return _instance;
-};
+import { addCommonOptions } from './utils.js';
+import { inputProofCommand } from './commands/input-proof.js';
+import { configCommand } from './commands/config.js';
+import { publicDecryptCommand } from './commands/public-decrypt.js';
 
+////////////////////////////////////////////////////////////////////////////////
+// input-proof
+////////////////////////////////////////////////////////////////////////////////
+
+// npx . input-proof --values true:ebool
+// npx . input-proof --contract-address 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9 --user-address 0x37AC010c1c566696326813b840319B58Bb5840E4 --values true:ebool
 // TODO: be able to pass a full configuration, or simply the chain-id/name, or relayer-url
-program
-  .command('encrypt')
-  .argument('<contractAddress>', 'address of the contract')
-  .argument('<userAddress>', 'address of the account')
-  .argument('<values:bits...>', 'values with number of bits eg: 1:1 3324242:64')
-  .requiredOption(
-    '-n, --node <url>',
-    'url of the blockchain',
-    'https://eth-sepolia.public.blastapi.io',
-  )
-  .action(async (contractAddress, userAddress, valuesArr, options) => {
-    const host = prependHttps(options.node);
-    const instance = await getInstance(host);
-    const encryptedInput = instance.createEncryptedInput(
-      contractAddress,
-      userAddress,
-    );
-    valuesArr.forEach((str, i) => {
-      const [value, bits] = str.split(':');
-      if (!allowedBits.includes(+bits)) throwError('Invalid number of bits');
-      const suffix = +bits === 1 ? 'Bool' : bits === '160' ? 'Address' : bits;
-      try {
-        encryptedInput[`add${suffix}`](parseInt(value, 10));
-      } catch (e) {
-        return throwError(e.message);
-      }
-    });
-    const result = await encryptedInput.encrypt();
-
-    console.log('Input proof:');
-    console.log(`0x${toHexString(result.inputProof)}`);
-    console.log('Handles:');
-    result.handles.forEach((handle, i) => {
-      console.log(`Handle ${i}`);
-      console.log(`0x${toHexString(handle)}`);
-    });
+addCommonOptions(program.command('input-proof'))
+  .requiredOption('--values <value:type-name...>', 'List of values')
+  .action(async (options) => {
+    await inputProofCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// public-decrypt
+////////////////////////////////////////////////////////////////////////////////
+
+addCommonOptions(program.command('public-decrypt'))
+  .requiredOption('--handles <handles...>', 'List of handles to decrypt')
+  .action(async (options) => {
+    await publicDecryptCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// user-decrypt
+////////////////////////////////////////////////////////////////////////////////
+
+addCommonOptions(program.command('user-decrypt'))
+  .requiredOption('--handles <handles...>', 'List of handles to decrypt')
+  .action(async (options) => {
+    const mod = await import('./commands/user-decrypt.js');
+    await mod.userDecryptCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// handle
+////////////////////////////////////////////////////////////////////////////////
+
+addCommonOptions(program.command('handle'))
+  .argument('<handles...>', 'List of handles to parse')
+  .action(async (handles, options) => {
+    const mod = await import('./commands/handle.js');
+    await mod.handleCommand(handles, options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// config
+////////////////////////////////////////////////////////////////////////////////
+
+// npx . config --contract-address 0xb2a8A265dD5A27026693Aa6cE87Fb21Ac197b6b9 --user-address 0x37AC010c1c566696326813b840319B58Bb5840E4
+addCommonOptions(program.command('config')).action(async (options) => {
+  await configCommand(options);
+});
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Create 'pubkey' command group
+const pubkey = program.command('pubkey').description('Public key operations');
+
+////////////////////////////////////////////////////////////////////////////////
+// pubkey info
+////////////////////////////////////////////////////////////////////////////////
+
+// npx . pubkey info
+pubkey
+  .command('info')
+  .description('Display public key information')
+  .action(async (options) => {
+    const mod = await import('./commands/pubkey-info.js');
+    await mod.pubkeyInfoCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// pubkey fetch
+////////////////////////////////////////////////////////////////////////////////
+
+// npx . pubkey fetch
+addCommonOptions(pubkey.command('fetch'))
+  .description('Fetch FHEVM public key')
+  .action(async (options) => {
+    const mod = await import('./commands/pubkey-fetch.js');
+    await mod.pubkeyFetchCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// pubkey delete
+////////////////////////////////////////////////////////////////////////////////
+
+// npx . pubkey delete
+pubkey
+  .command('delete')
+  .description('Clear FHEVM public key cache')
+  .action(async () => {
+    const mod = await import('./commands/pubkey-clear.js');
+    await mod.pubkeyClearCommand();
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+// test fhecounter-get-count
+////////////////////////////////////////////////////////////////////////////////
+
+const test = program.command('test').description('Test operations');
+
+// npx . test fhecounter-get-count
+addCommonOptions(test.command('fhecounter-get-count'))
+  .description('Call FHECounter.getCount()')
+  .action(async (options) => {
+    const mod = await import('./commands/test-fhecounter-getcount.js');
+    await mod.testFheCounterGetCountCommand(options);
+  });
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Create 'zkproof' command group
+const zkproof = program.command('zkproof').description('ZKProof operations');
+
+addCommonOptions(zkproof.command('generate'))
+  .description('Generate ZKProof')
+  .requiredOption('--values <value:type-name...>', 'List of values')
+  .action(async (options) => {
+    const mod = await import('./commands/zkproof-generate.js');
+    await mod.zkProofGenerateCommand(options);
   });
 
+// addCommonOptions(zkproof.command('verify'))
+//   .description('Verify ZKProof')
+//   .action(async (options) => {
+//     const mod = await import('./commands/zkproof-verify.js');
+//     await mod.zkProofVerifyCommand(options);
+//   });
+
 program.parseAsync();

package/bin/utils.js

@@ -1,12 +1,22 @@
-export const prependHttps = (host) => {
-  if (!/^https?:\/\//i.test(host)) {
-    return 'https://' + host;
-  }
-  return host;
-};
+import dotenv from 'dotenv';
+import fs from 'fs';
+import { ethers } from 'ethers';
+import {
+  encryptionBitsFromFheTypeName,
+  FhevmHandle,
+  isChecksummedAddress,
+  isFheTypeName,
+} from '../lib/internal.js';
 
-export const toHexString = (bytes) =>
-  bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '');
+export function logCLI(message, { json, verbose }) {
+  if (json === true) {
+    if (verbose === true) {
+      process.stderr.write(message + '\n');
+    }
+  } else {
+    console.log(message);
+  }
+}
 
 export const throwError = (error, cause) => {
   if (cause) {
@@ -16,3 +26,330 @@ export const throwError = (error, cause) => {
   }
   process.exit();
 };
+
+export function getEnv(envName, envFile) {
+  if (envName === 'MNEMONIC') {
+    envFile = '.env';
+  }
+  if (!envFile) {
+    throwError(`Missing env filename`);
+  }
+  const parsedEnv = dotenv.parse(fs.readFileSync(envFile));
+  return process.env[envName] ?? parsedEnv[envName];
+}
+
+export function parseHandles(handles) {
+  const fhevmHandles = [];
+  for (let i = 0; i < handles.length; ++i) {
+    if (handles[i].indexOf(' ') >= 0) {
+      const list = handles[i].split(' ');
+      for (let j = 0; j < list.length; ++j) {
+        fhevmHandles.push(FhevmHandle.fromBytes32Hex(list[j]));
+      }
+    } else {
+      fhevmHandles.push(FhevmHandle.fromBytes32Hex(handles[i]));
+    }
+  }
+  return fhevmHandles;
+}
+
+export function createWallet({ mnemonic, path, basePath, index, wordlist }) {
+  basePath = basePath || "m/44'/60'/0'/0/";
+  index = index || 0;
+  const hdNode = ethers.HDNodeWallet.fromPhrase(
+    mnemonic,
+    undefined, // password
+    path || `${basePath}${index}`,
+    wordlist,
+  );
+  return { wallet: hdNode, address: hdNode.address };
+}
+
+export function addCommonOptions(command) {
+  return command
+    .option('--contract-address <contract address>', 'address of the contract')
+    .option('--user-address <user address>', 'address of the account')
+    .option(
+      '--network <testnet|devnet>',
+      'network name, must be "testnet" or "devnet"',
+    )
+    .option('--acl <ACL contract address>', 'ACL contract address')
+    .option(
+      '--kms-verifier <KMSVerifier contract address>',
+      'KMSVerifier contract address',
+    )
+    .option(
+      '--input-verifier <InputVerifier contract address>',
+      'InputVerifier contract address',
+    )
+    .option(
+      '--gateway-input-verification <Gateway input verification contract address>',
+      'Gateway input verification contract address',
+    )
+    .option(
+      '--gateway-decryption-verification <Gateway decryption verification contract address>',
+      'Gateway decryption verification contract address',
+    )
+    .option('--chain <chain ID>', 'The chain ID')
+    .option('--gateway-chain <gateway chain ID>', 'The gateway chain ID')
+    .option('--rpc-url <rpc url>', 'The rpc url')
+    .option('--relayer-url <relayer url>', 'The relayer url')
+    .option('--mnemonic <word list>', 'Mnemonic word list')
+    .option('--version <route v1 or v2>', 'The default route version: 1|2')
+    .option('--clear-cache', 'Clear the FHEVM public key cache')
+    .option('--json', 'Ouput in JSON format')
+    .option('--verbose', 'Verbose output');
+}
+
+/**
+ * @param {object} options - Command line options
+ * @returns {{
+ *   config: {
+ *     name: 'testnet' | 'devnet',
+ *     version: 1 | 2,
+ *     walletAddress: string,
+ *     userAddress: string,
+ *     contractAddress: string,
+ *     fhevmInstanceConfig: {
+ *       aclContractAddress: string,
+ *       kmsContractAddress: string,
+ *       inputVerifierContractAddress: string,
+ *       verifyingContractAddressDecryption: string,
+ *       verifyingContractAddressInputVerification: string,
+ *       chainId: number,
+ *       gatewayChainId: number,
+ *       network: string,
+ *       relayerUrl: string,
+ *     },
+ *   },
+ *   wallet: import('ethers').HDNodeWallet | undefined,
+ *   signer: import('ethers').HDNodeWallet | undefined,
+ *   provider: import('ethers').JsonRpcProvider,
+ * }}
+ */
+export function parseCommonOptions(options) {
+  const name = options?.network ?? 'devnet';
+  if (name !== 'testnet' && name !== 'devnet') {
+    throwError(`Invalid network name '${name}'.`);
+  }
+
+  let version = options?.version ?? 1;
+  if (version === 'v1' || version === '1') {
+    version = 1;
+  }
+  if (version === 'v2' || version === '2') {
+    version = 2;
+  }
+  if (version !== 1 && version !== 2) {
+    throwError(`Invalid relayer route version '${version}'.`);
+  }
+
+  let rpcUrl = options?.rpcUrl;
+  if (!rpcUrl) {
+    rpcUrl = getEnv('RPC_URL', `.env.${name}`);
+  }
+  if (!rpcUrl) {
+    throwError(`Missing Rpc Url.`);
+  }
+
+  let relayerUrl = options?.relayerUrl;
+  if (!relayerUrl) {
+    relayerUrl = getEnv('RELAYER_URL', `.env.${name}`);
+  }
+  if (!relayerUrl) {
+    throwError(`Missing relayer Url.`);
+  }
+
+  if (version === 1) {
+    if (!relayerUrl.endsWith('/v1')) {
+      relayerUrl = relayerUrl + '/v1';
+    }
+  }
+  if (version === 2) {
+    if (!relayerUrl.endsWith('/v2')) {
+      relayerUrl = relayerUrl + '/v2';
+    }
+  }
+
+  let contractAddress = options?.contractAddress;
+  if (!contractAddress) {
+    contractAddress = getEnv('CONTRACT_ADDRESS', `.env.${name}`);
+  }
+  if (!contractAddress) {
+    contractAddress = getEnv(
+      'FHE_COUNTER_PUBLIC_DECRYPT_ADDRESS',
+      `.env.${name}`,
+    );
+  }
+  if (!isChecksummedAddress(contractAddress)) {
+    throwError(`Invalid contract address '${contractAddress}'.`);
+  }
+
+  let userAddress = options?.userAddress;
+  if (userAddress && !isChecksummedAddress(userAddress)) {
+    userAddress = getEnv('USER_ADDRESS', `.env.${name}`);
+  }
+
+  let aclContractAddress = options?.acl;
+  if (!aclContractAddress) {
+    aclContractAddress = getEnv('ACL_CONTRACT_ADDRESS', `.env.${name}`);
+  }
+  if (!isChecksummedAddress(aclContractAddress)) {
+    throwError(`Invalid ACL address '${aclContractAddress}'.`);
+  }
+
+  let kmsContractAddress = options?.kmsVerifier;
+  if (!kmsContractAddress) {
+    kmsContractAddress = getEnv(
+      'KMS_VERIFIER_CONTRACT_ADDRESS',
+      `.env.${name}`,
+    );
+  }
+  if (!isChecksummedAddress(kmsContractAddress)) {
+    throwError(`Invalid KMSVerifier address '${kmsContractAddress}'.`);
+  }
+
+  let inputVerifierContractAddress = options?.inputVerifier;
+  if (!inputVerifierContractAddress) {
+    inputVerifierContractAddress = getEnv(
+      'INPUT_VERIFIER_CONTRACT_ADDRESS',
+      `.env.${name}`,
+    );
+  }
+  if (!isChecksummedAddress(inputVerifierContractAddress)) {
+    throwError(
+      `Invalid InputVerifier address '${inputVerifierContractAddress}'.`,
+    );
+  }
+
+  let verifyingContractAddressInputVerification =
+    options?.gatewayInputVerification;
+  if (!verifyingContractAddressInputVerification) {
+    verifyingContractAddressInputVerification = getEnv(
+      'INPUT_VERIFICATION_ADDRESS',
+      `.env.${name}`,
+    );
+  }
+  if (!isChecksummedAddress(kmsContractAddress)) {
+    throwError(`Invalid KMSVerifier address '${kmsContractAddress}'.`);
+  }
+
+  let verifyingContractAddressDecryption =
+    options?.gatewayDecryptionVerification;
+  if (!verifyingContractAddressDecryption) {
+    verifyingContractAddressDecryption = getEnv(
+      'DECRYPTION_ADDRESS',
+      `.env.${name}`,
+    );
+  }
+  if (!isChecksummedAddress(kmsContractAddress)) {
+    throwError(`Invalid KMSVerifier address '${kmsContractAddress}'.`);
+  }
+
+  //
+  let chainId = options?.chain;
+  if (!chainId) {
+    chainId = getEnv('CHAIN_ID', `.env.${name}`);
+  }
+  chainId = Number.parseInt(chainId);
+  if (Number.isNaN(chainId)) {
+    throwError(`Invalid chain ID '${chainId}'.`);
+  }
+
+  let gatewayChainId = options?.gatewayChain;
+  if (!gatewayChainId) {
+    gatewayChainId = getEnv('CHAIN_ID_GATEWAY', `.env.${name}`);
+  }
+  gatewayChainId = Number.parseInt(gatewayChainId);
+  if (Number.isNaN(gatewayChainId)) {
+    throwError(`Invalid gateway chain ID '${gatewayChainId}'.`);
+  }
+
+  const mnemonic = options?.mnemonic ?? getEnv('MNEMONIC');
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+  const walletResult = mnemonic ? createWallet({ mnemonic }) : undefined;
+  const wallet = walletResult?.wallet;
+  const signer = wallet?.connect(provider);
+
+  const config = {
+    name: name,
+    version,
+    walletAddress: wallet?.address,
+    userAddress: userAddress ?? wallet?.address,
+    contractAddress,
+    fhevmInstanceConfig: {
+      aclContractAddress,
+      kmsContractAddress,
+      inputVerifierContractAddress,
+      verifyingContractAddressDecryption,
+      verifyingContractAddressInputVerification,
+      chainId,
+      gatewayChainId,
+      network: rpcUrl,
+      relayerUrl,
+    },
+  };
+
+  return { config, provider, wallet, signer };
+}
+
+export function valueColumnTypeListToFheTypedValues(list) {
+  return list.map((str) => {
+    const [valueStr, fheTypeName] = str.split(':');
+    if (!isFheTypeName(fheTypeName)) {
+      throwError(`Invalid FheType name: ${fheTypeName}`);
+    }
+    let value;
+    if (fheTypeName === 'ebool') {
+      value = valueStr === 'true' ? true : false;
+    } else if (fheTypeName === 'eaddress') {
+      value = valueStr;
+    } else if (
+      fheTypeName === 'euint8' ||
+      fheTypeName === 'euint16' ||
+      fheTypeName === 'euint32'
+    ) {
+      value = Number(valueStr);
+    } else {
+      value = BigInt(valueStr);
+      if (value <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        value = Number(value);
+      }
+    }
+    return { fheType: fheTypeName, value };
+  });
+}
+
+export function fheTypedValuesToBuilderFunctionWithArg(fheTypedValues) {
+  return fheTypedValues.map((pair) => {
+    const { value, fheType } = pair;
+    if (!isFheTypeName(fheType)) {
+      throwError(`Invalid FheType name: ${fheType}`);
+    }
+    let funcName;
+    if (fheType === 'ebool') {
+      funcName = 'addBool';
+    } else if (fheType === 'eaddress') {
+      funcName = 'addAddress';
+    } else {
+      const bits = encryptionBitsFromFheTypeName(fheType);
+      funcName = `add${bits}`;
+    }
+    return { funcName, arg: value };
+  });
+}
+
+export function jsonParseFheTypedValues(text) {
+  return JSON.parse(text, (key, value) => {
+    if (value === 'true' || value === true) {
+      return true;
+    }
+    if (value === 'false' || value === true) {
+      return false;
+    }
+    if (typeof value === 'string' && value.startsWith('0x')) {
+      return value;
+    }
+    return BigInt(value);
+  });
+}