@dorafactory/maci-sdk 0.0.6 → 0.0.8

package/dist/index.d.ts

@@ -5,9 +5,12 @@ export * from './libs/const';
 export { MaciClient } from './maci';
 export { Http } from './libs/http';
 export { Round } from './libs/query';
-export { Account } from './libs/query';
+export { UserAccount } from './libs/query';
 export { Circuit } from './libs/query';
 export { Operator } from './libs/query';
 export { Proof } from './libs/query';
 export { Transaction } from './libs/query';
+export * from './libs/circom';
 export * from './utils';
+export { Scalar, utils } from 'ffjavascript';
+export { default as createBlakeHash } from 'blake-hash';

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,12 +17,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Account: () => Account,
+  Circom: () => Circom,
   Circuit: () => Circuit,
   Contract: () => Contract,
   Http: () => Http,
@@ -32,13 +42,24 @@ __export(src_exports, {
   Operator: () => Operator,
   Proof: () => Proof,
   Round: () => Round,
+  Scalar: () => import_ffjavascript2.Scalar,
   Transaction: () => Transaction,
+  UserAccount: () => UserAccount,
+  batchGenMessage: () => batchGenMessage,
   circuits: () => circuits,
   compressPublicKey: () => compressPublicKey,
+  createBlakeHash: () => import_blake_hash2.default,
   decompressPublicKey: () => decompressPublicKey,
+  genAddKeyProof: () => genAddKeyProof,
+  genEcdhSharedKey: () => genEcdhSharedKey,
+  genKeypair: () => genKeypair,
+  genMessageFactory: () => genMessageFactory,
   getDefaultParams: () => getDefaultParams,
   hexToDecimalString: () => hexToDecimalString,
   isValidAddress: () => isValidAddress,
+  privateKeyFromTxt: () => privateKeyFromTxt,
+  stringizing: () => stringizing,
+  utils: () => import_ffjavascript2.utils,
   validator_operator_set: () => validator_operator_set
 });
 module.exports = __toCommonJS(src_exports);
@@ -277,7 +298,7 @@ var ERROR = {
 };
 
 // src/libs/query/account.ts
