@dorafactory/maci-sdk 0.0.51 → 0.0.53

package/dist/libs/crypto/babyjub.d.ts

@@ -61,13 +61,4 @@ export declare class G2Point {
      */
     private checkPointsRange;
 }
-/**
- * Returns a BabyJub-compatible random value. We create it by first generating
- * a random value (initially 256 bits large) modulo the snark field size as
- * described in EIP197. This results in a key size of roughly 253 bits and no
- * more than 254 bits. To prevent modulo bias, we then use this efficient
- * algorithm:
- * http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/lib/libc/crypt/arc4random_uniform.c
- * @returns A BabyJub-compatible random value.
- */
 export declare const genRandomBabyJubValue: () => bigint;

package/dist/libs/crypto/tree.d.ts

@@ -1,23 +1,22 @@
 export declare class Tree {
-    private DEPTH;
-    private HEIGHT;
-    private DEGREE;
-    private LEAVES_COUNT;
-    private LEAVES_IDX_0;
-    private NODES_COUNT;
-    private zeros;
-    private nodes;
+    readonly DEPTH: number;
+    readonly HEIGHT: number;
+    readonly DEGREE: number;
+    readonly LEAVES_COUNT: number;
+    readonly LEAVES_IDX_0: number;
+    readonly NODES_COUNT: number;
+    protected nodes: bigint[];
+    protected zeros: bigint[];
     constructor(degree: number, depth: number, zero: bigint);
     get root(): bigint;
-    private initZero;
-    private initNodes;
-    initLeaves(leaves: (bigint | string | number)[]): void;
+    initZero(zero: bigint): void;
+    initNodes(): void;
+    initLeaves(leaves: bigint[]): void;
     leaf(leafIdx: number): bigint;
     leaves(): bigint[];
     updateLeaf(leafIdx: number, leaf: bigint): void;
-    pathIdxOf(leafIdx: number): number[];
+    pathIdxOf(leafIdx: number): bigint[];
     pathElementOf(leafIdx: number): bigint[][];
     subTree(length: number): Tree;
-    private _update;
+    protected _update(nodeIdx: number): void;
 }
-export default Tree;

package/dist/maci.d.ts

@@ -113,6 +113,19 @@ export declare class MaciClient {
         signer?: OfflineSigner;
         contractAddress: string;
     }): Promise<OracleWhitelistConfig>;
+    getRounds(after?: string, limit?: number): Promise<import("./types").SuccessResponse<{
+        rounds: {
+            pageInfo: {
+                endCursor: string;
+                hasNextPage: boolean;
+            };
+            edges: {
+                cursor: string;
+                node: import("./types").RoundType;
+            }[];
+            totalCount: number;
+        };
+    }>>;
     getRoundInfo({ contractAddress }: {
         contractAddress: string;
     }): Promise<import("./types").RoundType>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorafactory/maci-sdk",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "SDK for interacting with maci",
   "keywords": [
     "maci",

package/src/libs/crypto/babyjub.ts

@@ -108,34 +108,57 @@ export class G2Point {
   }
 }
 
