@dorafactory/maci-sdk 0.0.35 → 0.0.36

package/dist/index.js

@@ -30,10 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Circom: () => Circom,
   Circuit: () => Circuit,
   Contract: () => Contract,
   Event: () => Event,
+  G1Point: () => G1Point,
+  G2Point: () => G2Point,
   Http: () => Http,
   Indexer: () => Indexer,
   MACI: () => MACI,
@@ -41,28 +42,53 @@ __export(index_exports, {
   MaciCircuitType: () => MaciCircuitType,
   MaciClient: () => MaciClient2,
   MaciRoundType: () => MaciRoundType,
+  NOTHING_UP_MY_SLEEVE: () => NOTHING_UP_MY_SLEEVE,
   Operator: () => Operator,
   OracleCertificate: () => OracleCertificate,
+  PAD_KEY_HASH: () => PAD_KEY_HASH,
   Proof: () => Proof,
   Round: () => Round,
-  Scalar: () => import_ffjavascript2.Scalar,
+  SNARK_FIELD_SIZE: () => SNARK_FIELD_SIZE,
   Transaction: () => Transaction,
+  Tree: () => Tree,
   UserAccount: () => UserAccount,
   batchGenMessage: () => batchGenMessage,
+  bigInt2Buffer: () => bigInt2Buffer,
   circuits: () => circuits,
-  compressPublicKey: () => compressPublicKey,
-  createBlakeHash: () => import_blake_hash2.default,
-  decompressPublicKey: () => decompressPublicKey,
+  formatPrivKeyForBabyJub: () => formatPrivKeyForBabyJub,
   genAddKeyProof: () => genAddKeyProof,
   genEcdhSharedKey: () => genEcdhSharedKey,
   genKeypair: () => genKeypair,
+  genKeypairFromSign: () => genKeypairFromSign,
+  genKeypairFromSignature: () => genKeypairFromSignature,
   genMessageFactory: () => genMessageFactory,
+  genPrivKey: () => genPrivKey,
+  genPubKey: () => genPubKey,
+  genRandomBabyJubValue: () => genRandomBabyJubValue,
+  genRandomSalt: () => genRandomSalt,
   getDefaultParams: () => getDefaultParams,
+  hash12: () => hash12,
+  hash2: () => hash2,
+  hash3: () => hash3,
+  hash4: () => hash4,
+  hash5: () => hash5,
+  hashLeanIMT: () => hashLeanIMT,
+  hashLeftRight: () => hashLeftRight,
+  hashN: () => hashN,
+  hashOne: () => hashOne,
   hexToDecimalString: () => hexToDecimalString,
   isValidAddress: () => isValidAddress,
+  packPubKey: () => packPubKey,
+  poseidon: () => poseidon,
+  poseidonT3: () => poseidonT3,
+  poseidonT4: () => poseidonT4,
+  poseidonT5: () => poseidonT5,
+  poseidonT6: () => poseidonT6,
   privateKeyFromTxt: () => privateKeyFromTxt,
+  sha256Hash: () => sha256Hash,
+  signMessage: () => signMessage2,
   stringizing: () => stringizing,
-  utils: () => import_ffjavascript2.utils,
+  unpackPubKey: () => unpackPubKey,
   validator_operator_set: () => validator_operator_set
 });
 module.exports = __toCommonJS(index_exports);
