@dorafactory/maci-sdk 0.0.5 → 0.0.7

package/dist/libs/circom/circomlib.d.ts

@@ -0,0 +1,39 @@
+type MixedData<T> = T | Array<MixedData<T>> | {
+    [key: string]: MixedData<T>;
+};
+export type PrivateKey = bigint;
+export type PublicKey = [bigint, bigint];
+export interface Account {
+    privKey: PrivateKey;
+    pubKey: PublicKey;
+    formatedPrivKey: PrivateKey;
+}
+export declare const stringizing: (o: MixedData<bigint>, path?: MixedData<bigint>[]) => MixedData<string>;
+export declare const genKeypair: (pkey?: PrivateKey) => Account;
+export declare const genEcdhSharedKey: (privKey: PrivateKey, pubKey: PublicKey) => PublicKey;
+export declare const genMessageFactory: (stateIdx: number, signPriKey: PrivateKey, signPubKey: PublicKey, coordPubKey: PublicKey) => (encPriKey: PrivateKey, nonce: number, voIdx: number, newVotes: number, isLastCmd: boolean, salt?: bigint) => bigint[];
+export declare const batchGenMessage: (stateIdx: number, account: Account, coordPubKey: PublicKey, plan: [number, number][]) => {
+    msg: bigint[];
+    encPubkeys: PublicKey;
+}[];
+export declare const privateKeyFromTxt: (txt: string) => Account | undefined;
+export declare const genAddKeyProof: (depth: number, { coordPubKey, oldKey, deactivates, }: {
+    coordPubKey: PublicKey;
+    oldKey: Account;
+    deactivates: bigint[][];
+}) => Promise<{
+    inputHash: bigint;
+    coordPubKey: PublicKey;
+    deactivateRoot: any;
+    deactivateIndex: number;
+    deactivateLeaf: any;
+    c1: bigint[];
+    c2: bigint[];
+    randomVal: bigint;
+    d1: bigint[];
+    d2: bigint[];
+    deactivateLeafPathElements: any;
+    nullifier: any;
+    oldPrivateKey: bigint;
+} | null>;
+export {};

package/dist/libs/circom/index.d.ts

@@ -0,0 +1,10 @@
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { SignResult, CircomParams } from './types';
+export * from './circomlib';
+export declare class Circom {
+    private network;
+    private chainId;
+    constructor({ network }: CircomParams);
+    signMessage(signer: OfflineSigner, address: string, message: string): Promise<SignResult>;
+    genKeypairFromSign(signer: OfflineSigner, address: string): Promise<import("./circomlib").Account>;
+}

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

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

package/dist/libs/circom/types.d.ts

@@ -0,0 +1,7 @@
+export type CircomParams = {
+    network: 'mainnet' | 'testnet';
+};
+export type SignResult = {
+    signature: string;
+    pubkey: Uint8Array;
+};

package/dist/libs/contract/contract.d.ts

@@ -1,4 +1,5 @@
 import { OfflineSigner } from '@cosmjs/proto-signing';
+import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
 import { MaciClient } from './ts/Maci.client';
 import { AMaciClient } from './ts/AMaci.client';
 import { RegistryClient } from './ts/Registry.client';
@@ -36,4 +37,7 @@ export declare class Contract {
         signer: OfflineSigner;
         contractAddress: string;
     }): Promise<AMaciClient>;
+    contractClient({ signer }: {
+        signer: OfflineSigner;
+    }): Promise<SigningCosmWasmClient>;
 }

package/dist/libs/contract/utils.d.ts

