@dorafactory/maci-sdk 0.1.3-pre.21 → 0.1.3-pre.22

package/dist/voter.d.ts

@@ -0,0 +1,161 @@
+import { ZKArtifact } from 'snarkjs';
+import { MaciAccount } from './libs/account';
+import { VoterClientParams, DerivePathParams, PubKey, PrivKey, DeactivateMessage } from './types';
+/**
+ * @class Maci Voter Client
+ * @description This class is used to interact with Maci Voter Client.
+ */
+export declare class VoterClient {
+    accountManager: MaciAccount;
+    /**
+     * @constructor
+     * @param {VoterClientParams} params - The parameters for the Maci Voter Client instance.
+     */
+    constructor({ mnemonic, secretKey }?: VoterClientParams);
+    /**
+     * else:
+     * it will generate signer from the mnemonic with the given derivePathParams.
+     * @param derivePathParams, such as { accountIndex: 2, isExternal: false, addressIndex: 10 }, comply with the BIP44 standard
+     */
+    getSigner(derivePathParams?: DerivePathParams): import(".").EdDSAPoseidonKeypair;
+    packMaciPubkey(pubkey?: PubKey): bigint;
+    unpackMaciPubkey(pubkey: bigint | string): PubKey;
+    getPubkey(derivePathParams?: DerivePathParams): import(".").EdDSAPoseidonPublicKey;
+    buildVotePayload({ stateIdx, operatorPubkey, selectedOptions, derivePathParams }: {
+        stateIdx: number;
+        operatorPubkey: bigint;
+        selectedOptions: {
+            idx: number;
+            vc: number;
+        }[];
+        derivePathParams?: DerivePathParams;
+    }): string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | {
+        [key: string]: string | /*elided*/ any | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    };
+    batchGenMessage(stateIdx: number, operatorPubkey: bigint, plan: [number, number][], derivePathParams?: DerivePathParams): {
+        msg: bigint[];
+        encPubkeys: PubKey<bigint>;
+    }[];
+    genMessageFactory(stateIdx: number, operatorPubkey: bigint, derivePathParams?: DerivePathParams): (encPriKey: PrivKey, nonce: number, voIdx: number, newVotes: number, isLastCmd: boolean, salt?: bigint) => bigint[];
+    buildAddNewKeyPayload({ stateTreeDepth, operatorPubkey, deactivates, wasmFile, zkeyFile, derivePathParams }: {
+        stateTreeDepth: number;
+        operatorPubkey: bigint;
+        deactivates: DeactivateMessage[];
+        wasmFile: ZKArtifact;
+        zkeyFile: ZKArtifact;
+        derivePathParams?: DerivePathParams;
+    }): Promise<{
+        proof: {
+            a: string;
+            b: string;
+            c: string;
+        };
+        d: string[];
+        nullifier: string;
+    }>;
+    buildPreAddNewKeyPayload({ stateTreeDepth, operatorPubkey, deactivates, wasmFile, zkeyFile, derivePathParams }: {
+        stateTreeDepth: number;
+        operatorPubkey: bigint;
+        deactivates: bigint[][];
+        wasmFile: ZKArtifact;
+        zkeyFile: ZKArtifact;
+        derivePathParams?: DerivePathParams;
+    }): Promise<{
+        proof: {
+            a: string;
+            b: string;
+            c: string;
+        };
+        d: string[];
+        nullifier: string;
+    }>;
+    genAddKeyInput(depth: number, { coordPubKey, deactivates, derivePathParams }: {
+        coordPubKey: PubKey;
+        deactivates: bigint[][];
+        derivePathParams?: DerivePathParams;
+    }): Promise<{
+        inputHash: bigint;
+        coordPubKey: PubKey;
+        deactivateRoot: bigint;
+        deactivateIndex: number;
+        deactivateLeaf: bigint;
+        c1: bigint[];
+        c2: bigint[];
+        randomVal: bigint;
+        d1: bigint[];
+        d2: bigint[];
+        deactivateLeafPathElements: bigint[][];
+        nullifier: bigint;
+        oldPrivateKey: bigint;
+    } | null>;
+    genPreAddKeyInput(depth: number, { coordPubKey, deactivates, derivePathParams }: {
+        coordPubKey: PubKey;
+        deactivates: bigint[][];
+        derivePathParams?: DerivePathParams;
+    }): Promise<{
+        inputHash: bigint;
+        coordPubKey: PubKey;
+        deactivateRoot: bigint;
+        deactivateIndex: number;
+        deactivateLeaf: bigint;
+        c1: [bigint, bigint];
+        c2: [bigint, bigint];
+        randomVal: bigint;
+        d1: bigint[];
+        d2: bigint[];
+        deactivateLeafPathElements: bigint[][];
+        nullifier: bigint;
+        oldPrivateKey: bigint;
+    } | null>;
+    buildDeactivatePayload({ stateIdx, operatorPubkey, derivePathParams }: {
+        stateIdx: number;
+        operatorPubkey: bigint;
+        derivePathParams?: DerivePathParams;
+    }): Promise<string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | {
+        [key: string]: string | /*elided*/ any | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    })[] | {
+        [key: string]: string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | (string | /*elided*/ any | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any)[] | /*elided*/ any;
+    }>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dorafactory/maci-sdk",
-  "version": "0.1.3-pre.21",
+  "version": "0.1.3-pre.22",
   "description": "SDK for interacting with maci",
   "keywords": [
     "maci",
@@ -28,16 +28,23 @@
     "src"
   ],
   "dependencies": {
+    "snarkjs": "0.7.5",
+    "ffjavascript": "0.3.1",
+    "@noble/curves": "^1.4.2",
+    "@noble/hashes": "^1.4.0",
+    "@scure/bip32": "^1.3.3",
+    "@scure/bip39": "^1.3.0",
+    "@zk-kit/baby-jubjub": "^1.0.3",
+    "@zk-kit/eddsa-poseidon": "^1.1.0",
+    "@zk-kit/poseidon-cipher": "^0.3.2",
+    "@zk-kit/utils": "^1.4.1",
     "@cosmjs/amino": "^0.32.1",
     "@cosmjs/cosmwasm-stargate": "^0.32.1",
     "@cosmjs/launchpad": "^0.27.1",
     "@cosmjs/proto-signing": "^0.32.1",
     "@cosmjs/stargate": "^0.32.1",
-    "@zk-kit/baby-jubjub": "^1.0.3",
-    "@zk-kit/eddsa-poseidon": "^1.1.0",
-    "@zk-kit/poseidon-cipher": "^0.3.2",
     "assert": "^2.1.0",
-    "bech32": "1.1.4",
+    "bech32": "^2.0.0",
     "cosmjs-types": "^0.9.0",
     "crypto-js": "^4.2.0",
     "ethers": "^6.13.4"
@@ -49,6 +56,7 @@
     "@types/crypto-js": "^4.2.2",
     "@types/node": "^20.8.7",
     "@types/tmp": "^0.2.5",
+    "@types/snarkjs": "^0.7.9",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
     "browserify-zlib": "^0.2.0",
@@ -73,62 +81,6 @@
     "typedoc": "^0.25.2",
     "typescript": "^5.2.2"
   },