-/**
- * Returns a BabyJub-compatible random value. We create it by first generating
- * a random value (initially 256 bits large) modulo the snark field size as
- * described in EIP197. This results in a key size of roughly 253 bits and no
- * more than 254 bits. To prevent modulo bias, we then use this efficient
- * algorithm:
- * http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/lib/libc/crypt/arc4random_uniform.c
- * @returns A BabyJub-compatible random value.
- */
-export const genRandomBabyJubValue = (): bigint => {
+// /**
+//  * Returns a BabyJub-compatible random value. We create it by first generating
+//  * a random value (initially 256 bits large) modulo the snark field size as
+//  * described in EIP197. This results in a key size of roughly 253 bits and no
+//  * more than 254 bits. To prevent modulo bias, we then use this efficient
+//  * algorithm:
+//  * http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/lib/libc/crypt/arc4random_uniform.c
+//  * @returns A BabyJub-compatible random value.
+//  */
+// export const genRandomBabyJubValue = (): bigint => {
+//   // Prevent modulo bias
+//   // const lim = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000')
+//   // const min = (lim - SNARK_FIELD_SIZE) % SNARK_FIELD_SIZE
+//   const min = BigInt(
+//     '6350874878119819312338956282401532410528162663560392320966563075034087161851'
+//   );
+
+//   let privKey: PrivKey = SNARK_FIELD_SIZE;
+
+//   do {
+//     const rand = BigInt(
+//       `0x${CryptoJS.lib.WordArray.random(32).toString(CryptoJS.enc.Hex)}`
+//     );
+
+//     if (rand >= min) {
+//       privKey = rand % SNARK_FIELD_SIZE;
+//     }
+//   } while (privKey >= SNARK_FIELD_SIZE);
+//    privKey =
+//   return privKey;
+// };
+
+export const genRandomBabyJubValue = () => {
   // Prevent modulo bias
-  // const lim = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000')
-  // const min = (lim - SNARK_FIELD_SIZE) % SNARK_FIELD_SIZE
-  const min = BigInt(
-    '6350874878119819312338956282401532410528162663560392320966563075034087161851'
-  );
-
-  let privKey: PrivKey = SNARK_FIELD_SIZE;
-
-  do {
-    const rand = BigInt(
+  //const lim = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000')
+  //const min = (lim - SNARK_FIELD_SIZE) % SNARK_FIELD_SIZE
+  const min =
+    6350874878119819312338956282401532410528162663560392320966563075034087161851n;
+
+  let rand;
+  while (true) {
+    rand = BigInt(
       `0x${CryptoJS.lib.WordArray.random(32).toString(CryptoJS.enc.Hex)}`
     );
 
     if (rand >= min) {
-      privKey = rand % SNARK_FIELD_SIZE;
+      break;
     }
-  } while (privKey >= SNARK_FIELD_SIZE);
+  }
 
+  // const privKey = rand % SNARK_FIELD_SIZE;
+  const privKey = rand % 2n ** 253n;
   return privKey;
 };

package/src/libs/crypto/keys.ts

@@ -14,10 +14,10 @@ import { solidityPackedSha256 } from 'ethers';
 import { mulPointEscalar } from '@zk-kit/baby-jubjub';
 import { packPublicKey, unpackPublicKey } from '@zk-kit/eddsa-poseidon';
 
-import { genRandomBabyJubValue } from './babyjub';
 import { EcdhSharedKey, Keypair, PrivKey, PubKey } from './types';
 import { poseidon } from './hashing';
-import Tree from './tree';
+import { Tree } from './tree';
+import { genRandomBabyJubValue } from './babyjub';
 
 const SNARK_FIELD_SIZE =
   21888242871839275222246405745257275088548364400416034343698204186575808495617n;

package/src/libs/crypto/tree.ts

@@ -1,14 +1,15 @@
 import { poseidon } from './hashing';
 
 export class Tree {
-  private DEPTH: number;
-  private HEIGHT: number;
-  private DEGREE: number;
-  private LEAVES_COUNT: number;
-  private LEAVES_IDX_0: number;
-  private NODES_COUNT: number;
-  private zeros!: bigint[];
-  private nodes!: bigint[];
+  public readonly DEPTH: number;
+  public readonly HEIGHT: number;
+  public readonly DEGREE: number;
+  public readonly LEAVES_COUNT: number;
+  public readonly LEAVES_IDX_0: number;
+  public readonly NODES_COUNT: number;
+
+  protected nodes: bigint[] = [];
+  protected zeros: bigint[] = [];
 
   constructor(degree: number, depth: number, zero: bigint) {
     this.DEPTH = depth;
@@ -23,34 +24,38 @@ export class Tree {
     this.initNodes();
   }
 
-  get root(): bigint {
+  get root() {
     return this.nodes[0];
   }
 
-  private async initZero(zero: bigint): Promise<void> {
-    this.zeros = new Array<bigint>(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]]);
+  initZero(zero: bigint) {
+    const zeros = new Array(this.HEIGHT);
+    zeros[0] = zero;
+    for (let i = 1; i < zeros.length; i++) {
+      const children = new Array(this.DEGREE).fill(zeros[i - 1]);
+      zeros[i] = poseidon(children);
     }
+    this.zeros = zeros;
   }
 
-  private async initNodes(): Promise<void> {
+  initNodes() {
     const DEGREE = this.DEGREE;
 
-    this.nodes = new Array<bigint>(this.NODES_COUNT);
+    const 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;
+        nodes[idx0 + i] = zero;
       }
     }
+
+    this.nodes = nodes;
   }
 
-  initLeaves(leaves: (bigint | string | number)[]): void {
+  initLeaves(leaves: bigint[]) {
     const DEGREE = this.DEGREE;
     for (let i = 0; i < leaves.length; i++) {
       if (i >= this.LEAVES_COUNT) {
@@ -71,7 +76,7 @@ export class Tree {
     }
   }
 
-  leaf(leafIdx: number): bigint {
+  leaf(leafIdx: number) {
     if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
       throw new Error('wrong leaf index');
     }
@@ -79,11 +84,11 @@ export class Tree {
     return this.nodes[nodeIdx];
   }
 
-  leaves(): bigint[] {
+  leaves() {
     return this.nodes.slice(this.LEAVES_IDX_0);
   }
 
-  updateLeaf(leafIdx: number, leaf: bigint): void {
+  updateLeaf(leafIdx: number, leaf: bigint) {
     if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
       throw new Error('wrong leaf index');
     }
@@ -93,18 +98,18 @@ export class Tree {
     this._update(nodeIdx);
   }
 
-  pathIdxOf(leafIdx: number): number[] {
+  pathIdxOf(leafIdx: number) {
     if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
       throw new Error('wrong leaf index');
     }
     let idx = this.LEAVES_IDX_0 + leafIdx;
-    const pathIdx: number[] = [];
+    const pathIdx: bigint[] = [];
 
     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);
+      pathIdx.push(BigInt(idx - childrenIdx0));
 
       idx = parentIdx;
     }
@@ -112,7 +117,7 @@ export class Tree {
     return pathIdx;
   }
 
-  pathElementOf(leafIdx: number): bigint[][] {
+  pathElementOf(leafIdx: number) {
     if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
       throw new Error('wrong leaf index');
     }
@@ -137,7 +142,7 @@ export class Tree {
     return pathElement;
   }
 
-  subTree(length: number): Tree {
+  subTree(length: number) {
     const subTree = new Tree(this.DEGREE, this.DEPTH, this.zeros[0]);
     const nodes = [...this.nodes];
 
@@ -159,18 +164,16 @@ export class Tree {
     return subTree;
   }
 
-  private async _update(nodeIdx: number): Promise<void> {
+  protected _update(nodeIdx: number) {
     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)
+      this.nodes[parentIdx] = poseidon(
+        this.nodes.slice(childrenIdx0, childrenIdx0 + 5)
       );
 
       idx = parentIdx;
     }
   }
 }
-
-export default Tree;

package/src/maci.ts

@@ -19,6 +19,7 @@ import { OracleWhitelistConfig } from './libs/contract/ts/OracleMaci.types';
 import { SignatureResponse } from './libs/oracle-certificate/types';
 import { StdFee } from '@cosmjs/amino';
 import { Groth16ProofType } from './libs/contract/ts/Maci.types';
+import { isErrorResponse } from './libs/maci/maci';
 
 /**
  * @class MaciClient
@@ -365,6 +366,18 @@ export class MaciClient {
     });
   }
 
+  async getRounds(after?: string, limit?: number) {
+    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 }: { contractAddress: string }) {
     return await this.maci.getRoundInfo({ contractAddress });
   }