@dorafactory/maci-sdk 0.0.50 → 0.0.52

package/dist/index.js

@@ -570,9 +570,10 @@ 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
+// src/libs/crypto/hashing.ts
+var import_poseidon_cipher = require("@zk-kit/poseidon-cipher");
+var import_ethers2 = require("ethers");
 var import_assert2 = __toESM(require("assert"));
-var import_crypto_js = __toESM(require("crypto-js"));
 
 // src/libs/crypto/constants.ts
 var import_baby_jubjub = require("@zk-kit/baby-jubjub");
@@ -589,100 +590,7 @@ 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${import_crypto_js.default.lib.WordArray.random(32).toString(import_crypto_js.default.enc.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(() => {
@@ -697,19 +605,19 @@ var sha256Hash = (input) => {
 };
 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);
+  (0, import_assert2.default)(inputs.length === 2);
   return poseidon(inputs);
 };
 var poseidonT4 = (inputs) => {
-  (0, import_assert3.default)(inputs.length === 3);
+  (0, import_assert2.default)(inputs.length === 3);
   return poseidon(inputs);
 };
 var poseidonT5 = (inputs) => {
-  (0, import_assert3.default)(inputs.length === 4);
+  (0, import_assert2.default)(inputs.length === 4);
   return poseidon(inputs);
 };
 var poseidonT6 = (inputs) => {
-  (0, import_assert3.default)(inputs.length === 5);
+  (0, import_assert2.default)(inputs.length === 5);
   return poseidon(inputs);
 };
 var hashLeftRight = (left, right) => poseidonT3([left, right]);
@@ -777,14 +685,14 @@ var Tree = class _Tree {
   get root() {
     return this.nodes[0];
   }
-  async initZero(zero) {
+  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]]);
+      this.zeros[i] = poseidon([this.zeros[i - 1], this.zeros[i - 1]]);
     }
   }
