@dorafactory/maci-sdk 0.0.6 → 0.0.7

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

@@ -1,3 +1,10 @@
+import { OfflineSigner } from '@cosmjs/proto-signing';
+import { SignResult, CircomParams } from './types';
+export * from './circomlib';
 export declare class Circom {
-    constructor();
+    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/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/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/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.6",
+  "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",
-    "ethers": "^6.13.4",
     "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;
+};

package/src/libs/circom/index.ts

@@ -0,0 +1,85 @@
+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 { PublicKey, genKeypair, stringizing } from './circomlib';
+import { SignResult, CircomParams } from './types';
+export * from './circomlib';
+
+export class Circom {
+  private network: string;
+  private chainId: string;
+
+  constructor({ network }: CircomParams) {
+    this.network = network;
+    this.chainId = getDefaultParams(network).chainId;
+  }
+
+  async signMessage(
+    signer: OfflineSigner,
+    address: string,
+    message: string
+  ): Promise<SignResult> {
+    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 (isOfflineDirectSigner(signer)) {
+      // Direct
+      const signDoc: 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 {
+      // Amino
+      const signDoc: StdSignDoc = {
+        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: OfflineSigner, address: string) {
+    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);
+  }
+}

package/src/libs/circom/types.ts

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

package/src/libs/contract/contract.ts

@@ -331,4 +331,8 @@ export class Contract {
       contractAddress,
     });
   }
+
+  async contractClient({ signer }: { signer: OfflineSigner }) {
+    return createContractClientByWallet(this.rpcEndpoint, signer);
+  }
 }

package/src/libs/contract/utils.ts

@@ -150,8 +150,8 @@ export function getContractParams(
     case MaciRoundType.ORACLE_MACI:
       return {
         parameters: CIRCUIT_INFO['9-4-3-625'].parameter,
-        groth16ProcessVkey: CIRCUIT_INFO['9-4-3-625']['groth16'].process_vkey,
-        groth16TallyVkey: CIRCUIT_INFO['9-4-3-625']['groth16'].tally_vkey,
+        groth16ProcessVkey,
+        groth16TallyVkey,
         plonkProcessVkey: null,
         plonkTallyVkey: null,
         maciVoteType,

package/src/libs/indexer/indexer.ts

@@ -14,7 +14,7 @@ import { IndexerParams } from './types';
 import { Http } from '../http';
 import {
   Round,
-  Account,
+  UserAccount,
   Circuit,
   Operator,
   Proof,
@@ -32,7 +32,7 @@ export class Indexer {
 
   public http: Http;
   public round: Round;
-  public account: Account;
+  public account: UserAccount;
   public circuit: Circuit;
   public operator: Operator;
   public proof: Proof;
@@ -55,7 +55,7 @@ export class Indexer {
     this.registryAddress = registryAddress;
 
     this.round = new Round(this.http);
-    this.account = new Account(this.http);
+    this.account = new UserAccount(this.http);
     this.circuit = new Circuit(this.http);
     this.operator = new Operator(this.http, this.registryAddress);
     this.proof = new Proof(this.http);