-  "lint-staged": {
-    "**/*.ts": [
-      "pnpm run format:fix",
-      "pnpm run lint:fix"
-    ],
-    "**/*.json|md": [
-      "pnpm run format:fix"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "prettier": {
-    "trailingComma": "es5",
-    "tabWidth": 2,
-    "semi": true,
-    "singleQuote": true,
-    "useTabs": false,
-    "quoteProps": "as-needed",
-    "bracketSpacing": true,
-    "arrowParens": "always",
-    "endOfLine": "lf"
-  },
-  "eslintConfig": {
-    "root": true,
-    "env": {
-      "browser": true,
-      "node": true,
-      "es2022": true
-    },
-    "extends": [
-      "eslint:recommended",
-      "plugin:@typescript-eslint/eslint-recommended",
-      "plugin:prettier/recommended"
-    ],
-    "plugins": [
-      "@typescript-eslint",
-      "prettier"
-    ],
-    "parser": "@typescript-eslint/parser",
-    "rules": {
-      "prettier/prettier": "warn",
-      "@typescript-eslint/no-explicit-any": "off",
-      "no-unused-vars": "off",
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        {
-          "argsIgnorePattern": "^_",
-          "varsIgnorePattern": "^_",
-          "caughtErrorsIgnorePattern": "^_"
-        }
-      ]
-    }
-  },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
     "build": "npm run build:types && npm run build:tsup",

package/src/index.ts

@@ -1,16 +1,10 @@
 // Core
 export { MaciClient } from './maci';
+export { VoterClient } from './voter';
 export { Http } from './libs/http';
 
 // Query Types
-export {
-  Round,
-  UserAccount,
-  Circuit,
-  Operator,
-  Proof,
-  Transaction,
-} from './libs/query';
+export { Round, UserAccount, Circuit, Operator, Proof, Transaction } from './libs/query';
 
 // Crypto
 export * from './libs/crypto';
@@ -23,10 +17,10 @@ export type * from './types';
 export { circuits, getDefaultParams, type NetworkConfig } from './libs/const';
 
 // Utils
-export {
-  stringizing,
-  destringizing,
-  bigInt2Buffer,
-} from './libs/crypto/bigintUtils';
+export { stringizing, destringizing, bigInt2Buffer } from './libs/crypto/bigintUtils';
 export { isValidAddress } from './utils';
 export { getAMaciRoundCircuitFee } from './libs/contract/utils';
+
+export { EdDSAPoseidonKeypair, EdDSAPoseidonPublicKey } from './libs/keypairs/eddsa-poseidon';
+
+export * from './utils';

package/src/libs/account/crypto.ts

@@ -0,0 +1,7 @@
+import { generateMnemonic as genMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+
+export const generateMnemonic = (numberOfWords: 12 | 24 = 24) => {
+  const strength = numberOfWords === 12 ? 128 : 256;
+  return genMnemonic(wordlist, strength);
+};

package/src/libs/account/index.ts

@@ -0,0 +1,70 @@
+import {
+	EdDSAPoseidonKeypair,
+	EdDSAPoseidonPublicKey,
+} from '../keypairs/eddsa-poseidon';
+import { getKeyPair } from './keypair';
+import { generateMnemonic } from './crypto';
+import type { AccountMangerParams, DerivePathParams } from 'src/types';
+
+export { generateMnemonic } from './crypto';
+export { getKeyPair } from './keypair';
+
+export class MaciAccount {
+	private mnemonic: string;
+	private secretKey: string | bigint;
+	public currentKeypair: EdDSAPoseidonKeypair;
+	public currentPubkey: EdDSAPoseidonPublicKey;
+
+	/**
+	 * Support the following ways to init the SuiToolkit:
+	 * 1. mnemonics
+	 * 2. secretKey (base64 or hex)
+	 * If none of them is provided, will generate a random mnemonics with 24 words.
+	 *
+	 * @param mnemonics, 12 or 24 mnemonics words, separated by space
+	 * @param secretKey, base64 or hex string or Bech32 string, when mnemonics is provided, secretKey will be ignored
+	 */
+	constructor({ mnemonic, secretKey }: AccountMangerParams = {}) {
+		// If the mnemonics or secretKey is provided, use it
+		// Otherwise, generate a random mnemonics with 24 words
+		this.mnemonic = mnemonic || '';
+		this.secretKey = secretKey || '';
+		if (!this.mnemonic && !this.secretKey) {
+			this.mnemonic = generateMnemonic(24);
+		}
+
+		// Init the current account
+		this.currentKeypair = this.secretKey
+			? this.parseSecretKey(this.secretKey)
+			: getKeyPair(this.mnemonic);
+		this.currentPubkey = this.currentKeypair.getPublicKey();
+	}
+
+	/**
+	 * Check if the secretKey starts with bench32 format
+	 */
+	parseSecretKey(secretKey: string | bigint) {
+		return EdDSAPoseidonKeypair.fromSecretKey(secretKey);
+	}
+
+	/**
+	 * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
+	 * else:
+	 * it will generate keyPair from the mnemonic with the given derivePathParams.
+	 */
+	getKeyPair(derivePathParams?: DerivePathParams) {
+		if (!derivePathParams || !this.mnemonic) return this.currentKeypair;
+		return getKeyPair(this.mnemonic, derivePathParams);
+	}
+
+	/**
+	 * Switch the current account with the given derivePathParams.
+	 * This is only useful when the mnemonic is provided. For secretKey mode, it will always use the same account.
+	 */
+	switchAccount(derivePathParams: DerivePathParams) {
+		if (this.mnemonic) {
+			this.currentKeypair = getKeyPair(this.mnemonic, derivePathParams);
+			this.currentPubkey = this.currentKeypair.getPublicKey();
+		}
+	}
+}

package/src/libs/account/keypair.ts

@@ -0,0 +1,29 @@
+import type { DerivePathParams } from '../../types';
+import { EdDSAPoseidonKeypair } from '../keypairs/eddsa-poseidon';
+
+/**
+ * @description Get eddsaposeidon derive path for MACI
+ * @param derivePathParams
+ */
+export const getDerivePathForMACI = (derivePathParams: DerivePathParams = {}) => {
+  const { accountIndex = 0, isExternal = false, addressIndex = 0 } = derivePathParams;
+  return `m/44'/118'/${accountIndex}'/${isExternal ? 1 : 0}/${addressIndex}`;
+};
+
+/**
+ * the format is m/44'/118'/accountIndex'/${isExternal ? 1 : 0}/addressIndex
+ *
+ * accountIndex is the index of the account, default is 0.
+ *
+ * isExternal is the type of the address, default is false. Usually, the external address is used to receive coins. The internal address is used to change coins.
+ *
+ * addressIndex is the index of the address, default is 0. It's used to generate multiple addresses for one account.
+ *
+ * @description Get keypair from mnemonics and derive path
+ * @param mnemonics
+ * @param derivePathParams
+ */
+export const getKeyPair = (mnemonics: string, derivePathParams: DerivePathParams = {}) => {
+  const derivePath = getDerivePathForMACI(derivePathParams);
+  return EdDSAPoseidonKeypair.deriveKeypair(mnemonics, derivePath);
+};

package/src/libs/account/util.ts

@@ -0,0 +1,55 @@
+/**
+ * @description This regular expression matches any string that contains only hexadecimal digits (0-9, A-F, a-f).
+ * @param str
+ */
+export const isHex = (str: string) =>
+  /^0x[0-9a-fA-F]+$|^[0-9a-fA-F]+$/.test(str);
+
+/**
+ * @description This regular expression matches any string that contains only base64 digits (0-9, A-Z, a-z, +, /, =).
+ * Note that the "=" signs at the end are optional padding characters that may be present in some base64 encoded strings.
+ * @param str
+ */
+export const isBase64 = (str: string) => /^[a-zA-Z0-9+/]+={0,2}$/g.test(str);
+
+/**
+ * Convert a hex string to Uint8Array
+ * @param hexStr
+ */
+export const fromHEX = (hexStr: string): Uint8Array => {
+  if (!hexStr) {
+    throw new Error('cannot parse empty string to Uint8Array');
+  }
+  const intArr = hexStr
+    .replace('0x', '')
+    .match(/.{1,2}/g)
+    ?.map((byte) => parseInt(byte, 16));
+
+  if (!intArr || intArr.length === 0) {
+    throw new Error(`Unable to parse HEX: ${hexStr}`);
+  }
+  return Uint8Array.from(intArr);
+};
+
+const PRIVATE_KEY_SIZE = 32;
+const LEGACY_PRIVATE_KEY_SIZE = 64;
+/**
+ * normalize a private key
+ * A private key is a 32-byte array.
+ * But there are two different formats for private keys:
+ * 1. A 32-byte array
+ * 2. A 64-byte array with the first 32 bytes being the private key and the last 32 bytes being the public key
+ * 3. A 33-byte array with the first byte being 0x00 (sui.keystore key is a Base64 string with scheme flag 0x00 at the beginning)
+ */
+export const normalizePrivateKey = (key: Uint8Array): Uint8Array => {
+  if (key.length === LEGACY_PRIVATE_KEY_SIZE) {
+    // This is a legacy secret key, we need to strip the public key bytes and only read the first 32 bytes
+    key = key.slice(0, PRIVATE_KEY_SIZE);
+  } else if (key.length === PRIVATE_KEY_SIZE + 1 && key[0] === 0) {
+    // sui.keystore key is a Base64 string with scheme flag 0x00 at the beginning
+    return key.slice(1);
+  } else if (key.length === PRIVATE_KEY_SIZE) {
+    return key;
+  }
+  throw new Error('invalid secret key');
+};

package/src/libs/crypto/adapter.ts

@@ -0,0 +1,41 @@
+import { Groth16Proof } from 'snarkjs';
+import { utils } from 'ffjavascript';
+const { unstringifyBigInts } = utils;
+
+import * as curves from './curve';
+
+const Bytes2Str = (arr: number[]) => {
+	let str = '';
+	for (let i = 0; i < arr.length; i++) {
+		let tmp = arr[i].toString(16);
+		if (tmp.length == 1) {
+			tmp = '0' + tmp;
+		}
+		str += tmp;
+	}
+	return str;
+};
+
+let BN128Curve: any = null;
+
+export const adaptToUncompressed = async (proof: Groth16Proof) => {
+	const p = unstringifyBigInts(proof);
+
+	let curve = BN128Curve;
+	if (!curve) {
+		BN128Curve = await curves.getCurveFromName('BN128');
+		curve = BN128Curve;
+	}
+
+	// convert u8 array(little-endian order)to uncompressed type(big-endian order and on bls12_381 curve)
+	// which can be convert into Affine type in bellman
+	const pi_a = curve.G1.toUncompressed(curve.G1.fromObject(p.pi_a));
+	const pi_b = curve.G2.toUncompressed(curve.G2.fromObject(p.pi_b));
+	const pi_c = curve.G1.toUncompressed(curve.G1.fromObject(p.pi_c));
+
+	return {
+		a: Bytes2Str(Array.from(pi_a)),
+		b: Bytes2Str(Array.from(pi_b)),
+		c: Bytes2Str(Array.from(pi_c)),
+	};
+};

package/src/libs/crypto/babyjub.ts

@@ -42,7 +42,7 @@ export class G1Point {
   asContractParam(): { x: string; y: string } {
     return {
       x: this.x.toString(),
-      y: this.y.toString(),
+      y: this.y.toString()
     };
   }
 }
@@ -91,7 +91,7 @@ export class G2Point {
   asContractParam(): { x: string[]; y: string[] } {
     return {
       x: this.x.map((n) => n.toString()),
-      y: this.y.map((n) => n.toString()),
+      y: this.y.map((n) => n.toString())
     };
   }
 
@@ -144,14 +144,11 @@ export const genRandomBabyJubValue = () => {
   // Prevent modulo bias
   //const lim = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000')
   //const min = (lim - SNARK_FIELD_SIZE) % SNARK_FIELD_SIZE
-  const min =
-    6350874878119819312338956282401532410528162663560392320966563075034087161851n;
+  const min = 6350874878119819312338956282401532410528162663560392320966563075034087161851n;
 
   let rand;
   while (true) {
-    rand = BigInt(
-      `0x${CryptoJS.lib.WordArray.random(32).toString(CryptoJS.enc.Hex)}`
-    );
+    rand = BigInt(`0x${CryptoJS.lib.WordArray.random(32).toString(CryptoJS.enc.Hex)}`);
 
     if (rand >= min) {
       break;

package/src/libs/crypto/constants.ts

@@ -7,14 +7,11 @@ export const SNARK_FIELD_SIZE = r;
 
 // A nothing-up-my-sleeve zero value
 // Should be equal to 8370432830353022751713833565135785980866757267633941821328460903436894336785
-export const NOTHING_UP_MY_SLEEVE =
-  BigInt(keccak256(toUtf8Bytes('Maci'))) % SNARK_FIELD_SIZE;
+export const NOTHING_UP_MY_SLEEVE = BigInt(keccak256(toUtf8Bytes('Maci'))) % SNARK_FIELD_SIZE;
 
 assert(
   NOTHING_UP_MY_SLEEVE ===
-    BigInt(
-      '8370432830353022751713833565135785980866757267633941821328460903436894336785'
-    )
+    BigInt('8370432830353022751713833565135785980866757267633941821328460903436894336785')
 );
 
 export const PAD_KEY_HASH = BigInt(

package/src/libs/crypto/curve.ts

@@ -0,0 +1,55 @@
+import { Scalar, buildBn128, buildBls12381 } from 'ffjavascript';
+
+const bls12381r = Scalar.e('73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001', 16);
+const bn128r = Scalar.e(
+  '21888242871839275222246405745257275088548364400416034343698204186575808495617'
+);
+
+const bls12381q = Scalar.e(
+  '1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab',
+  16
+);
+const bn128q = Scalar.e(
+  '21888242871839275222246405745257275088696311157297823662689037894645226208583'
+);
+
+export async function getCurveFromR(r: bigint) {
+  let curve;
+  if (Scalar.eq(r, bn128r)) {
+    curve = await buildBn128();
+  } else if (Scalar.eq(r, bls12381r)) {
+    curve = await buildBls12381();
+  } else {
+    throw new Error(`Curve not supported: ${Scalar.toString(r)}`);
+  }
+  return curve;
+}
+
+export async function getCurveFromQ(q: bigint) {
+  let curve;
+  if (Scalar.eq(q, bn128q)) {
+    curve = await buildBn128();
+  } else if (Scalar.eq(q, bls12381q)) {
+    curve = await buildBls12381();
+  } else {
+    throw new Error(`Curve not supported: ${Scalar.toString(q)}`);
+  }
+  return curve;
+}
+
+export async function getCurveFromName(name: string) {
+  let curve;
+  const normName = normalizeName(name);
+  if (['BN128', 'BN254', 'ALTBN128'].indexOf(normName) >= 0) {
+    curve = await buildBn128();
+  } else if (['BLS12381'].indexOf(normName) >= 0) {
+    curve = await buildBls12381();
+  } else {
+    throw new Error(`Curve not supported: ${name}`);
+  }
+  return curve;
+
+  function normalizeName(n: string) {
+    return (n.toUpperCase().match(/[A-Za-z0-9]+/g) || []).join('');
+  }
+}

package/src/libs/crypto/hashing.ts

@@ -83,15 +83,14 @@ export const poseidonT6 = (inputs: bigint[]): bigint => {
  * @param right The right-hand element to hash
  * @returns The hash of the two elements
  */
-export const hashLeftRight = (left: bigint, right: bigint): bigint =>
-  poseidonT3([left, right]);
+export const hashLeftRight = (left: bigint, right: bigint): bigint => poseidonT3([left, right]);
 
 // hash functions
 const funcs: PoseidonFuncs = {
   2: poseidonT3,
   3: poseidonT4,
   4: poseidonT5,
-  5: poseidonT6,
+  5: poseidonT6
 };
 
 /**
@@ -154,7 +153,7 @@ export const hash12 = (elements: Plaintext): bigint => {
     poseidonT6(elementsPadded.slice(0, 5)),
     poseidonT6(elementsPadded.slice(5, 10)),
     elementsPadded[10],
-    elementsPadded[11],
+    elementsPadded[11]
   ]);
 };
 
@@ -163,5 +162,4 @@ export const hash12 = (elements: Plaintext): bigint => {
  * @param preImage The element to hash
  * @returns The hash of the element
  */
-export const hashOne = (preImage: bigint): bigint =>
-  poseidonT3([preImage, BigInt(0)]);
+export const hashOne = (preImage: bigint): bigint => poseidonT3([preImage, BigInt(0)]);

package/src/libs/crypto/index.ts

@@ -6,4 +6,7 @@ export * from './sign';
 export * from './types';
 export * from './tree';
 export * from './babyjub';
+export * from './curve';
+export * from './adapter';
+export * from './rerandomize';
 export type { Keypair, PubKey, PrivKey } from './types';