-var Account = class {
+var UserAccount = class {
   constructor(http) {
     this.http = http;
   }
@@ -1483,7 +1504,7 @@ var Indexer = class {
     this.apiEndpoint = apiEndpoint;
     this.registryAddress = registryAddress;
     this.round = new Round(this.http);
-    this.account = new Account(this.http);
+    this.account = new UserAccount(this.http);
     this.circuit = new Circuit(this.http);
     this.operator = new Operator(this.http, this.registryAddress);
     this.proof = new Proof(this.http);
@@ -3711,10 +3732,17 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
         // plonkTallyVkey,
       };
     case "2" /* ORACLE_MACI */:
+      if (circuitType === "0" /* IP1V */) {
+        groth16ProcessVkey = CIRCUIT_INFO["9-4-3-625"]["groth16"].process_1p1v_vkey;
+        groth16TallyVkey = CIRCUIT_INFO["9-4-3-625"]["groth16"].tally_1p1v_vkey;
+      } else if (circuitType === "1" /* QV */) {
+        groth16ProcessVkey = CIRCUIT_INFO["9-4-3-625"]["groth16"].process_qv_vkey;
+        groth16TallyVkey = CIRCUIT_INFO["9-4-3-625"]["groth16"].tally_qv_vkey;
+      }
       return {
         parameters: CIRCUIT_INFO["9-4-3-625"].parameter,
-        groth16ProcessVkey: CIRCUIT_INFO["9-4-3-625"]["groth16"].process_vkey,
-        groth16TallyVkey: CIRCUIT_INFO["9-4-3-625"]["groth16"].tally_vkey,
+        groth16ProcessVkey,
+        groth16TallyVkey,
         plonkProcessVkey: null,
         plonkTallyVkey: null,
         maciVoteType,
@@ -3980,6 +4008,264 @@ var Contract = class {
       contractAddress
     });
   }
+  async contractClient({ signer }) {
+    return createContractClientByWallet(this.rpcEndpoint, signer);
+  }
+};
+
+// src/libs/circom/index.ts
+var import_proto_signing = require("@cosmjs/proto-signing");
+
+// src/libs/circom/circomlib.ts
+var import_crypto = require("crypto");
+var import_circomlib = require("@dorafactory/circomlib");
+var import_ffjavascript = require("ffjavascript");
+var import_blake_hash = __toESM(require("blake-hash"));
+var import_ethers = require("ethers");
+var SNARK_FIELD_SIZE = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var bigInt2Buffer = (i) => {
+  let hex = i.toString(16);
+  if (hex.length % 2 === 1) {
+    hex = "0" + hex;
+  }
+  return Buffer.from(hex, "hex");
+};
+var genRandomKey = () => {
+  const min = 6350874878119819312338956282401532410528162663560392320966563075034087161851n;
+  let rand;
+  while (true) {
+    rand = BigInt("0x" + (0, import_crypto.randomBytes)(32).toString("hex"));
+    if (rand >= min) {
+      break;
+    }
+  }
+  const privKey = rand % SNARK_FIELD_SIZE;
+  return privKey;
+};
+var genPubKey = (privKey) => {
+  return import_circomlib.eddsa.prv2pub(bigInt2Buffer(privKey));
+};
+var stringizing = (o, path = []) => {
+  if (path.includes(o)) {
+    throw new Error("loop nesting!");
+  }
+  const newPath = [...path, o];
+  if (Array.isArray(o)) {
+    return o.map((item) => stringizing(item, newPath));
+  } else if (typeof o === "object") {
+    const output = {};
+    for (const key in o) {
+      output[key] = stringizing(o[key], newPath);
+    }
+    return output;
+  } else {
+    return o.toString();
+  }
+};
+var genKeypair = (pkey) => {
+  const privKey = pkey ? pkey % SNARK_FIELD_SIZE : genRandomKey();
+  const pubKey = genPubKey(privKey);
+  const formatedPrivKey = formatPrivKeyForBabyJub(privKey);
+  return { privKey, pubKey, formatedPrivKey };
+};
+var formatPrivKeyForBabyJub = (privKey) => {
+  const sBuff = import_circomlib.eddsa.pruneBuffer(
+    (0, import_blake_hash.default)("blake512").update(bigInt2Buffer(privKey)).digest().slice(0, 32)
+  );
+  const s = import_ffjavascript.utils.leBuff2int(sBuff);
+  return import_ffjavascript.Scalar.shr(s, 3);
+};
+var genEcdhSharedKey = (privKey, pubKey) => {
+  const sharedKey = import_circomlib.babyJub.mulPointEscalar(
+    pubKey,
+    formatPrivKeyForBabyJub(privKey)
+  );
+  if (sharedKey[0] === 0n) {
+    return [0n, 1n];
+  } else {
+    return sharedKey;
+  }
+};
+var genMessageFactory = (stateIdx, signPriKey, signPubKey, coordPubKey) => (encPriKey, nonce, voIdx, newVotes, isLastCmd, salt) => {
+  if (!salt) {
+    salt = BigInt("0x" + (0, import_crypto.randomBytes)(7).toString("hex"));
+  }
+  const packaged = BigInt(nonce) + (BigInt(stateIdx) << 32n) + (BigInt(voIdx) << 64n) + (BigInt(newVotes) << 96n) + (BigInt(salt) << 192n);
+  let newPubKey = [...signPubKey];
+  if (isLastCmd) {
+    newPubKey = [0n, 0n];
+  }
+  const hash = (0, import_circomlib.poseidon)([packaged, ...newPubKey]);
+  const signature = import_circomlib.eddsa.signPoseidon(bigInt2Buffer(signPriKey), hash);
+  const command = [packaged, ...newPubKey, ...signature.R8, signature.S];
+  const message = (0, import_circomlib.poseidonEncrypt)(
+    command,
+    genEcdhSharedKey(encPriKey, coordPubKey),
+    0n
+  );
+  return message;
+};
+var batchGenMessage = (stateIdx, account, coordPubKey, plan) => {
+  const genMessage = genMessageFactory(
+    stateIdx,
+    account.privKey,
+    account.pubKey,
+    coordPubKey
+  );
+  const payload = [];
+  for (let i = plan.length - 1; i >= 0; i--) {
+    const p = plan[i];
+    const encAccount = genKeypair();
+    const msg = genMessage(
+      encAccount.privKey,
+      i + 1,
+      p[0],
+      p[1],
+      i === plan.length - 1
+    );
+    payload.push({
+      msg,
+      encPubkeys: encAccount.pubKey
+    });
+  }
+  return payload;
+};
+var privateKeyFromTxt = (txt) => {
+  if (typeof txt !== "string") {
+    return;
+  }
+  const key = txt.split("\n")[1] || "";
+  if (key.length !== 512) {
+    return;
+  }
+  const keys = key.match(/[0-9a-f]{128}/g);
+  if (!keys || keys.length !== 4) {
+    return;
+  }
+  const priKey = (0, import_circomlib.poseidon)(keys.map((k) => BigInt("0x" + k)));
+  return genKeypair(priKey % SNARK_FIELD_SIZE);
+};
+var rerandomize = (pubKey, ciphertext, randomVal = genRandomKey()) => {
+  const d1 = import_circomlib.babyJub.addPoint(
+    import_circomlib.babyJub.mulPointEscalar(import_circomlib.babyJub.Base8, randomVal),
+    ciphertext.c1
+  );
+  const d2 = import_circomlib.babyJub.addPoint(
+    import_circomlib.babyJub.mulPointEscalar(pubKey, randomVal),
+    ciphertext.c2
+  );
+  return {
+    d1,
+    d2
+  };
+};
+var genAddKeyProof = async (depth, {
+  coordPubKey,
+  oldKey,
+  deactivates
+}) => {
+  const sharedKeyHash = (0, import_circomlib.poseidon)(genEcdhSharedKey(oldKey.privKey, coordPubKey));
+  const randomVal = genRandomKey();
+  const deactivateIdx = deactivates.findIndex((d) => d[4] === sharedKeyHash);
+  if (deactivateIdx < 0) {
+    return null;
+  }
+  const deactivateLeaf = deactivates[deactivateIdx];
+  const c1 = [deactivateLeaf[0], deactivateLeaf[1]];
+  const c2 = [deactivateLeaf[2], deactivateLeaf[3]];
+  const { d1, d2 } = rerandomize(coordPubKey, { c1, c2 }, randomVal);
+  const nullifier = (0, import_circomlib.poseidon)([oldKey.formatedPrivKey, 1444992409218394441042n]);
+  const tree = new import_circomlib.Tree(5, depth, 0n);
+  const leaves = deactivates.map((d) => (0, import_circomlib.poseidon)(d));
+  tree.initLeaves(leaves);
+  const deactivateRoot = tree.root;
+  const deactivateLeafPathElements = tree.pathElementOf(deactivateIdx);
+  const inputHash = BigInt(
+    (0, import_ethers.solidityPackedSha256)(
+      new Array(7).fill("uint256"),
+      stringizing([
+        deactivateRoot,
+        (0, import_circomlib.poseidon)(coordPubKey),
+        nullifier,
+        d1[0],
+        d1[1],
+        d2[0],
+        d2[1]
+      ])
+    )
+  ) % SNARK_FIELD_SIZE;
+  const input = {
+    inputHash,
+    coordPubKey,
+    deactivateRoot,
+    deactivateIndex: deactivateIdx,
+    deactivateLeaf: (0, import_circomlib.poseidon)(deactivateLeaf),
+    c1,
+    c2,
+    randomVal,
+    d1,
+    d2,
+    deactivateLeafPathElements,
+    nullifier,
+    oldPrivateKey: oldKey.formatedPrivKey
+  };
+  return input;
+};
+
+// src/libs/circom/index.ts
+var Circom = class {
+  constructor({ network }) {
+    this.network = network;
+    this.chainId = getDefaultParams(network).chainId;
+  }
+  async signMessage(signer, address, message) {
+    const accounts = await signer.getAccounts();
+    const account = accounts.find((acc) => acc.address === address);
+    if (!account) {
+      throw new Error(`Address ${address} not found in wallet`);
+    }
+    if ((0, import_proto_signing.isOfflineDirectSigner)(signer)) {
+      const signDoc = {
+        bodyBytes: new TextEncoder().encode(message),
+        authInfoBytes: new Uint8Array(),
+        chainId: this.chainId,
+        accountNumber: BigInt(0)
+      };
+      const { signature } = await signer.signDirect(address, signDoc);
+      return {
+        signature: signature.signature,
+        pubkey: account.pubkey
+      };
+    } else {
+      const signDoc = {
+        chain_id: this.chainId,
+        account_number: "0",
+        sequence: "0",
+        fee: {
+          gas: "0",
+          amount: []
+        },
+        msgs: [],
+        memo: message
+      };
+      const { signature } = await signer.signAmino(address, signDoc);
+      return {
+        signature: signature.signature,
+        pubkey: account.pubkey
+      };
+    }
+  }
+  async genKeypairFromSign(signer, address) {
+    const sig = await this.signMessage(
+      signer,
+      address,
+      "Generate_MACI_Private_Key"
+    );
+    const sign = BigInt(
+      "0x" + Buffer.from(sig.signature, "base64").toString("hex")
+    );
+    return genKeypair(sign);
+  }
 };
 
 // src/maci.ts