@@ -17,7 +17,7 @@ export declare function getContractParams(type: MaciRoundType, circuitType: Maci
         vk_delta_2: string;
         vk_ic0: string;
         vk_ic1: string;
-    } | null;
+    } | null | undefined;
     groth16TallyVkey: {
         vk_alpha1: string;
         vk_beta_2: string;
@@ -25,7 +25,7 @@ export declare function getContractParams(type: MaciRoundType, circuitType: Maci
         vk_delta_2: string;
         vk_ic0: string;
         vk_ic1: string;
-    } | null;
+    } | null | undefined;
     plonkProcessVkey: {
         n: number;
         num_inputs: number;

package/dist/libs/contract/vars.d.ts

@@ -1,3 +1,11 @@
+type Groth16VkeyType = {
+    vk_alpha1: string;
+    vk_beta_2: string;
+    vk_gamma_2: string;
+    vk_delta_2: string;
+    vk_ic0: string;
+    vk_ic1: string;
+};
 type CircuitInfoType = {
     [key: string]: {
         parameter: {
@@ -7,22 +15,12 @@ type CircuitInfoType = {
             message_batch_size: string;
         };
         groth16: {
-            process_vkey: {
-                vk_alpha1: string;
-                vk_beta_2: string;
-                vk_gamma_2: string;
-                vk_delta_2: string;
-                vk_ic0: string;
-                vk_ic1: string;
-            };
-            tally_vkey: {
-                vk_alpha1: string;
-                vk_beta_2: string;
-                vk_gamma_2: string;
-                vk_delta_2: string;
-                vk_ic0: string;
-                vk_ic1: string;
-            };
+            process_vkey?: Groth16VkeyType;
+            tally_vkey?: Groth16VkeyType;
+            process_1p1v_vkey?: Groth16VkeyType;
+            tally_1p1v_vkey?: Groth16VkeyType;
+            process_qv_vkey?: Groth16VkeyType;
+            tally_qv_vkey?: Groth16VkeyType;
         };
         plonk?: {
             process_vkey: {

package/dist/libs/indexer/indexer.d.ts

@@ -1,7 +1,7 @@
 import { BalanceResponse, RoundResponse, RoundsResponse, OperatorResponse, OperatorsResponse, CircuitResponse, TransactionResponse, TransactionsResponse, CircuitsResponse, ProofResponse } from '../../types';
 import { IndexerParams } from './types';
 import { Http } from '../http';
-import { Round, Account, Circuit, Operator, Proof, Transaction } from '../query';
+import { Round, UserAccount, Circuit, Operator, Proof, Transaction } from '../query';
 /**
  * @class Indexer
  * @description This class is used to interact with Maci Indexer.
@@ -12,7 +12,7 @@ export declare class Indexer {
     registryAddress: string;
     http: Http;
     round: Round;
-    account: Account;
+    account: UserAccount;
     circuit: Circuit;
     operator: Operator;
     proof: Proof;

package/dist/libs/maci/maci.d.ts

@@ -0,0 +1,62 @@
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { Circom, PublicKey } from '../circom';
+import { Contract } from '../contract';
+import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+export declare class MACI {
+    circom: Circom;
+    contract: Contract;
+    constructor({ circom, contract }: {
+        circom: Circom;
+        contract: Contract;
+    });
+    signup({ signer, address, contractAddress, oracleCertificate, gasStation, }: {
+        signer: OfflineSigner;
+        address: string;
+        contractAddress: string;
+        oracleCertificate?: {
+            amount: string;
+            signature: string;
+        };
+        gasStation?: boolean;
+    }): Promise<void>;
+    submit: ({ signer, address, stateIdx, contractAddress, selectedOptions, operatorCoordPubKey, gasStation, }: {
+        signer: OfflineSigner;
+        address: string;
+        stateIdx: number;
+        contractAddress: string;
+        selectedOptions: {
+            idx: number;
+            vc: number;
+        }[];
+        operatorCoordPubKey: PublicKey;
+        gasStation?: boolean;
+    }) => Promise<void>;
+    submitPlan({ client, address, payload, contractAddress, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        payload: {
+            msg: bigint[];
+            encPubkeys: PublicKey;
+        }[];
+        contractAddress: string;
+        gasStation: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").DeliverTxResponse>;
+    signupSimple({ client, address, pubKey, contractAddress, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        pubKey: PublicKey;
+        contractAddress: string;
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+    signupOracle({ client, address, pubKey, contractAddress, oracleCertificate, gasStation, }: {
+        client: SigningCosmWasmClient;
+        address: string;
+        pubKey: PublicKey;
+        contractAddress: string;
+        oracleCertificate: {
+            amount: string;
+            signature: string;
+        };
+        gasStation?: boolean;
+    }): Promise<import("@cosmjs/cosmwasm-stargate").ExecuteResult>;
+}

package/dist/libs/maci/types.d.ts

@@ -0,0 +1,6 @@
+export type IAccountStatus = {
+    stateIdx: number;
+    vcbTotal: number;
+    whitelistCommitment: number;
+    feegrantStatus?: string;
+};

package/dist/libs/oracle-certificate/index.d.ts

@@ -0,0 +1 @@
+export { OracleCertificate } from './oracle-certificate';

package/dist/libs/oracle-certificate/oracle-certificate.d.ts

@@ -0,0 +1,27 @@
+import { OracleCertificateParams } from './types';
+/**
+ * @class Indexer
+ * @description This class is used to interact with Maci Indexer.
+ */
+export interface SignatureRequest {
+    address: string;
+    height: string;
+    contractAddress: string;
+    amount?: string;
+}
+export interface SignatureResponse {
+    code: number;
+    data?: {
+        signature: string;
+    };
+    error?: {
+        message: string;
+        type: string;
+    };
+}
+export declare class OracleCertificate {
+    private certificateApiEndpoint;
+    private http;
+    constructor({ certificateApiEndpoint, http }: OracleCertificateParams);
+    sign(data: SignatureRequest): Promise<SignatureResponse>;
+}

package/dist/libs/oracle-certificate/types.d.ts

@@ -0,0 +1,5 @@
+import { Http } from '../http/http';
+export type OracleCertificateParams = {
+    certificateApiEndpoint: string;
+    http: Http;
+};

package/dist/libs/query/account.d.ts

@@ -1,6 +1,6 @@
 import { Http } from '../http';
 import { BalanceResponse } from '../../types';
-export declare class Account {
+export declare class UserAccount {
     http: Http;
     constructor(http: Http);
     balanceOf(address: string): Promise<BalanceResponse>;

package/dist/libs/query/index.d.ts

@@ -1,4 +1,4 @@
-export { Account } from './account';
+export { UserAccount } from './account';
 export { Circuit } from './circuit';
 export { Operator } from './operator';
 export { Round } from './round';

package/dist/maci.d.ts

@@ -2,6 +2,7 @@ import { BalanceResponse, ClientParams, RoundResponse, RoundsResponse, OperatorR
 import { Http, Indexer, Contract } from './libs';
 import { CreateAMaciRoundParams, CreateMaciRoundParams, CreateOracleMaciRoundParams } from './libs/contract/types';
 import { OfflineSigner } from '@cosmjs/proto-signing';
+import { Circom } from './libs/circom';
 /**
  * @class MaciClient
  * @description This class is used to interact with Maci Client.
@@ -16,6 +17,7 @@ export declare class MaciClient {
     http: Http;
     indexer: Indexer;
     contract: Contract;
+    circom: Circom;
     feegrantOperator: string;
     whitelistBackendPubkey: string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorafactory/maci-sdk",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "SDK for interacting with maci",
   "keywords": [
     "maci",
@@ -34,19 +34,23 @@
     "@cosmjs/launchpad": "^0.27.1",
     "@cosmjs/proto-signing": "^0.32.1",
     "@cosmjs/stargate": "^0.32.1",
-    "@injectivelabs/sdk-ts": "^1.14.33",
     "assert": "^2.1.0",
     "bech32": "1.1.4",
-    "superstruct": "^1.0.3",
-    "ts-retry-promise": "^0.7.1",
-    "tweetnacl": "^1.0.3",
+    "@dorafactory/circomlib": "^0.0.2",
     "colorts": "^0.1.63",
+    "cosmjs-types": "^0.9.0",
+    "blake-hash": "^2.0.0",
+    "ffjavascript": "^0.2.60",
+    "ethers": "^6.13.4",
+    "gql.tada": "^1.7.0",
+    "graphql": "^16.8.1",
     "husky": "^8.0.3",
     "keccak256": "^1.0.6",
     "process": "^0.11.10",
-    "gql.tada": "^1.7.0",
-    "graphql": "^16.8.1",
+    "superstruct": "^1.0.3",
     "tmp": "^0.2.1",
+    "ts-retry-promise": "^0.7.1",
+    "tweetnacl": "^1.0.3",
     "valibot": "0.36.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -5,9 +5,12 @@ export * from './libs/const';
 export { MaciClient } from './maci';
 export { Http } from './libs/http';
 export { Round } from './libs/query';
-export { Account } from './libs/query';
+export { UserAccount } from './libs/query';
 export { Circuit } from './libs/query';
 export { Operator } from './libs/query';
 export { Proof } from './libs/query';
 export { Transaction } from './libs/query';
+export * from './libs/circom';
 export * from './utils';
+export { Scalar, utils } from 'ffjavascript';
+export { default as createBlakeHash } from 'blake-hash';

package/src/libs/circom/circomlib.ts

@@ -0,0 +1,308 @@
+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';
+
+type MixedData<T> = T | Array<MixedData<T>> | { [key: string]: MixedData<T> };
+
+export type PrivateKey = bigint;
+export type PublicKey = [bigint, bigint];
+
+export interface Account {
+  privKey: PrivateKey;
+  pubKey: PublicKey;
+  formatedPrivKey: PrivateKey;
+}
+
+const SNARK_FIELD_SIZE =
+  21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+
+const bigInt2Buffer = (i: bigint) => {
+  let hex = i.toString(16);
+  if (hex.length % 2 === 1) {
+    hex = '0' + hex;
+  }
+  return Buffer.from(hex, 'hex');
+};
+
+const genRandomKey = () => {
+  // Prevent modulo bias
+  // const lim = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000')
+  // const min = (lim - SNARK_FIELD_SIZE) % SNARK_FIELD_SIZE
+  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;
+};
+
+const genPubKey = (privKey: bigint) => {
+  return eddsa.prv2pub(bigInt2Buffer(privKey));
+};
+
+export const stringizing = (
+  o: MixedData<bigint>,
+  path: MixedData<bigint>[] = []
+): MixedData<string> => {
+  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: { [key: string]: MixedData<string> } = {};
+    for (const key in o) {
+      output[key] = stringizing(o[key], newPath);
+    }
+    return output;
+  } else {
+    return o.toString();
+  }
+};
+
+export const genKeypair = (pkey?: PrivateKey): Account => {
+  const privKey = pkey ? pkey % SNARK_FIELD_SIZE : genRandomKey();
+  const pubKey = genPubKey(privKey);
+  const formatedPrivKey = formatPrivKeyForBabyJub(privKey);
+
+  return { privKey, pubKey, formatedPrivKey };
+};
+
+const formatPrivKeyForBabyJub = (privKey: PrivateKey) => {
+  const sBuff = eddsa.pruneBuffer(
+    createBlakeHash('blake512')
+      .update(bigInt2Buffer(privKey))
+      .digest()
+      .slice(0, 32)
+  );
+  const s = utils.leBuff2int(sBuff);
+  return Scalar.shr(s, 3);
+};
+
+export const genEcdhSharedKey = (
+  privKey: PrivateKey,
+  pubKey: PublicKey
+): PublicKey => {
+  const sharedKey = babyJub.mulPointEscalar(
+    pubKey,
+    formatPrivKeyForBabyJub(privKey)
+  );
+  if (sharedKey[0] === 0n) {
+    return [0n, 1n];
+  } else {
+    return sharedKey;
+  }
+};
+
+export const genMessageFactory =
+  (
+    stateIdx: number,
+    signPriKey: PrivateKey,
+    signPubKey: PublicKey,
+    coordPubKey: PublicKey
+  ) =>
+  (
+    encPriKey: PrivateKey,
+    nonce: number,
+    voIdx: number,
+    newVotes: number,
+    isLastCmd: boolean,
+    salt?: bigint
+  ): bigint[] => {
+    if (!salt) {
+      // uint56
+      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;
+  };
+
+// Batch generate encrypted commands.
+// output format just like (with commands 1 ~ N):
+// [
+//   [msg_N, msg_N-1, ... msg_3, msg_2, msg_1],
+//   [pubkey_N, pubkey_N-1, ... pubkey_3, pubkey_2, pubkey_1]
+// ]
+// and change the public key at command_N
+export const batchGenMessage = (
+  stateIdx: number,
+  account: Account,
+  coordPubKey: PublicKey,
+  plan: [number, number][]
+) => {
+  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;
+};
+
+export const privateKeyFromTxt = (txt: string) => {
+  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);
+};
+
+const rerandomize = (
+  pubKey: bigint[],
+  ciphertext: { c1: bigint[]; c2: bigint[] },
+  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,
+  } as { d1: bigint[]; d2: bigint[] };
+};
+
+export const genAddKeyProof = async (
+  depth: number,
+  {
+    coordPubKey,
+    oldKey,
+    deactivates,
+  }: {
+    coordPubKey: PublicKey;
+    oldKey: Account;
+    deactivates: bigint[][];
+  }
+) => {
+  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],
+        ]) as string[]
+      )
+    ) % 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;
+};