@dorafactory/maci-sdk 0.0.34 → 0.0.36

package/dist/index.mjs

@@ -533,30 +533,6 @@ function hexToDecimalString(hexString) {
   const decimalString = BigInt("0x" + hexString).toString(10);
   return decimalString;
 }
-function padWithZerosIfNeeded(inputString) {
-  if (inputString.length === 64) {
-    return inputString;
-  } else if (inputString.length < 64) {
-    const zerosToAdd = 64 - inputString.length;
-    const zeroPadding = "0".repeat(zerosToAdd);
-    return zeroPadding + inputString;
-  }
-  throw new Error("Invalid input string length");
-}
-function decompressPublicKey(compressedPubkey) {
-  const x = compressedPubkey.slice(0, 64);
-  const y = compressedPubkey.slice(64);
-  return {
-    x: hexToDecimalString(x),
-    y: hexToDecimalString(y)
-  };
-}
-function compressPublicKey(decompressedPubkey) {
-  const x = decompressedPubkey[0];
-  const y = decompressedPubkey[1];
-  const compressedPubkey = padWithZerosIfNeeded(x.toString(16)) + padWithZerosIfNeeded(y.toString(16));
-  return compressedPubkey;
-}
 
 // src/libs/query/operator.ts
 var Operator = class {
@@ -1122,9 +1098,9 @@ var Round = class {
         }
       }
       const results = JSON.parse(response.data.round.results);