@@ -4030,6 +4316,7 @@ var MaciClient2 = class {
       feegrantOperator: this.feegrantOperator,
       whitelistBackendPubkey: this.whitelistBackendPubkey
     });
+    this.circom = new Circom({ network });
   }
   async oracleMaciClient({
     signer,
@@ -4208,9 +4495,13 @@ var MaciClient2 = class {
     return await this.indexer.proof.getProofByContractAddress(address);
   }
 };
+
+// src/index.ts
+var import_ffjavascript2 = require("ffjavascript");
+var import_blake_hash2 = __toESM(require("blake-hash"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Account,
+  Circom,
   Circuit,
   Contract,
   Http,
@@ -4222,13 +4513,24 @@ var MaciClient2 = class {
   Operator,
   Proof,
   Round,
+  Scalar,
   Transaction,
+  UserAccount,
+  batchGenMessage,
   circuits,
   compressPublicKey,
+  createBlakeHash,
   decompressPublicKey,
+  genAddKeyProof,
+  genEcdhSharedKey,
+  genKeypair,
+  genMessageFactory,
   getDefaultParams,
   hexToDecimalString,
   isValidAddress,
+  privateKeyFromTxt,
+  stringizing,
+  utils,
   validator_operator_set
 });
 //# sourceMappingURL=index.js.map