@semaphore-protocol/identity 0.1.0 → 0.2.2

package/README.md

@@ -18,9 +18,6 @@
     <a href="https://npmjs.org/package/@semaphore-protocol/identity">
         <img alt="Downloads" src="https://img.shields.io/npm/dm/@semaphore-protocol/identity.svg?style=flat-square" />
     </a>
-    <a href="https://bundlephobia.com/package/@semaphore-protocol/identity">
-        <img alt="npm bundle size (scoped)" src="https://img.shields.io/bundlephobia/minzip/@semaphore-protocol/identity" />
-    </a>
     <a href="https://eslint.org/">
         <img alt="Linter eslint" src="https://img.shields.io/badge/linter-eslint-8080f2?style=flat-square&logo=eslint" />
     </a>
@@ -61,37 +58,35 @@ yarn add @semaphore-protocol/identity
 
 ## 📜 Usage
 
-### Creating an identity with a random strategy:
+\# **new Identity**(identityOrMessage?: _string_): _Identity_
 
 ```typescript
 import { Identity } from "@semaphore-protocol/identity"
-// const { Identity } = require("@semaphore-protocol/identity") // with commonJS
 
-const identity = new Identity()
+// Trapdoor and nullifier are generated randomly.
+const identity1 = new Identity()
 
-const trapdoor = identity.getTrapdoor()
-const nullifier = identity.getNullifier()
-const secret = identity.getSecret()
-const multipartSecret = identity.getMultipartSecret()
+// Trapdoor and nullifier are generated deterministically from a secret message.
+const identity2 = new Identity("secret-message")
 
-const identityCommitment = identity.genIdentityCommitment()
+// Trapdoor and nullifier are generated from an existing identity.
+const identity3 = new Identity(identity1.toString())
 ```
 
-### Creating an identity with a message strategy:
+\# **getTrapdoor**(): _bigint_
 
 ```typescript
-import { Identity, Strategy } from "@semaphore-protocol/identity"
-
-const identity = new Identity(Strategy.MESSAGE, "message")
+const trapdoor = identity.getTrapdoor()
 ```
 
-### Creating an identity with a serialized strategy:
+\# **getNullifier**(): _bigint_
 
 ```typescript
-import { Identity, Strategy } from "@semaphore-protocol/identity"
+const nullifier = identity.getNullifier()
+```
 
-const identity = new Identity()
-const serializedIdentity = identity.serializeIdentity()
+\# **generateCommitment**(): _bigint_
 
-const identity2 = new Identity(Strategy.SERIALIZED, serializedIdentity)
+```typescript
+const commitment = identity.generateCommitment()
 ```

package/dist/index.mjs

@@ -1,15 +1,22 @@
 /**
  * @module @semaphore-protocol/identity
- * @version 0.1.0
+ * @version 0.2.2
  * @file A library for managing Semaphore identities.
  * @copyright Ethereum Foundation 2022
  * @license MIT
- * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/proof}
+ * @see [Github]{@link https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof}
 */
 import { BigNumber } from '@ethersproject/bignumber';
 import { poseidon } from 'circomlibjs';
 import { randomBytes } from '@ethersproject/random';
-import _sha256 from 'crypto-js/sha256';
+import { sha256 as sha256$1 } from '@ethersproject/sha2';
+import { toUtf8Bytes } from '@ethersproject/strings';
+
+function checkParameter(value, name, type) {
+    if (typeof value !== type) {
+        throw new TypeError("Parameter '".concat(name, "' is not a ").concat(type));
+    }
+}
 
 /**
  * Returns an hexadecimal sha256 hash of the message passed as parameter.
@@ -17,8 +24,8 @@ import _sha256 from 'crypto-js/sha256';
  * @returns The hexadecimal hash of the message.
  */
 function sha256(message) {
-    var hash = _sha256(message);
-    return hash.toString();
+    var hash = sha256$1(toUtf8Bytes(message));
+    return hash;
 }
 /**
  * Generates a random big number.
@@ -28,119 +35,73 @@ function sha256(message) {
 function genRandomNumber(numberOfBytes) {
     if (numberOfBytes === void 0) { numberOfBytes = 31; }
     return BigNumber.from(randomBytes(numberOfBytes)).toBigInt();
+}
+/**
+ * Checks if a string is a JSON.
+ * @param jsonString The JSON string.
+ * @returns True or false.
+ */
+function isJsonArray(jsonString) {
+    try {
+        return Array.isArray(JSON.parse(jsonString));
+    }
+    catch (error) {
+        return false;
+    }
 }
 
