@dorafactory/maci-sdk 0.0.35 → 0.0.36

package/src/libs/crypto/sign.ts

@@ -0,0 +1,91 @@
+import {
+  OfflineSigner,
+  OfflineDirectSigner,
+  isOfflineDirectSigner,
+} from '@cosmjs/proto-signing';
+import { StdSignDoc } from '@cosmjs/amino';
+import { SignDoc } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { getDefaultParams } from '../const';
+import { genKeypair } from './keys';
+import { SignResult } from './types';
+
+export async function signMessage(
+  signer: OfflineSigner,
+  address: string,
+  message: string,
+  network: 'mainnet' | 'testnet'
+): Promise<SignResult> {
+  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)) {
+    // Direct
+    const signDoc: 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 {
+    // Amino
+    const signDoc: StdSignDoc = {
+      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,
+    };
+  }
+}
+
+export async function genKeypairFromSignature(signature: string) {
+  const sign = BigInt('0x' + Buffer.from(signature, 'base64').toString('hex'));
+
+  return genKeypair(sign);
+}
+
+export async function genKeypairFromSign({
+  signer,
+  address,
+  network,
+}: {
+  signer: OfflineSigner;
+  address?: string;
+  network: 'mainnet' | 'testnet';
+}) {
+  if (!address) {
+    [{ address }] = await signer.getAccounts();
+  }
+
+  const sig = await signMessage(
+    signer,
+    address,
+    'Generate_MACI_Private_Key',
+    network
+  );
+
+  return genKeypairFromSignature(sig.signature);
+}

package/src/libs/crypto/tree.ts

@@ -0,0 +1,176 @@
+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[];
+
+  constructor(degree: number, depth: number, zero: bigint) {
+    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(): bigint {
+    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]]);
+    }
+  }
+
+  private async initNodes(): Promise<void> {
+    const DEGREE = this.DEGREE;
+
+    this.nodes = new Array<bigint>(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: (bigint | string | number)[]): void {
+    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: number): bigint {
+    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(): bigint[] {
+    return this.nodes.slice(this.LEAVES_IDX_0);
+  }
+
+  updateLeaf(leafIdx: number, leaf: bigint): void {
+    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: number): number[] {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error('wrong leaf index');
+    }
+    let idx = this.LEAVES_IDX_0 + leafIdx;
+    const pathIdx: number[] = [];
+
+    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: number): bigint[][] {
+    if (leafIdx > this.LEAVES_COUNT || leafIdx < 0) {
+      throw new Error('wrong leaf index');
+    }
+    let idx = this.LEAVES_IDX_0 + leafIdx;
+    const pathElement: bigint[][] = [];
+
+    for (let h = 0; h < this.DEPTH; h++) {
+      const parentIdx = Math.floor((idx - 1) / this.DEGREE);
+      const childrenIdx0 = parentIdx * this.DEGREE + 1;
+
+      const el: bigint[] = [];
+      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: number): Tree {
+    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;
+  }
+
+  private async _update(nodeIdx: number): Promise<void> {
+    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;
+    }
+  }
+}
+
+export default Tree;

package/src/libs/crypto/types.ts