@@ -602,30 +628,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 {
@@ -1191,9 +1193,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) => ({
@@ -4257,6 +4259,579 @@ function getAMaciRoundCircuitFee(maxVoter, maxOption) {
   return requiredFee;
 }
 
+// src/libs/crypto/keys.ts
+var import_crypto2 = require("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
+var import_poseidon_cipher2 = require("@zk-kit/poseidon-cipher");
+var BabyJub = __toESM(require("@zk-kit/baby-jubjub"));
+var import_eddsa_poseidon = require("@zk-kit/eddsa-poseidon");
+var import_ethers3 = require("ethers");
+var import_baby_jubjub2 = require("@zk-kit/baby-jubjub");
+var import_eddsa_poseidon2 = require("@zk-kit/eddsa-poseidon");
+
+// src/libs/crypto/babyjub.ts
+var import_assert2 = __toESM(require("assert"));
+var import_crypto = require("crypto");
+
+// src/libs/crypto/constants.ts
+var import_baby_jubjub = require("@zk-kit/baby-jubjub");
+var import_ethers = require("ethers");
+var import_assert = __toESM(require("assert"));
+var SNARK_FIELD_SIZE = import_baby_jubjub.r;
+var NOTHING_UP_MY_SLEEVE = BigInt((0, import_ethers.keccak256)((0, import_ethers.toUtf8Bytes)("Maci"))) % SNARK_FIELD_SIZE;
+(0, import_assert.default)(
+  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) {
+    (0, import_assert2.default)(x < SNARK_FIELD_SIZE && x >= 0, "G1Point x out of range");
+    (0, import_assert2.default)(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) {
+    (0, import_assert2.default)(
+      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${(0, import_crypto.randomBytes)(32).toString("hex")}`);
+    if (rand >= min) {
+      privKey = rand % SNARK_FIELD_SIZE;
+    }
+  } while (privKey >= SNARK_FIELD_SIZE);
+  return privKey;
+};
+
+// src/libs/crypto/hashing.ts
+var import_poseidon_cipher = require("@zk-kit/poseidon-cipher");
+var import_ethers2 = require("ethers");
+var import_assert3 = __toESM(require("assert"));
+var sha256Hash = (input) => {
+  const types = [];
+  input.forEach(() => {
+    types.push("uint256");
+  });
+  return BigInt(
+    (0, import_ethers2.solidityPackedSha256)(
+      types,
+      input.map((x) => x.toString())
+    )
+  ) % SNARK_FIELD_SIZE;
+};
+var poseidon = (inputs) => (0, import_poseidon_cipher.poseidonPerm)([BigInt(0), ...inputs.map((x) => BigInt(x))])[0];
+var poseidonT3 = (inputs) => {
+  (0, import_assert3.default)(inputs.length === 2);
+  return poseidon(inputs);
+};
+var poseidonT4 = (inputs) => {
+  (0, import_assert3.default)(inputs.length === 3);
+  return poseidon(inputs);
+};
+var poseidonT5 = (inputs) => {
+  (0, import_assert3.default)(inputs.length === 4);
+  return poseidon(inputs);
+};
+var poseidonT6 = (inputs) => {
+  (0, import_assert3.default)(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${(0, import_crypto2.randomBytes)(32).toString("hex")}`);
+var genRandomSalt = () => genRandomBabyJubValue();
+var formatPrivKeyForBabyJub = (privKey) => BigInt((0, import_eddsa_poseidon.deriveSecretScalar)(bigInt2Buffer(privKey)));
+var packPubKey = (pubKey) => BigInt((0, import_eddsa_poseidon2.packPublicKey)(pubKey));
+var unpackPubKey = (packed) => {
+  const pubKey = (0, import_eddsa_poseidon2.unpackPublicKey)(packed);
+  return pubKey.map((x) => BigInt(x));
+};
+var genPubKey = (privKey) => {
+  const key = (0, import_eddsa_poseidon.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) => (0, import_baby_jubjub2.mulPointEscalar)(pubKey, formatPrivKeyForBabyJub(privKey));
+var genMessageFactory = (stateIdx, signPriKey, signPubKey, coordPubKey) => (encPriKey, nonce, voIdx, newVotes, isLastCmd, salt) => {
+  if (!salt) {
+    salt = BigInt("0x" + (0, import_crypto2.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 = (0, import_eddsa_poseidon.signMessage)(bigInt2Buffer(signPriKey), hash);
+  const command = [packaged, ...newPubKey, ...signature.R8, signature.S];
+  const message = (0, import_poseidon_cipher2.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(
+    (0, import_ethers3.solidityPackedSha256)(
+      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
+var import_proto_signing = require("@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 ((0, import_proto_signing.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({
@@ -4356,7 +4931,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,
@@ -4383,8 +4960,8 @@ var Contract = class {
         },
         parameters,
         coordinator: {
-          x: operatorPubkeyX,
-          y: operatorPubkeyY
+          x: operatorPubkeyX.toString(),
+          y: operatorPubkeyY.toString()
         },
         groth16_process_vkey: groth16ProcessVkey,
         groth16_tally_vkey: groth16TallyVkey,
@@ -4419,7 +4996,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,
@@ -4437,8 +5016,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,
@@ -4561,272 +5140,6 @@ var OracleCertificate = class {
   }
 };
 
-// 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) {
-    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 ((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/libs/maci/maci.ts
 var import_stargate2 = require("@cosmjs/stargate");
 var import_tx = require("cosmjs-types/cosmwasm/wasm/v1/tx.js");
@@ -4835,15 +5148,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,
@@ -4961,8 +5274,8 @@ var MACI = class {
         contractAddress
       });
       const balance = await client.whiteBalanceOf({
-        amount: address,
-        certificate,
+        amount: certificate.amount,
+        certificate: certificate.signature,
         sender: address
       });
       return balance;
@@ -5133,7 +5446,7 @@ var MACI = class {
     signer,
     address,
     contractAddress,
-    maciAccount,
+    maciKeypair,
     oracleCertificate,
     gasStation = false
   }) {
@@ -5141,8 +5454,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
@@ -5151,7 +5464,7 @@ var MACI = class {
         return await this.signupOracle({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           oracleCertificate,
           gasStation
@@ -5160,7 +5473,7 @@ var MACI = class {
         return await this.signupSimple({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           gasStation
         });
@@ -5198,7 +5511,7 @@ var MACI = class {
     contractAddress,
     selectedOptions,
     operatorCoordPubKey,
-    maciAccount,
+    maciKeypair,
     gasStation = false
   }) {
     if (stateIdx === -1) {
@@ -5218,15 +5531,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
       );
@@ -5521,6 +5834,7 @@ var MaciClient2 = class {
    * @param {ClientParams} params - The parameters for the Maci Client instance.
    */
   constructor({
+    signer,
     network,
     rpcEndpoint,
     restEndpoint,
@@ -5532,8 +5846,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;
@@ -5544,6 +5861,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,
@@ -5564,22 +5882,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
@@ -5589,28 +5926,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,
@@ -5618,7 +5977,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getStateIdxInc({
-      signer,
+      signer: this.getSigner(signer),
       address,
       contractAddress
     });
@@ -5629,7 +5988,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getVoiceCreditBalance({
-      signer,
+      signer: this.getSigner(signer),
       stateIdx,
       contractAddress
     });
@@ -5644,18 +6003,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
@@ -5668,6 +6031,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,
@@ -5681,6 +6048,10 @@ var MaciClient2 = class {
     address,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
+    if (!address) {
+      address = await this.getAddress(signer);
+    }
     return await this.maci.isWhitelisted({
       signer,
       address,
@@ -5692,7 +6063,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.getOracleWhitelistConfig({
-      signer,
+      signer: this.getSigner(signer),
       contractAddress
     });
   }
@@ -5740,7 +6111,7 @@ var MaciClient2 = class {
     contractAddress
   }) {
     return await this.maci.requestOracleCertificate({
-      signer,
+      signer: this.getSigner(signer),
       ecosystem,
       address,
       contractAddress
@@ -5750,15 +6121,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
     });
@@ -5770,17 +6141,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,
+      maciKeypair,
       gasStation
     });
   }
@@ -5788,6 +6159,7 @@ var MaciClient2 = class {
     signer,
     contractAddress
   }) {
+    signer = this.getSigner(signer);
     return await this.maci.claimAMaciRound({
       signer,
       contractAddress
@@ -5802,8 +6174,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
@@ -5814,23 +6189,23 @@ 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
-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 = {
-  Circom,
   Circuit,
   Contract,
   Event,
+  G1Point,
+  G2Point,
   Http,
   Indexer,
   MACI,
@@ -5838,28 +6213,53 @@ var import_blake_hash2 = __toESM(require("blake-hash"));
   MaciCircuitType,
   MaciClient,
   MaciRoundType,
+  NOTHING_UP_MY_SLEEVE,
   Operator,
   OracleCertificate,
+  PAD_KEY_HASH,
   Proof,
   Round,
-  Scalar,
+  SNARK_FIELD_SIZE,
   Transaction,
+  Tree,
   UserAccount,
   batchGenMessage,
+  bigInt2Buffer,
   circuits,
-  compressPublicKey,
-  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,
+  signMessage,
   stringizing,
-  utils,
+  unpackPubKey,
   validator_operator_set
 });
 //# sourceMappingURL=index.js.map