-      const votes = results.map((r) => ({
-        v: Number(r.slice(0, -24)),
-        v2: Number(r.slice(-24))
+      const votes = results.map((r2) => ({
+        v: Number(r2.slice(0, -24)),
+        v2: Number(r2.slice(-24))
       }));
       const totalVotes = votes.reduce(
         (s, c) => ({
@@ -4193,6 +4169,585 @@ function getAMaciRoundCircuitFee(maxVoter, maxOption) {
   return requiredFee;
 }
 
+// src/libs/crypto/keys.ts
+import { randomBytes as randomBytes2 } from "crypto";
+
+// src/libs/crypto/bigintUtils.ts
+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 bigInt2Buffer = (i) => {
+  let hex = i.toString(16);
+  if (hex.length % 2 === 1) {
+    hex = "0" + hex;
+  }
+  return Buffer.from(hex, "hex");
+};
+
+// src/libs/crypto/keys.ts
+import { poseidonEncrypt } from "@zk-kit/poseidon-cipher";
+import * as BabyJub from "@zk-kit/baby-jubjub";
+import {
+  derivePublicKey,
+  signMessage,
+  deriveSecretScalar
+} from "@zk-kit/eddsa-poseidon";
+import { solidityPackedSha256 as solidityPackedSha2562 } from "ethers";
+import { mulPointEscalar as mulPointEscalar2 } from "@zk-kit/baby-jubjub";
+import { packPublicKey, unpackPublicKey } from "@zk-kit/eddsa-poseidon";
+
+// src/libs/crypto/babyjub.ts
+import assert2 from "assert";
+import { randomBytes } from "crypto";
+
+// src/libs/crypto/constants.ts
+import { r } from "@zk-kit/baby-jubjub";
+import { keccak256, toUtf8Bytes } from "ethers";
+import assert from "assert";
+var SNARK_FIELD_SIZE = r;
+var NOTHING_UP_MY_SLEEVE = BigInt(keccak256(toUtf8Bytes("Maci"))) % SNARK_FIELD_SIZE;
+assert(
+  NOTHING_UP_MY_SLEEVE === BigInt(
+    "8370432830353022751713833565135785980866757267633941821328460903436894336785"
+  )
+);
+var PAD_KEY_HASH = BigInt(
+  "1309255631273308531193241901289907343161346846555918942743921933037802809814"
+);
+
+// src/libs/crypto/babyjub.ts
+var G1Point = class {
+  /**
+   * Create a new instance of G1Point
+   * @param x the x coordinate
+   * @param y the y coordinate
+   */
+  constructor(x, y) {
+    assert2(x < SNARK_FIELD_SIZE && x >= 0, "G1Point x out of range");
+    assert2(y < SNARK_FIELD_SIZE && y >= 0, "G1Point y out of range");
+    this.x = x;
+    this.y = y;
+  }
+  /**
+   * Check whether two points are equal
+   * @param pt the point to compare with
+   * @returns whether they are equal or not
+   */
+  equals(pt) {
+    return this.x === pt.x && this.y === pt.y;
+  }
+  /**
+   * Return the point as a contract param in the form of an object
+   * @returns the point as a contract param
+   */
+  asContractParam() {
+    return {
+      x: this.x.toString(),
+      y: this.y.toString()
+    };
+  }
+};
+var G2Point = class {
+  /**
+   * Create a new instance of G2Point
+   * @param x the x coordinate
+   * @param y the y coordinate
+   */
+  constructor(x, y) {
+    this.checkPointsRange(x, "x");
+    this.checkPointsRange(y, "y");
+    this.x = x;
+    this.y = y;
+  }
+  /**
+   * Check whether two points are equal
+   * @param pt the point to compare with
+   * @returns whether they are equal or not
+   */
+  equals(pt) {
+    return this.x[0] === pt.x[0] && this.x[1] === pt.x[1] && this.y[0] === pt.y[0] && this.y[1] === pt.y[1];
+  }
+  /**
+   * Return the point as a contract param in the form of an object
+   * @returns the point as a contract param
+   */
+  asContractParam() {
+    return {
+      x: this.x.map((n) => n.toString()),
+      y: this.y.map((n) => n.toString())
+    };
+  }
+  /**
+   * Check whether the points are in range
+   * @param x the x coordinate
+   * @param type the type of the coordinate
+   */
+  checkPointsRange(x, type) {
+    assert2(
+      x.every((n) => n < SNARK_FIELD_SIZE && n >= 0),
+      `G2Point ${type} out of range`
+    );
+  }
+};
+var genRandomBabyJubValue = () => {
+  const min = BigInt("6350874878119819312338956282401532410528162663560392320966563075034087161851");
+  let privKey = SNARK_FIELD_SIZE;
+  do {
+    const rand = BigInt(`0x${randomBytes(32).toString("hex")}`);
+    if (rand >= min) {
+      privKey = rand % SNARK_FIELD_SIZE;
+    }
+  } while (privKey >= SNARK_FIELD_SIZE);
+  return privKey;
+};
+
+// src/libs/crypto/hashing.ts
+import { poseidonPerm } from "@zk-kit/poseidon-cipher";
+import { solidityPackedSha256 } from "ethers";
+import assert3 from "assert";
+var sha256Hash = (input) => {
+  const types = [];
+  input.forEach(() => {
+    types.push("uint256");
+  });
+  return BigInt(
+    solidityPackedSha256(
+      types,
+      input.map((x) => x.toString())
+    )
+  ) % SNARK_FIELD_SIZE;
+};
+var poseidon = (inputs) => poseidonPerm([BigInt(0), ...inputs.map((x) => BigInt(x))])[0];
+var poseidonT3 = (inputs) => {
+  assert3(inputs.length === 2);
+  return poseidon(inputs);
+};
+var poseidonT4 = (inputs) => {
+  assert3(inputs.length === 3);
+  return poseidon(inputs);
+};
+var poseidonT5 = (inputs) => {
+  assert3(inputs.length === 4);
+  return poseidon(inputs);
+};
+var poseidonT6 = (inputs) => {
+  assert3(inputs.length === 5);
+  return poseidon(inputs);
+};
+var hashLeftRight = (left, right) => poseidonT3([left, right]);
+var funcs = {
+  2: poseidonT3,
+  3: poseidonT4,
+  4: poseidonT5,
+  5: poseidonT6
+};
+var hashN = (numElements, elements) => {
+  const elementLength = elements.length;
+  if (elements.length > numElements) {
+    throw new TypeError(
+      `the length of the elements array should be at most ${numElements}; got ${elements.length}`
+    );
+  }
+  const elementsPadded = elements.slice();
+  if (elementLength < numElements) {
+    for (let i = elementLength; i < numElements; i += 1) {
+      elementsPadded.push(BigInt(0));
+    }
+  }
+  return funcs[numElements](elementsPadded);
+};
+var hashLeanIMT = (a, b) => hashN(2, [a, b]);
+var hash2 = (elements) => hashN(2, elements);
+var hash3 = (elements) => hashN(3, elements);
+var hash4 = (elements) => hashN(4, elements);
+var hash5 = (elements) => hashN(5, elements);
+var hash12 = (elements) => {
+  const max = 12;
+  const elementLength = elements.length;
+  if (elementLength > max) {
+    throw new TypeError(
+      `the length of the elements array should be at most ${max}; got ${elements.length}`
+    );
+  }
+  const elementsPadded = elements.slice();
+  if (elementLength < max) {
+    for (let i = elementLength; i < max; i += 1) {
+      elementsPadded.push(BigInt(0));
+    }
+  }
+  return poseidonT5([
+    poseidonT6(elementsPadded.slice(0, 5)),
+    poseidonT6(elementsPadded.slice(5, 10)),
+    elementsPadded[10],
+    elementsPadded[11]
+  ]);
+};
+var hashOne = (preImage) => poseidonT3([preImage, BigInt(0)]);
+
+// src/libs/crypto/tree.ts
+var Tree = class _Tree {
+  constructor(degree, depth, zero) {
+    this.DEPTH = depth;
+    this.HEIGHT = depth + 1;
+    this.DEGREE = degree;
+    this.LEAVES_COUNT = degree ** depth;
+    this.LEAVES_IDX_0 = (degree ** depth - 1) / (degree - 1);
+    this.NODES_COUNT = (degree ** (depth + 1) - 1) / (degree - 1);
+    this.initZero(zero);
+    this.initNodes();
+  }
+  get root() {
+    return this.nodes[0];
+  }
+  async initZero(zero) {
+    this.zeros = new Array(this.HEIGHT);
+    this.zeros[0] = zero;
+    for (let i = 1; i < this.zeros.length; i++) {
+      this.zeros[i] = await poseidon([this.zeros[i - 1], this.zeros[i - 1]]);
+    }
+  }
+  async initNodes() {
+    const DEGREE = this.DEGREE;
+    this.nodes = new Array(this.NODES_COUNT);
+    for (let d = this.DEPTH; d >= 0; d--) {
+      const size = DEGREE ** d;
+      const idx0 = (DEGREE ** d - 1) / (DEGREE - 1);
+      const zero = this.zeros[this.DEPTH - d];
+      for (let i = 0; i < size; i++) {
+        this.nodes[idx0 + i] = zero;
+      }
+    }
+  }
+  initLeaves(leaves) {
+    const DEGREE = this.DEGREE;
+    for (let i = 0; i < leaves.length; i++) {
+      if (i >= this.LEAVES_COUNT) {
+        console.error("OVERFLOW");
+        break;
+      }
+      this.nodes[this.LEAVES_IDX_0 + i] = BigInt(leaves[i]);
+    }
+    for (let d = this.DEPTH - 1; d >= 0; d--) {
+      const size = DEGREE ** d;
+      const idx0 = (DEGREE ** d - 1) / (DEGREE - 1);
+      for (let i = 0; i < size / DEGREE; i++) {
+        const start = (idx0 + i) * DEGREE + 1;
+        const children = this.nodes.slice(start, start + DEGREE);
+        this.nodes[idx0 + i] = poseidon(children);
+      }
+    }
+  }
+  leaf(leafIdx) {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error("wrong leaf index");
+    }
+    const nodeIdx = this.LEAVES_IDX_0 + leafIdx;
+    return this.nodes[nodeIdx];
+  }
+  leaves() {
+    return this.nodes.slice(this.LEAVES_IDX_0);
+  }
+  updateLeaf(leafIdx, leaf) {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error("wrong leaf index");
+    }
+    const nodeIdx = this.LEAVES_IDX_0 + leafIdx;
+    this.nodes[nodeIdx] = leaf;
+    this._update(nodeIdx);
+  }
+  pathIdxOf(leafIdx) {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error("wrong leaf index");
+    }
+    let idx = this.LEAVES_IDX_0 + leafIdx;
+    const pathIdx = [];
+    for (let i = 0; i < this.DEPTH; i++) {
+      const parentIdx = Math.floor((idx - 1) / this.DEGREE);
+      const childrenIdx0 = parentIdx * this.DEGREE + 1;
+      pathIdx.push(idx - childrenIdx0);
+      idx = parentIdx;
+    }
+    return pathIdx;
+  }
+  pathElementOf(leafIdx) {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error("wrong leaf index");
+    }
+    let idx = this.LEAVES_IDX_0 + leafIdx;
+    const pathElement = [];
+    for (let h = 0; h < this.DEPTH; h++) {
+      const parentIdx = Math.floor((idx - 1) / this.DEGREE);
+      const childrenIdx0 = parentIdx * this.DEGREE + 1;
+      const el = [];
+      for (let i = childrenIdx0; i < childrenIdx0 + this.DEGREE; i++) {
+        if (i === idx) continue;
+        el.push(this.nodes[i]);
+      }
+      pathElement.push(el);
+      idx = parentIdx;
+    }
+    return pathElement;
+  }
+  subTree(length) {
+    const subTree = new _Tree(this.DEGREE, this.DEPTH, this.zeros[0]);
+    const nodes = [...this.nodes];
+    const DEGREE = this.DEGREE;
+    let tail = length;
+    for (let d = this.DEPTH; d >= 0; d--) {
+      const size = DEGREE ** d;
+      const idx0 = (DEGREE ** d - 1) / (DEGREE - 1);
+      const zero = this.zeros[this.DEPTH - d];
+      for (let i = tail; i < size; i++) {
+        nodes[idx0 + i] = zero;
+      }
+      tail = Math.ceil(tail / DEGREE);
+    }
+    subTree.nodes = nodes;
+    subTree._update(this.LEAVES_IDX_0 + length - 1);
+    return subTree;
+  }
+  async _update(nodeIdx) {
+    let idx = nodeIdx;
+    while (idx > 0) {
+      const parentIdx = Math.floor((idx - 1) / this.DEGREE);
+      const childrenIdx0 = parentIdx * this.DEGREE + 1;
+      this.nodes[parentIdx] = await poseidon(
+        this.nodes.slice(childrenIdx0, childrenIdx0 + this.DEGREE)
+      );
+      idx = parentIdx;
+    }
+  }
+};
+var tree_default = Tree;
+
+// src/libs/crypto/keys.ts
+var SNARK_FIELD_SIZE2 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+var genPrivKey = () => BigInt(`0x${randomBytes2(32).toString("hex")}`);
+var genRandomSalt = () => genRandomBabyJubValue();
+var formatPrivKeyForBabyJub = (privKey) => BigInt(deriveSecretScalar(bigInt2Buffer(privKey)));
+var packPubKey = (pubKey) => BigInt(packPublicKey(pubKey));
+var unpackPubKey = (packed) => {
+  const pubKey = unpackPublicKey(packed);
+  return pubKey.map((x) => BigInt(x));
+};
+var genPubKey = (privKey) => {
+  const key = derivePublicKey(bigInt2Buffer(privKey));
+  return [BigInt(key[0]), BigInt(key[1])];
+};
+var genKeypair = (pkey) => {
+  const privKey = pkey ? pkey % SNARK_FIELD_SIZE2 : genPrivKey();
+  const pubKey = genPubKey(privKey);
+  const formatedPrivKey = formatPrivKeyForBabyJub(privKey);
+  const keypair = { privKey, pubKey, formatedPrivKey };
+  return keypair;
+};
+var genEcdhSharedKey = (privKey, pubKey) => mulPointEscalar2(pubKey, formatPrivKeyForBabyJub(privKey));
+var genMessageFactory = (stateIdx, signPriKey, signPubKey, coordPubKey) => (encPriKey, nonce, voIdx, newVotes, isLastCmd, salt) => {
+  if (!salt) {
+    salt = BigInt("0x" + randomBytes2(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 = signMessage(bigInt2Buffer(signPriKey), hash);
+  const command = [packaged, ...newPubKey, ...signature.R8, signature.S];
+  const message = poseidonEncrypt(
+    command,
+    genEcdhSharedKey(encPriKey, coordPubKey),
+    0n
+  );
+  return message;
+};
+var batchGenMessage = (stateIdx, keypair, coordPubKey, plan) => {
+  const genMessage = genMessageFactory(
+    stateIdx,
+    BigInt(keypair.privKey),
+    keypair.pubKey,
+    coordPubKey
+  );
+  const payload = [];
+  for (let i = plan.length - 1; i >= 0; i--) {
+    const p = plan[i];
+    const encAccount = genKeypair();
+    const msg = genMessage(
+      BigInt(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_SIZE2);
+};
+var rerandomize = (pubKey, ciphertext, randomVal = genRandomSalt()) => {
+  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 = genRandomSalt();
+  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([
+    BigInt(oldKey.formatedPrivKey),
+    1444992409218394441042n
+  ]);
+  const tree = new tree_default(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(
+    solidityPackedSha2562(
+      new Array(7).fill("uint256"),
+      stringizing([
+        deactivateRoot,
+        poseidon(coordPubKey),
+        nullifier,
+        d1[0],
+        d1[1],
+        d2[0],
+        d2[1]
+      ])
+    )
+  ) % SNARK_FIELD_SIZE2;
+  const input = {
+    inputHash,
+    coordPubKey,
+    deactivateRoot,
+    deactivateIndex: deactivateIdx,
+    deactivateLeaf: poseidon(deactivateLeaf),
+    c1,
+    c2,
+    randomVal,
+    d1,
+    d2,
+    deactivateLeafPathElements,
+    nullifier,
+    oldPrivateKey: oldKey.formatedPrivKey
+  };
+  return input;
+};
+
+// src/libs/crypto/sign.ts
+import {
+  isOfflineDirectSigner
+} from "@cosmjs/proto-signing";
+async function signMessage2(signer, address, message, network) {
+  const accounts = await signer.getAccounts();
+  const account = accounts.find((acc) => acc.address === address);
+  const chainId = getDefaultParams(network).chainId;
+  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,
+      accountNumber: BigInt(0)
+    };
+    const { signature } = await signer.signDirect(address, signDoc);
+    return {
+      signature: signature.signature,
+      pubkey: account.pubkey
+    };
+  } else {
+    const signDoc = {
+      chain_id: 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 function genKeypairFromSignature(signature) {
+  const sign = BigInt("0x" + Buffer.from(signature, "base64").toString("hex"));
+  return genKeypair(sign);
+}
+async function genKeypairFromSign({
+  signer,
+  address,
+  network
+}) {
+  if (!address) {
+    [{ address }] = await signer.getAccounts();
+  }
+  const sig = await signMessage2(
+    signer,
+    address,
+    "Generate_MACI_Private_Key",
+    network
+  );
+  return genKeypairFromSignature(sig.signature);
+}
+
 // src/libs/contract/contract.ts
 var Contract = class {
   constructor({
@@ -4292,7 +4847,9 @@ var Contract = class {
     const end_time = (endVoting.getTime() * 10 ** 6).toString();
     const [{ address }] = await signer.getAccounts();
     const client = await createContractClientByWallet(this.rpcEndpoint, signer);
-    const { x: operatorPubkeyX, y: operatorPubkeyY } = decompressPublicKey(operatorPubkey);
+    const [operatorPubkeyX, operatorPubkeyY] = unpackPubKey(
+      BigInt(operatorPubkey)
+    );
     const {
       parameters,
       groth16ProcessVkey,
@@ -4319,8 +4876,8 @@ var Contract = class {
         },
         parameters,
         coordinator: {
-          x: operatorPubkeyX,
-          y: operatorPubkeyY
+          x: operatorPubkeyX.toString(),
+          y: operatorPubkeyY.toString()
         },
         groth16_process_vkey: groth16ProcessVkey,
         groth16_tally_vkey: groth16TallyVkey,
@@ -4355,7 +4912,9 @@ var Contract = class {
     const end_time = (endVoting.getTime() * 1e6).toString();
     const [{ address }] = await signer.getAccounts();
     const client = await createContractClientByWallet(this.rpcEndpoint, signer);
-    const { x: operatorPubkeyX, y: operatorPubkeyY } = decompressPublicKey(operatorPubkey);
+    const [operatorPubkeyX, operatorPubkeyY] = unpackPubKey(
+      BigInt(operatorPubkey)
+    );
     const { maciVoteType, maciCertSystem } = getContractParams(
       "2" /* ORACLE_MACI */,
       circuitType,
@@ -4373,8 +4932,8 @@ var Contract = class {
           end_time
         },
         coordinator: {
-          x: operatorPubkeyX,
-          y: operatorPubkeyY
+          x: operatorPubkeyX.toString(),
+          y: operatorPubkeyY.toString()
         },
         vote_option_map: voteOptionMap,
         whitelist_backend_pubkey: this.whitelistBackendPubkey,
@@ -4497,280 +5056,6 @@ var OracleCertificate = class {
   }
 };
 
-// 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) {
-    if (typeof window !== "undefined" && window.keplr) {
-      const sig = await window.keplr.signArbitrary(
-        this.chainId,
-        address,
-        message
-      );
-      return {
-        signature: sig.signature,
-        pubkey: sig.pub_key.value
-      };
-    }
-    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/libs/maci/maci.ts
 import { GasPrice as GasPrice2, calculateFee } from "@cosmjs/stargate";
 import { MsgExecuteContract } from "cosmjs-types/cosmwasm/wasm/v1/tx.js";
@@ -4779,15 +5064,15 @@ function isErrorResponse(response) {
 }
 var MACI = class {
   constructor({
-    circom,
     contract,
     indexer,
-    oracleCertificate
+    oracleCertificate,
+    maciKeypair
   }) {
-    this.circom = circom;
     this.contract = contract;
     this.indexer = indexer;
     this.oracleCertificate = oracleCertificate;
+    this.maciKeypair = maciKeypair;
   }
   async getStateIdxInc({
     signer,
@@ -4905,8 +5190,8 @@ var MACI = class {
         contractAddress
       });
       const balance = await client.whiteBalanceOf({
-        amount: address,
-        certificate,
+        amount: certificate.amount,
+        certificate: certificate.signature,
         sender: address
       });
       return balance;
@@ -5077,7 +5362,7 @@ var MACI = class {
     signer,
     address,
     contractAddress,
-    maciAccount,
+    maciKeypair,
     oracleCertificate,
     gasStation = false
   }) {
@@ -5085,8 +5370,8 @@ var MACI = class {
       if (!address) {
         address = (await signer.getAccounts())[0].address;
       }
-      if (maciAccount === void 0) {
-        maciAccount = await this.circom.genKeypairFromSign(signer, address);
+      if (maciKeypair === void 0) {
+        maciKeypair = this.maciKeypair;
       }
       const client = await this.contract.contractClient({
         signer
@@ -5095,7 +5380,7 @@ var MACI = class {
         return await this.signupOracle({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           oracleCertificate,
           gasStation
@@ -5104,7 +5389,7 @@ var MACI = class {
         return await this.signupSimple({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           gasStation
         });
@@ -5142,7 +5427,7 @@ var MACI = class {
     contractAddress,
     selectedOptions,
     operatorCoordPubKey,
-    maciAccount,
+    maciKeypair,
     gasStation = false
   }) {
     if (stateIdx === -1) {
@@ -5162,15 +5447,15 @@ var MACI = class {
       if (!address) {
         address = (await signer.getAccounts())[0].address;
       }
-      if (maciAccount === void 0) {
-        maciAccount = await this.circom.genKeypairFromSign(signer, address);
+      if (maciKeypair === void 0) {
+        maciKeypair = this.maciKeypair;
       }
       const plan = options.map((o) => {
         return [o.idx, o.vc];
       });
       const payload = batchGenMessage(
         stateIdx,
-        maciAccount,
+        maciKeypair,
         operatorCoordPubKey,
         plan
       );
@@ -5465,6 +5750,7 @@ var MaciClient2 = class {
    * @param {ClientParams} params - The parameters for the Maci Client instance.
    */
   constructor({
+    signer,
     network,
     rpcEndpoint,
     restEndpoint,
@@ -5476,8 +5762,11 @@ var MaciClient2 = class {
     defaultOptions,
     feegrantOperator,
     whitelistBackendPubkey,
-    certificateApiEndpoint
+    certificateApiEndpoint,
+    maciKeypair
   }) {
+    this.signer = signer;
+    this.network = network;
     const defaultParams = getDefaultParams(network);
     this.rpcEndpoint = rpcEndpoint || defaultParams.rpcEndpoint;
     this.restEndpoint = restEndpoint || defaultParams.restEndpoint;
@@ -5488,6 +5777,7 @@ var MaciClient2 = class {
     this.oracleCodeId = oracleCodeId || defaultParams.oracleCodeId;
     this.feegrantOperator = feegrantOperator || defaultParams.oracleFeegrantOperator;
     this.whitelistBackendPubkey = whitelistBackendPubkey || defaultParams.oracleWhitelistBackendPubkey;
+    this.maciKeypair = maciKeypair ?? genKeypair();
     this.http = new Http(
       this.apiEndpoint,
       this.restEndpoint,
@@ -5508,22 +5798,41 @@ var MaciClient2 = class {
       feegrantOperator: this.feegrantOperator,
       whitelistBackendPubkey: this.whitelistBackendPubkey
     });
-    this.circom = new Circom({ network });
     this.oracleCertificate = new OracleCertificate({
       certificateApiEndpoint: this.certificateApiEndpoint,
       http: this.http
     });
     this.maci = new MACI({
-      circom: this.circom,
       contract: this.contract,
       indexer: this.indexer,
-      oracleCertificate: this.oracleCertificate
+      oracleCertificate: this.oracleCertificate,
+      maciKeypair: this.maciKeypair
     });
   }
+  getSigner(signer) {
+    return signer || this.signer;
+  }
+  getMaciKeypair() {
+    return this.maciKeypair;
+  }
+  getMaciPubkey() {
+    return this.packMaciPubkey(this.maciKeypair.pubKey);
+  }
+  packMaciPubkey(pubkey) {
+    return packPubKey(pubkey || this.maciKeypair.pubKey);
+  }
+  unpackMaciPubkey(pubkey) {
+    return unpackPubKey(BigInt(pubkey));
+  }
+  async getAddress(signer) {
+    const [{ address }] = await this.getSigner(signer).getAccounts();
+    return address;
+  }
   async oracleMaciClient({
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.contract.oracleMaciClient({
       signer,
       contractAddress
@@ -5533,28 +5842,50 @@ var MaciClient2 = class {
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.contract.registryClient({ signer, contractAddress });
   }
   async maciClient({
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.contract.maciClient({ signer, contractAddress });
   }
   async amaciClient({
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.contract.amaciClient({ signer, contractAddress });
   }
   async createAMaciRound(params) {
-    return await this.contract.createAMaciRound(params);
+    return await this.contract.createAMaciRound({
+      signer: this.getSigner(),
+      ...params
+    });
   }
   async createMaciRound(params) {
-    return await this.contract.createMaciRound(params);
+    return await this.contract.createMaciRound({
+      signer: this.getSigner(),
+      ...params
+    });
   }
   async createOracleMaciRound(params) {
-    return await this.contract.createOracleMaciRound(params);
+    return await this.contract.createOracleMaciRound({
+      signer: this.getSigner(),
+      ...params
+    });
+  }
+  async genKeypairFromSign({
+    signer,
+    address
+  } = {}) {
+    return await genKeypairFromSign({
+      signer: this.getSigner(signer),
+      address,
+      network: this.network
+    });
   }
   async getStateIdxInc({
     signer,
@@ -5562,7 +5893,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getStateIdxInc({
-      signer,
+      signer: this.getSigner(signer),
       address,
       contractAddress
     });
@@ -5573,7 +5904,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getVoiceCreditBalance({
-      signer,
+      signer: this.getSigner(signer),
       stateIdx,
       contractAddress
     });
@@ -5588,18 +5919,22 @@ var MaciClient2 = class {
     });
   }
   async feegrantAllowance({
+    signer,
     address,
     contractAddress
   }) {
+    address = await this.getAddress(signer);
     return await this.maci.feegrantAllowance({
       address,
       contractAddress
     });
   }
   async hasFeegrant({
+    signer,
     address,
     contractAddress
   }) {
+    address = await this.getAddress(signer);
     return await this.maci.hasFeegrant({
       address,
       contractAddress
@@ -5612,6 +5947,10 @@ var MaciClient2 = class {
     certificate,
     mode = "maci"
   }) {
+    signer = this.getSigner(signer);
+    if (!address) {
+      address = await this.getAddress(signer);
+    }
     return await this.maci.queryWhitelistBalanceOf({
       signer,
       address,
@@ -5625,6 +5964,10 @@ var MaciClient2 = class {
     address,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
+    if (!address) {
+      address = await this.getAddress(signer);
+    }
     return await this.maci.isWhitelisted({
       signer,
       address,
@@ -5636,7 +5979,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getOracleWhitelistConfig({
-      signer,
+      signer: this.getSigner(signer),
       contractAddress
     });
   }
@@ -5684,7 +6027,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.requestOracleCertificate({
-      signer,
+      signer: this.getSigner(signer),
       ecosystem,
       address,
       contractAddress
@@ -5694,15 +6037,15 @@ var MaciClient2 = class {
     signer,
     address,
     contractAddress,
-    maciAccount,
+    maciKeypair,
     oracleCertificate,
     gasStation = false
   }) {
     return await this.maci.signup({
-      signer,
+      signer: this.getSigner(signer),
       address,
       contractAddress,
-      maciAccount,
+      maciKeypair,
       oracleCertificate,
       gasStation
     });
@@ -5714,32 +6057,17 @@ var MaciClient2 = class {
     contractAddress,
     selectedOptions,
     operatorCoordPubKey,
-    maciAccount,
+    maciKeypair,
     gasStation = false
   }) {
     return await this.maci.vote({
-      signer,
+      signer: this.getSigner(signer),
       address,
       stateIdx,
       contractAddress,
       selectedOptions,
       operatorCoordPubKey,
-      maciAccount,
-      gasStation
-    });
-  }
-  async publishMessage({
-    client,
-    address,
-    payload,
-    contractAddress,
-    gasStation
-  }) {
-    return await this.maci.publishMessage({
-      client,
-      address,
-      payload,
-      contractAddress,
+      maciKeypair,
       gasStation
     });
   }
@@ -5747,6 +6075,7 @@ var MaciClient2 = class {
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.maci.claimAMaciRound({
       signer,
       contractAddress
@@ -5761,8 +6090,11 @@ var MaciClient2 = class {
     address,
     amount
   }) {
+    if (!address) {
+      address = await this.getAddress(signer);
+    }
     return await this.maci.batchGrantWithBond({
-      signer,
+      signer: this.getSigner(signer),
       contractAddress,
       address,
       amount
@@ -5773,22 +6105,22 @@ var MaciClient2 = class {
     contractAddress,
     address
   }) {
+    if (!address) {
+      address = await this.getAddress(signer);
+    }
     return await this.maci.batchRevokeWithdraw({
-      signer,
+      signer: this.getSigner(signer),
       contractAddress,
       address
     });
   }
 };
-
-// src/index.ts
-import { Scalar as Scalar2, utils as utils2 } from "ffjavascript";
-import { default as default2 } from "blake-hash";
 export {
-  Circom,
   Circuit,
   Contract,
   Event,
+  G1Point,
+  G2Point,
   Http,
   Indexer,
   MACI,
@@ -5796,28 +6128,53 @@ export {
   MaciCircuitType,
   MaciClient2 as MaciClient,
   MaciRoundType,
+  NOTHING_UP_MY_SLEEVE,
   Operator,
   OracleCertificate,
+  PAD_KEY_HASH,
   Proof,
   Round,
-  Scalar2 as Scalar,
+  SNARK_FIELD_SIZE,
   Transaction,
+  Tree,
   UserAccount,
   batchGenMessage,
+  bigInt2Buffer,
   circuits,
-  compressPublicKey,
-  default2 as createBlakeHash,
-  decompressPublicKey,
+  formatPrivKeyForBabyJub,
   genAddKeyProof,
   genEcdhSharedKey,
   genKeypair,
+  genKeypairFromSign,
+  genKeypairFromSignature,
   genMessageFactory,
+  genPrivKey,
+  genPubKey,
+  genRandomBabyJubValue,
+  genRandomSalt,
   getDefaultParams,
+  hash12,
+  hash2,
+  hash3,
+  hash4,
+  hash5,
+  hashLeanIMT,
+  hashLeftRight,
+  hashN,
+  hashOne,
   hexToDecimalString,
   isValidAddress,
+  packPubKey,
+  poseidon,
+  poseidonT3,
+  poseidonT4,
+  poseidonT5,
+  poseidonT6,
   privateKeyFromTxt,
+  sha256Hash,
+  signMessage2 as signMessage,
   stringizing,
-  utils2 as utils,
+  unpackPubKey,
   validator_operator_set
 };
 //# sourceMappingURL=index.mjs.map