@@ -0,0 +1,101 @@
+export type SignResult = {
+  signature: string;
+  pubkey: Uint8Array;
+};
+
+// we define a bignumber as either a bigint or a string
+// which is what we use the most in MACI
+export type SnarkBigNumber = bigint;
+
+// a private key is a single BigNumber
+export type PrivKey = SnarkBigNumber;
+
+// a public key is a pair of BigNumbers
+export type PubKey<N = bigint> = [N, N];
+
+// a shared key is a pair of BigNumbers
+export type EcdhSharedKey<N = bigint> = [N, N];
+
+// a point is a pair of BigNumbers
+export type Point<N = SnarkBigNumber> = [N, N];
+
+// a plaintext is an array of BigNumbers
+export type Plaintext<N = bigint> = N[];
+
+// a ciphertext is an array of BigNumbers
+export type Ciphertext<N = bigint> = N[];
+
+// a merkle tree path elements
+export type PathElements = bigint[][];
+
+/**
+ * A acc queue
+ */
+export interface Queue {
+  levels: Map<number, Map<number, bigint>>;
+  indices: number[];
+}
+
+/**
+ * A private key and a public key
+ */
+export interface Keypair {
+  privKey: PrivKey;
+  pubKey: PubKey;
+  formatedPrivKey: PrivKey;
+}
+
+// An EdDSA signature.
+// R8 is a Baby Jubjub elliptic curve point and S is an element of the finite
+// field of order `l` where `l` is the large prime number dividing the order of
+// Baby Jubjub: see
+// https://iden3-docs.readthedocs.io/en/latest/_downloads/a04267077fb3fdbf2b608e014706e004/Ed-DSA.pdf
+export interface Signature<N = SnarkBigNumber> {
+  R8: Point<N>;
+  S: N;
+}
+
+/**
+ * A interface for poseidon hash functions
+ */
+export interface PoseidonFuncs {
+  [key: number]: (inputs: bigint[]) => bigint;
+  2: (inputs: bigint[]) => bigint;
+  3: (inputs: bigint[]) => bigint;
+  4: (inputs: bigint[]) => bigint;
+  5: (inputs: bigint[]) => bigint;
+}
+
+// a leaf is a single BigNumber
+export type Leaf = bigint;
+
+// a node is a leaf or subroot in a quinary merkle tree
+export type Node = Record<number, Leaf>;
+
+// a merkle proof is a set of path elements, path indices, and a root
+export interface IMerkleProof {
+  pathElements: Leaf[][];
+  pathIndices: number[];
+  root: Leaf;
+  leaf: Leaf;
+}
+
+export type StringifiedBigInts =
+  | StringifiedBigInts[]
+  | string
+  | string[]
+  | string[][]
+  | string[][][]
+  | { [key: string]: StringifiedBigInts }
+  | null;
+
+export type BigIntVariants =
+  | BigIntVariants[]
+  | StringifiedBigInts
+  | bigint
+  | bigint[]
+  | bigint[][]
+  | bigint[][][]
+  | { [key: string]: BigIntVariants }
+  | Uint8Array
+  | null;

package/src/libs/index.ts

@@ -3,5 +3,5 @@ export * from './query';
 export * from './indexer';
 export * from './contract';
 export * from './oracle-certificate';
-export * from './circom';
 export * from './maci';
+export * from './crypto';

package/src/libs/maci/maci.ts

@@ -1,11 +1,5 @@
 import { OfflineSigner } from '@cosmjs/proto-signing';
-import {
-  Account,
-  batchGenMessage,
-  Circom,
-  PublicKey,
-  stringizing,
-} from '../circom';
+import { Keypair, batchGenMessage, PubKey, stringizing } from '../crypto';
 import { Contract } from '../contract';
 import { Indexer } from '../indexer';
 import { OracleCertificate } from '../oracle-certificate';