-  async initNodes() {
+  initNodes() {
     const DEGREE = this.DEGREE;
     this.nodes = new Array(this.NODES_COUNT);
     for (let d = this.DEPTH; d >= 0; d--) {
@@ -884,12 +792,12 @@ var Tree = class _Tree {
     subTree._update(this.LEAVES_IDX_0 + length - 1);
     return subTree;
   }
-  async _update(nodeIdx) {
+  _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[parentIdx] = poseidon(
         this.nodes.slice(childrenIdx0, childrenIdx0 + this.DEGREE)
       );
       idx = parentIdx;
@@ -898,6 +806,97 @@ var Tree = class _Tree {
 };
 var tree_default = Tree;
 
+// src/libs/crypto/babyjub.ts
+var import_assert3 = __toESM(require("assert"));
+var import_crypto_js = __toESM(require("crypto-js"));
+var G1Point = class {
+  /**
+   * Create a new instance of G1Point
+   * @param x the x coordinate
+   * @param y the y coordinate
+   */
+  constructor(x, y) {
+    (0, import_assert3.default)(x < SNARK_FIELD_SIZE && x >= 0, "G1Point x out of range");
+    (0, import_assert3.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_assert3.default)(
+      x.every((n) => n < SNARK_FIELD_SIZE && n >= 0),
+      `G2Point ${type} out of range`
+    );
+  }
+};
+var genRandomBabyJubValue = () => {
+  const min = 6350874878119819312338956282401532410528162663560392320966563075034087161851n;
+  let rand;
+  while (true) {
+    rand = BigInt(
+      `0x${import_crypto_js.default.lib.WordArray.random(32).toString(import_crypto_js.default.enc.Hex)}`
+    );
+    if (rand >= min) {
+      break;
+    }
+  }
+  const privKey = rand % 2n ** 253n;
+  return privKey;
+};
+
 // src/libs/crypto/keys.ts
 var SNARK_FIELD_SIZE2 = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 var genPrivKey = () => BigInt(`0x${import_crypto_js2.default.lib.WordArray.random(32).toString(import_crypto_js2.default.enc.Hex)}`);
@@ -5772,63 +5771,54 @@ var MACI = class {
     const deactivates = await this.indexer.fetchAllDeactivateLogs(contractAddress);
     return deactivates;
   }
-  // async addNewKey({
-  //   signer,
-  //   client,
-  //   address,
-  //   maciKeypair,
-  //   newMaciKeypair,
-  //   contractAddress,
-  //   gasStation,
-  //   fee,
-  // }: {
-  //   signer: OfflineSigner;
-  //   client: SigningCosmWasmClient;
-  //   address?: string;
-  //   maciKeypair: Keypair;
-  //   newMaciKeypair: Keypair;
-  //   contractAddress: string;
-  //   gasStation: boolean;
-  //   fee?: StdFee;
-  // }) {
-  //   const deactivates = await this.fetchAllDeactivateLogs({
-  //     contractAddress,
-  //   });
-  //   const roundInfo = await this.getRoundInfo({
-  //     contractAddress,
-  //   });
-  //   const inputObj = await genAddKeyProof(4, {
-  //     coordPubKey: [
-  //       BigInt(roundInfo.coordinatorPubkeyX),
-  //       BigInt(roundInfo.coordinatorPubkeyY),
-  //     ],
-  //     oldKey: maciKeypair,
-  //     deactivates: deactivates.map((d: any) => d.map(BigInt)),
-  //   });
-  //   if (!inputObj) {
-  //     throw new Error('Failed to generate add key proof');
-  //   }
-  //   const amaciClient = await this.contract.amaciClient({
-  //     signer,
-  //     contractAddress,
-  //   });
-  //   const d = [
-  //     inputObj.c1[0].toString(),
-  //     inputObj.c1[1].toString(),
-  //     inputObj.c2[0].toString(),
-  //     inputObj.c2[1].toString(),
-  //   ];
-  //   const result = await amaciClient.addNewKey({
-  //     d: d,
-  //     groth16Proof: inputObj.proof,
-  //     nullifier: inputObj.nullifier.toString(),
-  //     pubkey: {
-  //       x: newMaciKeypair.pubKey[0].toString(),
-  //       y: newMaciKeypair.pubKey[1].toString(),
-  //     },
-  //   });
-  //   return result;
-  // }
+  async genAddKeyInput({
+    maciKeypair,
+    contractAddress
+  }) {
+    const deactivates = await this.fetchAllDeactivateLogs({
+      contractAddress
+    });
+    const roundInfo = await this.getRoundInfo({
+      contractAddress
+    });
+    const circuitPower = roundInfo.circuitPower;
+    const stateTreeDepth = Number(circuitPower.split("-")[0]);
+    const inputObj = genAddKeyInput(stateTreeDepth + 2, {
+      coordPubKey: [
+        BigInt(roundInfo.coordinatorPubkeyX),
+        BigInt(roundInfo.coordinatorPubkeyY)
+      ],
+      oldKey: maciKeypair,
+      deactivates: deactivates.map((d) => d.map(BigInt))
+    });
+    return inputObj;
+  }
+  async addNewKey({
+    signer,
+    contractAddress,
+    d,
+    proof,
+    nullifier,
+    newMaciKeypair,
+    fee = "auto"
+  }) {
+    const client = await this.contract.amaciClient({
+      signer,
+      contractAddress
+    });
+    return await client.addNewKey(
+      {
+        d,
+        groth16Proof: proof,
+        nullifier: nullifier.toString(),
+        pubkey: {
+          x: newMaciKeypair.pubKey[0].toString(),
+          y: newMaciKeypair.pubKey[1].toString()
+        }
+      },
+      fee
+    );
+  }
   async claimAMaciRound({
     signer,
     contractAddress,
@@ -6212,6 +6202,15 @@ var MaciClient2 = class {
       contractAddress
     });
   }
+  async getRounds(after, limit) {
+    const rounds = await this.indexer.getRounds(after || "", limit || 10);
+    if (isErrorResponse(rounds)) {
+      throw new Error(
+        `Failed to get rounds: ${rounds.code} ${rounds.error.message}`
+      );
+    }
+    return rounds;
+  }
   async getRoundInfo({ contractAddress }) {
     return await this.maci.getRoundInfo({ contractAddress });
   }
@@ -6319,6 +6318,34 @@ var MaciClient2 = class {
       fee
     });
   }
+  async genAddKeyInput({
+    contractAddress,
+    maciKeypair
+  }) {
+    return await this.maci.genAddKeyInput({
+      maciKeypair: maciKeypair || this.maciKeypair,
+      contractAddress
+    });
+  }
+  async addNewKey({
+    signer,
+    contractAddress,
+    d,
+    proof,
+    nullifier,
+    newMaciKeypair,
+    fee = "auto"
+  }) {
+    return await this.maci.addNewKey({
+      signer: this.getSigner(signer),
+      contractAddress,
+      d,
+      proof,
+      nullifier,
+      newMaciKeypair,
+      fee
+    });
+  }
   async claimAMaciRound({
     signer,
     contractAddress,