@dorafactory/maci-sdk 0.0.6 → 0.0.7

package/dist/index.mjs

@@ -232,7 +232,7 @@ var ERROR = {
 };
 
 // src/libs/query/account.ts
-var Account = class {
+var UserAccount = class {
   constructor(http) {
     this.http = http;
   }
@@ -1438,7 +1438,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);
@@ -3673,8 +3673,8 @@ function getContractParams(type, circuitType, proofSystem, maxVoter, maxOption)
     case "2" /* ORACLE_MACI */:
       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,
@@ -3940,6 +3940,272 @@ var Contract = class {
       contractAddress
     });
   }
+  async contractClient({ signer }) {
+    return createContractClientByWallet(this.rpcEndpoint, signer);
+  }
+};
+
+// src/libs/circom/index.ts
+import {
+  isOfflineDirectSigner
+} from "@cosmjs/proto-signing";
+
+// src/libs/circom/circomlib.ts
+import { randomBytes } from "crypto";
+import {
+  babyJub,
+  eddsa,
+  poseidon,
+  poseidonEncrypt,
+  Tree
+} from "@dorafactory/circomlib";
+import { Scalar, utils } from "ffjavascript";
+import createBlakeHash from "blake-hash";
+import { solidityPackedSha256 } from "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" + randomBytes(32).toString("hex"));
+    if (rand >= min) {
+      break;
+    }
+  }
+  const privKey = rand % SNARK_FIELD_SIZE;
+  return privKey;
+};
+var genPubKey = (privKey) => {
+  return 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 = eddsa.pruneBuffer(
+    createBlakeHash("blake512").update(bigInt2Buffer(privKey)).digest().slice(0, 32)
+  );
+  const s = utils.leBuff2int(sBuff);
+  return Scalar.shr(s, 3);
+};
+var genEcdhSharedKey = (privKey, pubKey) => {
+  const sharedKey = 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" + 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 = poseidon([packaged, ...newPubKey]);
+  const signature = eddsa.signPoseidon(bigInt2Buffer(signPriKey), hash);
+  const command = [packaged, ...newPubKey, ...signature.R8, signature.S];
+  const message = 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 = poseidon(keys.map((k) => BigInt("0x" + k)));
+  return genKeypair(priKey % SNARK_FIELD_SIZE);
+};
+var rerandomize = (pubKey, ciphertext, randomVal = genRandomKey()) => {
+  const d1 = babyJub.addPoint(
+    babyJub.mulPointEscalar(babyJub.Base8, randomVal),
+    ciphertext.c1
+  );
+  const d2 = babyJub.addPoint(
+    babyJub.mulPointEscalar(pubKey, randomVal),
+    ciphertext.c2
+  );
+  return {
+    d1,
+    d2
+  };
+};
+var genAddKeyProof = async (depth, {
+  coordPubKey,
+  oldKey,
+  deactivates
+}) => {
+  const sharedKeyHash = 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 = poseidon([oldKey.formatedPrivKey, 1444992409218394441042n]);
+  const tree = new Tree(5, depth, 0n);
+  const leaves = deactivates.map((d) => poseidon(d));
+  tree.initLeaves(leaves);
+  const deactivateRoot = tree.root;
+  const deactivateLeafPathElements = tree.pathElementOf(deactivateIdx);
+  const inputHash = BigInt(
+    solidityPackedSha256(
+      new Array(7).fill("uint256"),
+      stringizing([
+        deactivateRoot,
+        poseidon(coordPubKey),
+        nullifier,
+        d1[0],
+        d1[1],
+        d2[0],
+        d2[1]
+      ])
+    )
+  ) % SNARK_FIELD_SIZE;
+  const input = {
+    inputHash,
+    coordPubKey,
+    deactivateRoot,
+    deactivateIndex: deactivateIdx,
+    deactivateLeaf: 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 (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
@@ -3990,6 +4256,7 @@ var MaciClient2 = class {
       feegrantOperator: this.feegrantOperator,
       whitelistBackendPubkey: this.whitelistBackendPubkey
     });
+    this.circom = new Circom({ network });
   }
   async oracleMaciClient({
     signer,
@@ -4168,8 +4435,12 @@ var MaciClient2 = class {
     return await this.indexer.proof.getProofByContractAddress(address);
   }
 };
+
+// src/index.ts
+import { Scalar as Scalar2, utils as utils2 } from "ffjavascript";
+import { default as default2 } from "blake-hash";
 export {
-  Account,
+  Circom,
   Circuit,
   Contract,
   Http,
@@ -4181,13 +4452,24 @@ export {
   Operator,
   Proof,
   Round,
+  Scalar2 as Scalar,
   Transaction,
+  UserAccount,
+  batchGenMessage,
   circuits,
   compressPublicKey,
+  default2 as createBlakeHash,
   decompressPublicKey,
+  genAddKeyProof,
+  genEcdhSharedKey,
+  genKeypair,
+  genMessageFactory,
   getDefaultParams,
   hexToDecimalString,
   isValidAddress,
+  privateKeyFromTxt,
+  stringizing,
+  utils2 as utils,
   validator_operator_set
 };
 //# sourceMappingURL=index.mjs.map