@@ -31,25 +25,25 @@ export function isErrorResponse(response: unknown): response is ErrorResponse {
 }
 
 export class MACI {
-  public circom: Circom;
   public contract: Contract;
   public indexer: Indexer;
   public oracleCertificate: OracleCertificate;
+  public maciKeypair: Keypair;
   constructor({
-    circom,
     contract,
     indexer,
     oracleCertificate,
+    maciKeypair,
   }: {
-    circom: Circom;
     contract: Contract;
     indexer: Indexer;
     oracleCertificate: OracleCertificate;
+    maciKeypair: Keypair;
   }) {
-    this.circom = circom;
     this.contract = contract;
     this.indexer = indexer;
     this.oracleCertificate = oracleCertificate;
+    this.maciKeypair = maciKeypair;
   }
 
   async getStateIdxInc({
@@ -163,7 +157,10 @@ export class MACI {
     signer: OfflineSigner;
     address?: string;
     contractAddress: string;
-    certificate?: string;
+    certificate?: {
+      signature: string;
+      amount: string;
+    };
     mode?: 'maci' | 'amaci';
   }): Promise<string> {
     if (!address) {
@@ -205,8 +202,8 @@ export class MACI {
       });
 
       const balance = await client.whiteBalanceOf({
-        amount: address,
-        certificate,
+        amount: certificate.amount,
+        certificate: certificate.signature,
         sender: address,
       });
 
@@ -444,14 +441,14 @@ export class MACI {
     signer,
     address,
     contractAddress,
-    maciAccount,
+    maciKeypair,
     oracleCertificate,
     gasStation = false,
   }: {
     signer: OfflineSigner;
     address?: string;
     contractAddress: string;
-    maciAccount?: Account;
+    maciKeypair?: Keypair;
     oracleCertificate?: {
       amount: string;
       signature: string;
@@ -463,8 +460,9 @@ export class MACI {
         address = (await signer.getAccounts())[0].address;
       }
 
-      if (maciAccount === undefined) {
-        maciAccount = await this.circom.genKeypairFromSign(signer, address);
+      if (maciKeypair === undefined) {
+        maciKeypair = this.maciKeypair;
+        // maciKeypair = await this.crypto.genKeypairFromSign(signer, address);
       }
 
       const client = await this.contract.contractClient({
@@ -475,7 +473,7 @@ export class MACI {
         return await this.signupOracle({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           oracleCertificate,
           gasStation,
@@ -484,7 +482,7 @@ export class MACI {
         return await this.signupSimple({
           client,
           address,
-          pubKey: maciAccount.pubKey,
+          pubKey: maciKeypair.pubKey,
           contractAddress,
           gasStation,
         });
@@ -540,7 +538,7 @@ export class MACI {
     contractAddress,
     selectedOptions,
     operatorCoordPubKey,
-    maciAccount,
+    maciKeypair,
     gasStation = false,
   }: {
     signer: OfflineSigner;
@@ -551,8 +549,8 @@ export class MACI {
       idx: number;
       vc: number;
     }[];
-    operatorCoordPubKey: PublicKey;
-    maciAccount?: Account;
+    operatorCoordPubKey: PubKey;
+    maciKeypair?: Keypair;
     gasStation?: boolean;
   }) {
     if (stateIdx === -1) {
@@ -576,8 +574,9 @@ export class MACI {
         address = (await signer.getAccounts())[0].address;
       }
 
-      if (maciAccount === undefined) {
-        maciAccount = await this.circom.genKeypairFromSign(signer, address);
+      if (maciKeypair === undefined) {
+        maciKeypair = this.maciKeypair;
+        // maciKeypair = await this.crypto.genKeypairFromSign(signer, address);
       }
 
       const plan = options.map((o) => {
@@ -586,7 +585,7 @@ export class MACI {
 
       const payload = batchGenMessage(
         stateIdx,
-        maciAccount,
+        maciKeypair,
         operatorCoordPubKey,
         plan
       );
@@ -618,7 +617,7 @@ export class MACI {
     address: string;
     payload: {
       msg: bigint[];
-      encPubkeys: PublicKey;
+      encPubkeys: PubKey;
     }[];
     contractAddress: string;
     gasStation: boolean;
@@ -671,7 +670,7 @@ export class MACI {
   }: {
     client: SigningCosmWasmClient;
     address: string;
-    pubKey: PublicKey;
+    pubKey: PubKey;
     contractAddress: string;
     gasStation?: boolean;
   }) {
@@ -724,7 +723,7 @@ export class MACI {
   }: {
     client: SigningCosmWasmClient;
     address: string;
-    pubKey: PublicKey;
+    pubKey: PubKey;
     contractAddress: string;
     oracleCertificate: {
       amount: string;