-// The strategy used to generate the Identity.
-var Strategy;
-(function (Strategy) {
-    Strategy[Strategy["RANDOM"] = 0] = "RANDOM";
-    Strategy[Strategy["MESSAGE"] = 1] = "MESSAGE";
-    Strategy[Strategy["SERIALIZED"] = 2] = "SERIALIZED"; // Identity parameters are passed from outside.
-})(Strategy || (Strategy = {}));
 var Identity = /** @class */ (function () {
     /**
      * Initializes the class attributes based on the strategy passed as parameter.
-     * @param strategy The strategy for identity generation.
-     * @param metadata Additional data needed to create identity for given strategy.
+     * @param identityOrMessage Additional data needed to create identity for given strategy.
      */
-    function Identity(strategy, metadata) {
-        if (strategy === void 0) { strategy = Strategy.RANDOM; }
-        this._secret = [];
-        switch (strategy) {
-            case Strategy.RANDOM: {
-                this._identityTrapdoor = genRandomNumber();
-                this._identityNullifier = genRandomNumber();
-                this._secret = [this._identityNullifier, this._identityTrapdoor];
-                break;
-            }
-            case Strategy.MESSAGE: {
-                if (!metadata) {
-                    throw new Error("The message is not defined");
-                }
-                if (typeof metadata !== "string") {
-                    throw new Error("The message is not a string");
-                }
-                var messageHash = sha256(metadata);
-                this._identityTrapdoor = BigNumber.from("0x".concat(sha256("".concat(messageHash, "identity_trapdoor")))).toBigInt();
-                this._identityNullifier = BigNumber.from("0x".concat(sha256("".concat(messageHash, "identity_nullifier")))).toBigInt();
-                this._secret = [this._identityNullifier, this._identityTrapdoor];
-                break;
-            }
-            case Strategy.SERIALIZED: {
-                if (!metadata) {
-                    throw new Error("The serialized identity is not defined");
-                }
-                if (typeof metadata === "string") {
-                    try {
-                        metadata = JSON.parse(metadata);
-                    }
-                    catch (error) {
-                        throw new Error("The serialized identity cannot be parsed");
-                    }
-                }
-                if (!("identityNullifier" in metadata) ||
-                    !("identityTrapdoor" in metadata) ||
-                    !("secret" in metadata)) {
-                    throw new Error("The serialized identity does not contain the right parameter");
-                }
-                var identityNullifier = metadata.identityNullifier, identityTrapdoor = metadata.identityTrapdoor, secret = metadata.secret;
-                this._identityNullifier = BigNumber.from("0x".concat(identityNullifier)).toBigInt();
-                this._identityTrapdoor = BigNumber.from("0x".concat(identityTrapdoor)).toBigInt();
-                this._secret = secret.map(function (item) { return BigNumber.from("0x".concat(item)).toBigInt(); });
-                break;
-            }
-            default:
-                throw new Error("The provided strategy is not supported");
+    function Identity(identityOrMessage) {
+        if (identityOrMessage === undefined) {
+            this._trapdoor = genRandomNumber();
+            this._nullifier = genRandomNumber();
+            return;
         }
+        checkParameter(identityOrMessage, "identityOrMessage", "string");
+        if (!isJsonArray(identityOrMessage)) {
+            var messageHash = sha256(identityOrMessage).slice(2);
+            this._trapdoor = BigNumber.from(sha256("".concat(messageHash, "identity_trapdoor"))).toBigInt();
+            this._nullifier = BigNumber.from(sha256("".concat(messageHash, "identity_nullifier"))).toBigInt();
+            return;
+        }
+        var _a = JSON.parse(identityOrMessage), trapdoor = _a[0], nullifier = _a[1];
+        this._trapdoor = BigNumber.from("0x".concat(trapdoor)).toBigInt();
+        this._nullifier = BigNumber.from("0x".concat(nullifier)).toBigInt();
     }
     /**
      * Returns the identity trapdoor.
      * @returns The identity trapdoor.
      */
     Identity.prototype.getTrapdoor = function () {
-        return this._identityTrapdoor;
+        return this._trapdoor;
     };
     /**
      * Returns the identity nullifier.
      * @returns The identity nullifier.
      */
     Identity.prototype.getNullifier = function () {
-        return this._identityNullifier;
-    };
-    /**
-     * Returns the secret.
-     * @returns The secret.
-     */
-    Identity.prototype.getSecret = function () {
-        return this._secret;
-    };
-    /**
-     * Returns the Poseidon hash of the secret.
-     * @returns The hash of the secret.
-     */
-    Identity.prototype.getSecretHash = function () {
-        return poseidon(this._secret);
+        return this._nullifier;
     };
     /**
-     * Generates the identity commitment from the secret.
+     * Generates the identity commitment from trapdoor and nullifier.
      * @returns identity commitment
      */
-    Identity.prototype.genIdentityCommitment = function () {
-        return poseidon([this.getSecretHash()]);
+    Identity.prototype.generateCommitment = function () {
+        return poseidon([poseidon([this._nullifier, this._trapdoor])]);
     };
     /**
-     * Serializes the class attributes and returns a stringified object.
-     * @returns The stringified serialized identity.
+     * Returns a JSON string with trapdoor and nullifier. It can be used
+     * to export the identity and reuse it later.
+     * @returns The string representation of the identity.
      */
-    Identity.prototype.serializeIdentity = function () {
-        var data = {
-            identityNullifier: this._identityNullifier.toString(16),
-            identityTrapdoor: this._identityTrapdoor.toString(16),
-            secret: this._secret.map(function (item) { return item.toString(16); })
-        };
-        return JSON.stringify(data);
+    Identity.prototype.toString = function () {
+        return JSON.stringify([this._trapdoor.toString(16), this._nullifier.toString(16)]);
     };
     return Identity;
 }());
 
-export { Identity, Strategy };
+export { Identity };

package/dist/index.node.js

@@ -1,10 +1,10 @@
 /**
  * @module @semaphore-protocol/identity
- * @version 0.1.0
+ * @version 0.2.2
  * @file A library for managing Semaphore identities.
  * @copyright Ethereum Foundation 2022
  * @license MIT
- * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/proof}
+ * @see [Github]{@link https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof}
 */
 'use strict';
 
@@ -13,11 +13,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var bignumber = require('@ethersproject/bignumber');
 var circomlibjs = require('circomlibjs');
 var random = require('@ethersproject/random');
-var _sha256 = require('crypto-js/sha256');
+var sha2 = require('@ethersproject/sha2');
+var strings = require('@ethersproject/strings');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _sha256__default = /*#__PURE__*/_interopDefaultLegacy(_sha256);
+function checkParameter(value, name, type) {
+    if (typeof value !== type) {
+        throw new TypeError("Parameter '".concat(name, "' is not a ").concat(type));
+    }
+}
 
 /**
  * Returns an hexadecimal sha256 hash of the message passed as parameter.
@@ -25,8 +28,8 @@ var _sha256__default = /*#__PURE__*/_interopDefaultLegacy(_sha256);
  * @returns The hexadecimal hash of the message.
  */
 function sha256(message) {
-    var hash = _sha256__default["default"](message);
-    return hash.toString();
+    var hash = sha2.sha256(strings.toUtf8Bytes(message));
+    return hash;
 }
 /**
  * Generates a random big number.
@@ -36,117 +39,71 @@ function sha256(message) {
 function genRandomNumber(numberOfBytes) {
     if (numberOfBytes === void 0) { numberOfBytes = 31; }
     return bignumber.BigNumber.from(random.randomBytes(numberOfBytes)).toBigInt();
+}
+/**
+ * Checks if a string is a JSON.
+ * @param jsonString The JSON string.
+ * @returns True or false.
+ */
+function isJsonArray(jsonString) {
+    try {
+        return Array.isArray(JSON.parse(jsonString));
+    }
+    catch (error) {
+        return false;
+    }
 }
 
-// The strategy used to generate the Identity.
-exports.Strategy = void 0;
-(function (Strategy) {
-    Strategy[Strategy["RANDOM"] = 0] = "RANDOM";
-    Strategy[Strategy["MESSAGE"] = 1] = "MESSAGE";
-    Strategy[Strategy["SERIALIZED"] = 2] = "SERIALIZED"; // Identity parameters are passed from outside.
-})(exports.Strategy || (exports.Strategy = {}));
 var Identity = /** @class */ (function () {
     /**
      * Initializes the class attributes based on the strategy passed as parameter.
-     * @param strategy The strategy for identity generation.
-     * @param metadata Additional data needed to create identity for given strategy.
+     * @param identityOrMessage Additional data needed to create identity for given strategy.
      */
-    function Identity(strategy, metadata) {
-        if (strategy === void 0) { strategy = exports.Strategy.RANDOM; }
-        this._secret = [];
-        switch (strategy) {
-            case exports.Strategy.RANDOM: {
-                this._identityTrapdoor = genRandomNumber();
-                this._identityNullifier = genRandomNumber();
-                this._secret = [this._identityNullifier, this._identityTrapdoor];
-                break;
-            }
-            case exports.Strategy.MESSAGE: {
-                if (!metadata) {
-                    throw new Error("The message is not defined");
-                }
-                if (typeof metadata !== "string") {
-                    throw new Error("The message is not a string");
-                }
-                var messageHash = sha256(metadata);
-                this._identityTrapdoor = bignumber.BigNumber.from("0x".concat(sha256("".concat(messageHash, "identity_trapdoor")))).toBigInt();
-                this._identityNullifier = bignumber.BigNumber.from("0x".concat(sha256("".concat(messageHash, "identity_nullifier")))).toBigInt();
-                this._secret = [this._identityNullifier, this._identityTrapdoor];
-                break;
-            }
-            case exports.Strategy.SERIALIZED: {
-                if (!metadata) {
-                    throw new Error("The serialized identity is not defined");
-                }
-                if (typeof metadata === "string") {
-                    try {
-                        metadata = JSON.parse(metadata);
-                    }
-                    catch (error) {
-                        throw new Error("The serialized identity cannot be parsed");
-                    }
-                }
-                if (!("identityNullifier" in metadata) ||
-                    !("identityTrapdoor" in metadata) ||
-                    !("secret" in metadata)) {
-                    throw new Error("The serialized identity does not contain the right parameter");
-                }
-                var identityNullifier = metadata.identityNullifier, identityTrapdoor = metadata.identityTrapdoor, secret = metadata.secret;
-                this._identityNullifier = bignumber.BigNumber.from("0x".concat(identityNullifier)).toBigInt();
-                this._identityTrapdoor = bignumber.BigNumber.from("0x".concat(identityTrapdoor)).toBigInt();
-                this._secret = secret.map(function (item) { return bignumber.BigNumber.from("0x".concat(item)).toBigInt(); });
-                break;
-            }
-            default:
-                throw new Error("The provided strategy is not supported");
+    function Identity(identityOrMessage) {
+        if (identityOrMessage === undefined) {
+            this._trapdoor = genRandomNumber();
+            this._nullifier = genRandomNumber();
+            return;
         }
+        checkParameter(identityOrMessage, "identityOrMessage", "string");
+        if (!isJsonArray(identityOrMessage)) {
+            var messageHash = sha256(identityOrMessage).slice(2);
+            this._trapdoor = bignumber.BigNumber.from(sha256("".concat(messageHash, "identity_trapdoor"))).toBigInt();
+            this._nullifier = bignumber.BigNumber.from(sha256("".concat(messageHash, "identity_nullifier"))).toBigInt();
+            return;
+        }
+        var _a = JSON.parse(identityOrMessage), trapdoor = _a[0], nullifier = _a[1];
+        this._trapdoor = bignumber.BigNumber.from("0x".concat(trapdoor)).toBigInt();
+        this._nullifier = bignumber.BigNumber.from("0x".concat(nullifier)).toBigInt();
     }
     /**
      * Returns the identity trapdoor.
      * @returns The identity trapdoor.
      */
     Identity.prototype.getTrapdoor = function () {
-        return this._identityTrapdoor;
+        return this._trapdoor;
     };
     /**
      * Returns the identity nullifier.
      * @returns The identity nullifier.
      */
     Identity.prototype.getNullifier = function () {
-        return this._identityNullifier;
-    };
-    /**
-     * Returns the secret.
-     * @returns The secret.
-     */
-    Identity.prototype.getSecret = function () {
-        return this._secret;
-    };
-    /**
-     * Returns the Poseidon hash of the secret.
-     * @returns The hash of the secret.
-     */
-    Identity.prototype.getSecretHash = function () {
-        return circomlibjs.poseidon(this._secret);
+        return this._nullifier;
     };
     /**
-     * Generates the identity commitment from the secret.
+     * Generates the identity commitment from trapdoor and nullifier.
      * @returns identity commitment
      */
-    Identity.prototype.genIdentityCommitment = function () {
-        return circomlibjs.poseidon([this.getSecretHash()]);
+    Identity.prototype.generateCommitment = function () {
+        return circomlibjs.poseidon([circomlibjs.poseidon([this._nullifier, this._trapdoor])]);
     };
     /**
-     * Serializes the class attributes and returns a stringified object.
-     * @returns The stringified serialized identity.
+     * Returns a JSON string with trapdoor and nullifier. It can be used
+     * to export the identity and reuse it later.
+     * @returns The string representation of the identity.
      */
-    Identity.prototype.serializeIdentity = function () {
-        var data = {
-            identityNullifier: this._identityNullifier.toString(16),
-            identityTrapdoor: this._identityTrapdoor.toString(16),
-            secret: this._secret.map(function (item) { return item.toString(16); })
-        };
-        return JSON.stringify(data);
+    Identity.prototype.toString = function () {
+        return JSON.stringify([this._trapdoor.toString(16), this._nullifier.toString(16)]);
     };
     return Identity;
 }());

package/dist/types/checkParameter.d.ts

@@ -0,0 +1 @@
+export default function checkParameter(value: any, name: string, type: string): void;

package/dist/types/identity.d.ts

@@ -1,19 +1,11 @@
-import { SerializedIdentity } from "./types";
-export declare enum Strategy {
-    RANDOM = 0,
-    MESSAGE = 1,
-    SERIALIZED = 2
-}
 export default class Identity {
-    private _identityTrapdoor;
-    private _identityNullifier;
-    private _secret;
+    private _trapdoor;
+    private _nullifier;
     /**
      * Initializes the class attributes based on the strategy passed as parameter.
-     * @param strategy The strategy for identity generation.
-     * @param metadata Additional data needed to create identity for given strategy.
+     * @param identityOrMessage Additional data needed to create identity for given strategy.
      */
-    constructor(strategy?: Strategy, metadata?: string | SerializedIdentity);
+    constructor(identityOrMessage?: string);
     /**
      * Returns the identity trapdoor.
      * @returns The identity trapdoor.
@@ -25,23 +17,14 @@ export default class Identity {
      */
     getNullifier(): bigint;
     /**
-     * Returns the secret.
-     * @returns The secret.
-     */
-    getSecret(): bigint[];
-    /**
-     * Returns the Poseidon hash of the secret.
-     * @returns The hash of the secret.
-     */
-    getSecretHash(): bigint;
-    /**
-     * Generates the identity commitment from the secret.
+     * Generates the identity commitment from trapdoor and nullifier.
      * @returns identity commitment
      */
-    genIdentityCommitment(): bigint;
+    generateCommitment(): bigint;
     /**
-     * Serializes the class attributes and returns a stringified object.
-     * @returns The stringified serialized identity.
+     * Returns a JSON string with trapdoor and nullifier. It can be used
+     * to export the identity and reuse it later.
+     * @returns The string representation of the identity.
      */
-    serializeIdentity(): string;
+    toString(): string;
 }

package/dist/types/index.d.ts

@@ -1,2 +1,2 @@
-import Identity, { Strategy } from "./identity";
-export { Identity, Strategy };
+import Identity from "./identity";
+export { Identity };

package/dist/types/utils.d.ts

@@ -10,3 +10,9 @@ export declare function sha256(message: string): string;
  * @returns The generated random number.
  */
 export declare function genRandomNumber(numberOfBytes?: number): bigint;
+/**
+ * Checks if a string is a JSON.
+ * @param jsonString The JSON string.
+ * @returns True or false.
+ */
+export declare function isJsonArray(jsonString: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@semaphore-protocol/identity",
-    "version": "0.1.0",
+    "version": "0.2.2",
     "description": "A library for managing Semaphore identities.",
     "license": "MIT",
     "main": "dist/index.node.js",
@@ -15,8 +15,8 @@
         "LICENSE",
         "README.md"
     ],
-    "repository": "https://github.com/privacy-scaling-explorations/zk-kit",
-    "homepage": "https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/proof",
+    "repository": "https://github.com/semaphore-protocol/semaphore.js",
+    "homepage": "https://github.com/semaphore-protocol/semaphore.js/tree/main/packages/proof",
     "scripts": {
         "build:watch": "rollup -c rollup.config.ts -w --configPlugin typescript",
         "build": "rimraf dist && rollup -c rollup.config.ts --configPlugin typescript",
@@ -27,7 +27,6 @@
         "access": "public"
     },
     "devDependencies": {
-        "@types/crypto-js": "^4.1.1",
         "rollup-plugin-cleanup": "^3.2.1",
         "rollup-plugin-typescript2": "^0.31.2",
         "typedoc": "^0.22.11"
@@ -35,8 +34,8 @@
     "dependencies": {
         "@ethersproject/bignumber": "^5.5.0",
         "@ethersproject/random": "^5.5.1",
-        "circomlibjs": "0.0.8",
-        "crypto-js": "^4.1.1"
-    },
-    "gitHead": "6c1b469a4b5ffaac562f478fc2bbc78731734e81"
+        "@ethersproject/sha2": "^5.6.1",
+        "@ethersproject/strings": "^5.6.1",
+        "circomlibjs": "0.0.8"
+    }
 }

package/src/checkParameter.ts

@@ -0,0 +1,5 @@
+export default function checkParameter(value: any, name: string, type: string) {
+    if (typeof value !== type) {
+        throw new TypeError(`Parameter '${name}' is not a ${type}`)
+    }
+}

package/src/identity.test.ts

@@ -1,92 +1,114 @@
-import Identity, { Strategy } from "./identity"
+import { BigNumber } from "@ethersproject/bignumber"
+import Identity from "./identity"
 
 describe("Identity", () => {
-    describe("Create identity", () => {
-        it("Should not create a identity if the strategy is wrong", () => {
-            const fun = () => new Identity("wrong" as any)
+    describe("# Identity", () => {
+        it("Should not create a identity if the parameter is not valid", () => {
+            const fun1 = () => new Identity(13 as any)
+            const fun2 = () => new Identity(true as any)
+            const fun3 = () => new Identity((() => true) as any)
+
+            expect(fun1).toThrow("Parameter 'identityOrMessage' is not a string")
+            expect(fun2).toThrow("Parameter 'identityOrMessage' is not a string")
+            expect(fun3).toThrow("Parameter 'identityOrMessage' is not a string")
+        })
+
+        it("Should create random identities", () => {
+            const identity1 = new Identity()
+            const identity2 = new Identity()
 
-            expect(fun).toThrow("strategy is not supported")
+            expect(identity1.getTrapdoor()).not.toBe(identity2.getTrapdoor())
+            expect(identity1.getNullifier()).not.toBe(identity2.getNullifier())
         })
 
-        it("Should create a identity", () => {
-            const identity = new Identity()
+        it("Should create deterministic identities from a message", () => {
+            const identity1 = new Identity("message")
+            const identity2 = new Identity("message")
 
-            expect(typeof identity).toBe("object")
+            expect(identity1.getTrapdoor()).toBe(identity2.getTrapdoor())
+            expect(identity1.getNullifier()).toBe(identity2.getNullifier())
         })
 
-        it("Should not create a identity with a message strategy if there is no message", () => {
-            const fun = () => new Identity(Strategy.MESSAGE)
+        it("Should create deterministic identities from number/boolean messages", () => {
+            const identity1 = new Identity("true")
+            const identity2 = new Identity("true")
+            const identity3 = new Identity("7")
+            const identity4 = new Identity("7")
 
-            expect(fun).toThrow("The message is not defined")
+            expect(identity1.getTrapdoor()).toBe(identity2.getTrapdoor())
+            expect(identity1.getNullifier()).toBe(identity2.getNullifier())
+            expect(identity3.getTrapdoor()).toBe(identity4.getTrapdoor())
+            expect(identity3.getNullifier()).toBe(identity4.getNullifier())
         })
 
-        it("Should not create a identity with a message strategy if the message is not a string", () => {
-            const fun = () => new Identity(Strategy.MESSAGE, 1 as any)
+        it("Should not recreate an existing invalid identity", () => {
+            const fun = () => new Identity('[true, "01323"]')
 
-            expect(fun).toThrow("The message is not a string")
+            expect(fun).toThrow("invalid BigNumber string")
         })
 
-        it("Should create a identity with a message strategy", () => {
-            const identity = new Identity(Strategy.MESSAGE, "message")
+        it("Should recreate an existing identity", () => {
+            const identity1 = new Identity("message")
+
+            const identity2 = new Identity(identity1.toString())
+
+            expect(identity1.getTrapdoor()).toBe(identity2.getTrapdoor())
+            expect(identity1.getNullifier()).toBe(identity2.getNullifier())
+        })
+    })
+
+    describe("# getTrapdoor", () => {
+        it("Should return the identity trapdoor", () => {
+            const identity = new Identity("message")
 
             const trapdoor = identity.getTrapdoor()
-            const nullifier = identity.getNullifier()
-            const identitySecret = identity.getSecret()
 
-            expect(typeof identity).toBe("object")
             expect(trapdoor).toBe(
                 BigInt("58952291509798197436757858062402199043831251943841934828591473955215726495831")
             )
+        })
+    })
+
+    describe("# getNullifier", () => {
+        it("Should return the identity nullifier", () => {
+            const identity = new Identity("message")
+
+            const nullifier = identity.getNullifier()
+
             expect(nullifier).toBe(
                 BigInt("44673097405870585416457571638073245190425597599743560105244308998175651589997")
             )
-            expect(identitySecret).toHaveLength(2)
-            expect(typeof identitySecret).toBe("object")
         })
+    })
+
+    describe("# generateCommitment", () => {
+        it("Should generate an identity commitment", () => {
+            const identity = new Identity("message")
 
-        it("Should generate an identity commitment secret", () => {
-            const identity = new Identity(Strategy.MESSAGE, "message")
-            const identityCommitment = identity.genIdentityCommitment()
+            const commitment = identity.generateCommitment()
 
-            expect(identityCommitment).toBe(
+            expect(commitment).toBe(
                 BigInt("1720349790382552497189398984241859233944354304766757200361065203741879866188")
             )
         })
+    })
 
-        it("Should serialize an identity", () => {
-            const identity = new Identity()
-            const serialized = identity.serializeIdentity()
-
-            expect(typeof serialized).toBe("string")
-        })
-
-        it("Should not create a identity with a serialized strategy if there is no serialize identity", () => {
-            const fun = () => new Identity(Strategy.SERIALIZED)
-
-            expect(fun).toThrow("serialized identity is not defined")
-        })
+    describe("# toString", () => {
+        it("Should return a string", () => {
+            const identity = new Identity("message")
 
-        it("Should not create a identity with a serialized strategy if the serialize identity cannot be parsed", () => {
-            const fun = () => new Identity(Strategy.SERIALIZED, "{a}")
+            const identityString = identity.toString()
 
-            expect(fun).toThrow("The serialized identity cannot be parsed")
+            expect(typeof identityString).toBe("string")
         })
 
-        it("Should not create a identity with a serialized strategy if the serialize identity does not contain the right parameters", () => {
-            const fun = () =>
-                new Identity(Strategy.SERIALIZED, {
-                    identityTrapdoor: "234"
-                } as any)
+        it("Should return a valid identity string", () => {
+            const identity = new Identity("message")
 
-            expect(fun).toThrow("The serialized identity does not contain the right parameter")
-        })
-
-        it("Should create a identity with a serialized strategy", () => {
-            const identity1 = new Identity()
-            const serialized = identity1.serializeIdentity()
-            const identity2 = new Identity(Strategy.SERIALIZED, serialized)
+            const [trapdoor, nullifier] = JSON.parse(identity.toString())
 
-            expect(identity2).toStrictEqual(identity1)
+            expect(BigNumber.from(`0x${trapdoor}`).toBigInt()).toBe(identity.getTrapdoor())
+            expect(BigNumber.from(`0x${nullifier}`).toBigInt()).toBe(identity.getNullifier())
         })
     })
 })

package/src/identity.ts

@@ -1,82 +1,39 @@
 import { BigNumber } from "@ethersproject/bignumber"
 import { poseidon } from "circomlibjs"
-import { SerializedIdentity } from "./types"
-import { genRandomNumber, sha256 } from "./utils"
-
-// The strategy used to generate the Identity.
-export enum Strategy {
-    RANDOM, // Identity is generated randomly.
-    MESSAGE, // Identity is generated from a message.
-    SERIALIZED // Identity parameters are passed from outside.
-}
+import checkParameter from "./checkParameter"
+import { genRandomNumber, isJsonArray, sha256 } from "./utils"
 
 export default class Identity {
-    private _identityTrapdoor: bigint
-    private _identityNullifier: bigint
-
-    private _secret: bigint[] = []
+    private _trapdoor: bigint
+    private _nullifier: bigint
 
     /**
      * Initializes the class attributes based on the strategy passed as parameter.
-     * @param strategy The strategy for identity generation.
-     * @param metadata Additional data needed to create identity for given strategy.
+     * @param identityOrMessage Additional data needed to create identity for given strategy.
      */
-    constructor(strategy: Strategy = Strategy.RANDOM, metadata?: string | SerializedIdentity) {
-        switch (strategy) {
-            case Strategy.RANDOM: {
-                this._identityTrapdoor = genRandomNumber()
-                this._identityNullifier = genRandomNumber()
-                this._secret = [this._identityNullifier, this._identityTrapdoor]
-                break
-            }
-            case Strategy.MESSAGE: {
-                if (!metadata) {
-                    throw new Error("The message is not defined")
-                }
+    constructor(identityOrMessage?: string) {
+        if (identityOrMessage === undefined) {
+            this._trapdoor = genRandomNumber()
+            this._nullifier = genRandomNumber()
 
-                if (typeof metadata !== "string") {
-                    throw new Error("The message is not a string")
-                }
-
-                const messageHash = sha256(metadata)
+            return
+        }
 
-                this._identityTrapdoor = BigNumber.from(`0x${sha256(`${messageHash}identity_trapdoor`)}`).toBigInt()
-                this._identityNullifier = BigNumber.from(`0x${sha256(`${messageHash}identity_nullifier`)}`).toBigInt()
-                this._secret = [this._identityNullifier, this._identityTrapdoor]
-                break
-            }
-            case Strategy.SERIALIZED: {
-                if (!metadata) {
-                    throw new Error("The serialized identity is not defined")
-                }
+        checkParameter(identityOrMessage, "identityOrMessage", "string")
 
-                if (typeof metadata === "string") {
-                    try {
-                        metadata = JSON.parse(metadata) as SerializedIdentity
-                    } catch (error) {
-                        throw new Error("The serialized identity cannot be parsed")
-                    }
-                }
+        if (!isJsonArray(identityOrMessage)) {
+            const messageHash = sha256(identityOrMessage).slice(2)
 
-                if (
-                    !("identityNullifier" in metadata) ||
-                    !("identityTrapdoor" in metadata) ||
-                    !("secret" in metadata)
-                ) {
-                    throw new Error("The serialized identity does not contain the right parameter")
-                }
+            this._trapdoor = BigNumber.from(sha256(`${messageHash}identity_trapdoor`)).toBigInt()
+            this._nullifier = BigNumber.from(sha256(`${messageHash}identity_nullifier`)).toBigInt()
 
-                const { identityNullifier, identityTrapdoor, secret } = metadata
+            return
+        }
 
-                this._identityNullifier = BigNumber.from(`0x${identityNullifier}`).toBigInt()
-                this._identityTrapdoor = BigNumber.from(`0x${identityTrapdoor}`).toBigInt()
-                this._secret = secret.map((item) => BigNumber.from(`0x${item}`).toBigInt())
+        const [trapdoor, nullifier] = JSON.parse(identityOrMessage)
 
-                break
-            }
-            default:
-                throw new Error("The provided strategy is not supported")
-        }
+        this._trapdoor = BigNumber.from(`0x${trapdoor}`).toBigInt()
+        this._nullifier = BigNumber.from(`0x${nullifier}`).toBigInt()
     }
 
     /**
@@ -84,7 +41,7 @@ export default class Identity {
      * @returns The identity trapdoor.
      */
     public getTrapdoor(): bigint {
-        return this._identityTrapdoor
+        return this._trapdoor
     }
 
     /**
@@ -92,44 +49,23 @@ export default class Identity {
      * @returns The identity nullifier.
      */
     public getNullifier(): bigint {
-        return this._identityNullifier
+        return this._nullifier
     }
 
     /**
-     * Returns the secret.
-     * @returns The secret.
-     */
-    public getSecret(): bigint[] {
-        return this._secret
-    }
-
-    /**
-     * Returns the Poseidon hash of the secret.
-     * @returns The hash of the secret.
-     */
-    public getSecretHash(): bigint {
-        return poseidon(this._secret)
-    }
-
-    /**
-     * Generates the identity commitment from the secret.
+     * Generates the identity commitment from trapdoor and nullifier.
      * @returns identity commitment
      */
-    public genIdentityCommitment(): bigint {
-        return poseidon([this.getSecretHash()])
+    public generateCommitment(): bigint {
+        return poseidon([poseidon([this._nullifier, this._trapdoor])])
     }
 
     /**
-     * Serializes the class attributes and returns a stringified object.
-     * @returns The stringified serialized identity.
+     * Returns a JSON string with trapdoor and nullifier. It can be used
+     * to export the identity and reuse it later.
+     * @returns The string representation of the identity.
      */
-    public serializeIdentity(): string {
-        const data: SerializedIdentity = {
-            identityNullifier: this._identityNullifier.toString(16),
-            identityTrapdoor: this._identityTrapdoor.toString(16),
-            secret: this._secret.map((item) => item.toString(16))
-        }
-
-        return JSON.stringify(data)
+    public toString(): string {
+        return JSON.stringify([this._trapdoor.toString(16), this._nullifier.toString(16)])
     }
 }

package/src/index.ts

@@ -1,3 +1,4 @@
-import Identity, { Strategy } from "./identity"
+import Identity from "./identity"
 
-export { Identity, Strategy }
+// eslint-disable-next-line import/prefer-default-export
+export { Identity }

package/src/utils.ts

@@ -1,6 +1,7 @@
 import { BigNumber } from "@ethersproject/bignumber"
 import { randomBytes } from "@ethersproject/random"
-import _sha256 from "crypto-js/sha256"
+import { sha256 as _sha256 } from "@ethersproject/sha2"
+import { toUtf8Bytes } from "@ethersproject/strings"
 
 /**
  * Returns an hexadecimal sha256 hash of the message passed as parameter.
@@ -8,9 +9,9 @@ import _sha256 from "crypto-js/sha256"
  * @returns The hexadecimal hash of the message.
  */
 export function sha256(message: string): string {
-    const hash = _sha256(message)
+    const hash = _sha256(toUtf8Bytes(message))
 
-    return hash.toString()
+    return hash
 }
 
 /**
@@ -21,3 +22,16 @@ export function sha256(message: string): string {
 export function genRandomNumber(numberOfBytes = 31): bigint {
     return BigNumber.from(randomBytes(numberOfBytes)).toBigInt()
 }
+
+/**
+ * Checks if a string is a JSON.
+ * @param jsonString The JSON string.
+ * @returns True or false.
+ */
+export function isJsonArray(jsonString: string) {
+    try {
+        return Array.isArray(JSON.parse(jsonString))
+    } catch (error) {
+        return false
+    }
+}

package/dist/types/types/index.d.ts

@@ -1,5 +0,0 @@
-export declare type SerializedIdentity = {
-    identityNullifier: string;
-    identityTrapdoor: string;
-    secret: string[];
-};

package/src/types/index.ts

@@ -1,5 +0,0 @@
-export type SerializedIdentity = {
-    identityNullifier: string
-    identityTrapdoor: string
-    secret: string[]
-}