@semaphore-protocol/identity 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ethereum Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+<p align="center">
+    <h1 align="center">
+        Semaphore identity
+    </h1>
+    <p align="center">A library for managing Semaphore identities.</p>
+</p>
+
+<p align="center">
+    <a href="https://github.com/semaphore-protocol/semaphore.js">
+        <img src="https://img.shields.io/badge/project-semaphore-blue.svg?style=flat-square">
+    </a>
+    <a href="https://github.com/semaphore-protocol/semaphore.js/blob/main/packages/identity/LICENSE">
+        <img alt="Github license" src="https://img.shields.io/github/license/semaphore-protocol/semaphore.js.svg?style=flat-square">
+    </a>
+    <a href="https://www.npmjs.com/package/@semaphore-protocol/identity">
+        <img alt="NPM version" src="https://img.shields.io/npm/v/@semaphore-protocol/identity?style=flat-square" />
+    </a>
+    <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>
+    <a href="https://prettier.io/">
+        <img alt="Code style prettier" src="https://img.shields.io/badge/code%20style-prettier-f8bc45?style=flat-square&logo=prettier" />
+    </a>
+</p>
+
+<div align="center">
+    <h4>
+        <a href="https://t.me/joinchat/B-PQx1U3GtAh--Z4Fwo56A">
+            🗣️ Chat &amp; Support
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://semaphore-protocol.github.io/semaphore.js/identity">
+            📘 Docs
+        </a>
+    </h4>
+</div>
+
+---
+
+## 🛠 Install
+
+### npm or yarn
+
+Install the `@semaphore-protocol/identity` package with npm:
+
+```bash
+npm i @semaphore-protocol/identity
+```
+
+or yarn:
+
+```bash
+yarn add @semaphore-protocol/identity
+```
+
+## 📜 Usage
+
+### Creating an identity with a random strategy:
+
+```typescript
+import { Identity } from "@semaphore-protocol/identity"
+// const { Identity } = require("@semaphore-protocol/identity") // with commonJS
+
+const identity = new Identity()
+
+const trapdoor = identity.getTrapdoor()
+const nullifier = identity.getNullifier()
+const secret = identity.getSecret()
+const multipartSecret = identity.getMultipartSecret()
+
+const identityCommitment = identity.genIdentityCommitment()
+```
+
+### Creating an identity with a message strategy:
+
+```typescript
+import { Identity, Strategy } from "@semaphore-protocol/identity"
+
+const identity = new Identity(Strategy.MESSAGE, "message")
+```
+
+### Creating an identity with a serialized strategy:
+
+```typescript
+import { Identity, Strategy } from "@semaphore-protocol/identity"
+
+const identity = new Identity()
+const serializedIdentity = identity.serializeIdentity()
+
+const identity2 = new Identity(Strategy.SERIALIZED, serializedIdentity)
+```

package/dist/index.mjs

@@ -0,0 +1,146 @@
+/**
+ * @module @semaphore-protocol/identity
+ * @version 0.1.0
+ * @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}
+*/
+import { BigNumber } from '@ethersproject/bignumber';
+import { poseidon } from 'circomlibjs';
+import { randomBytes } from '@ethersproject/random';
+import _sha256 from 'crypto-js/sha256';
+
+/**
+ * Returns an hexadecimal sha256 hash of the message passed as parameter.
+ * @param message The string to hash.
+ * @returns The hexadecimal hash of the message.
+ */
+function sha256(message) {
+    var hash = _sha256(message);
+    return hash.toString();
+}
+/**
+ * Generates a random big number.
+ * @param numberOfBytes The number of bytes of the number.
+ * @returns The generated random number.
+ */
+function genRandomNumber(numberOfBytes) {
+    if (numberOfBytes === void 0) { numberOfBytes = 31; }
+    return BigNumber.from(randomBytes(numberOfBytes)).toBigInt();
+}
+
+// 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.
+     */
+    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");
+        }
+    }
+    /**
+     * Returns the identity trapdoor.
+     * @returns The identity trapdoor.
+     */
+    Identity.prototype.getTrapdoor = function () {
+        return this._identityTrapdoor;
+    };
+    /**
+     * 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);
+    };
+    /**
+     * Generates the identity commitment from the secret.
+     * @returns identity commitment
+     */
+    Identity.prototype.genIdentityCommitment = function () {
+        return poseidon([this.getSecretHash()]);
+    };
+    /**
+     * Serializes the class attributes and returns a stringified object.
+     * @returns The stringified serialized 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);
+    };
+    return Identity;
+}());
+
+export { Identity, Strategy };

package/dist/index.node.js

@@ -0,0 +1,154 @@
+/**
+ * @module @semaphore-protocol/identity
+ * @version 0.1.0
+ * @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}
+*/
+'use strict';
+
+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');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _sha256__default = /*#__PURE__*/_interopDefaultLegacy(_sha256);
+
+/**
+ * Returns an hexadecimal sha256 hash of the message passed as parameter.
+ * @param message The string to hash.
+ * @returns The hexadecimal hash of the message.
+ */
+function sha256(message) {
+    var hash = _sha256__default["default"](message);
+    return hash.toString();
+}
+/**
+ * Generates a random big number.
+ * @param numberOfBytes The number of bytes of the number.
+ * @returns The generated random number.
+ */
+function genRandomNumber(numberOfBytes) {
+    if (numberOfBytes === void 0) { numberOfBytes = 31; }
+    return bignumber.BigNumber.from(random.randomBytes(numberOfBytes)).toBigInt();
+}
+
+// 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.
+     */
+    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");
+        }
+    }
+    /**
+     * Returns the identity trapdoor.
+     * @returns The identity trapdoor.
+     */
+    Identity.prototype.getTrapdoor = function () {
+        return this._identityTrapdoor;
+    };
+    /**
+     * 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);
+    };
+    /**
+     * Generates the identity commitment from the secret.
+     * @returns identity commitment
+     */
+    Identity.prototype.genIdentityCommitment = function () {
+        return circomlibjs.poseidon([this.getSecretHash()]);
+    };
+    /**
+     * Serializes the class attributes and returns a stringified object.
+     * @returns The stringified serialized 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);
+    };
+    return Identity;
+}());
+
+exports.Identity = Identity;

package/dist/types/identity.d.ts

@@ -0,0 +1,47 @@
+import { SerializedIdentity } from "./types";
+export declare enum Strategy {
+    RANDOM = 0,
+    MESSAGE = 1,
+    SERIALIZED = 2
+}
+export default class Identity {
+    private _identityTrapdoor;
+    private _identityNullifier;
+    private _secret;
+    /**
+     * 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.
+     */
+    constructor(strategy?: Strategy, metadata?: string | SerializedIdentity);
+    /**
+     * Returns the identity trapdoor.
+     * @returns The identity trapdoor.
+     */
+    getTrapdoor(): bigint;
+    /**
+     * Returns the identity nullifier.
+     * @returns The identity nullifier.
+     */
+    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.
+     * @returns identity commitment
+     */
+    genIdentityCommitment(): bigint;
+    /**
+     * Serializes the class attributes and returns a stringified object.
+     * @returns The stringified serialized identity.
+     */
+    serializeIdentity(): string;
+}

package/dist/types/identity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

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

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

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

package/dist/types/utils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns an hexadecimal sha256 hash of the message passed as parameter.
+ * @param message The string to hash.
+ * @returns The hexadecimal hash of the message.
+ */
+export declare function sha256(message: string): string;
+/**
+ * Generates a random big number.
+ * @param numberOfBytes The number of bytes of the number.
+ * @returns The generated random number.
+ */
+export declare function genRandomNumber(numberOfBytes?: number): bigint;

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@semaphore-protocol/identity",
+    "version": "0.1.0",
+    "description": "A library for managing Semaphore identities.",
+    "license": "MIT",
+    "main": "dist/index.node.js",
+    "exports": {
+        "import": "./dist/index.mjs",
+        "require": "./dist/index.node.js"
+    },
+    "types": "dist/types/index.d.ts",
+    "files": [
+        "dist/",
+        "src/",
+        "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",
+    "scripts": {
+        "build:watch": "rollup -c rollup.config.ts -w --configPlugin typescript",
+        "build": "rimraf dist && rollup -c rollup.config.ts --configPlugin typescript",
+        "prepublishOnly": "yarn build",
+        "docs": "typedoc src/index.ts --out ../../docs/identity"
+    },
+    "publishConfig": {
+        "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"
+    },
+    "dependencies": {
+        "@ethersproject/bignumber": "^5.5.0",
+        "@ethersproject/random": "^5.5.1",
+        "circomlibjs": "0.0.8",
+        "crypto-js": "^4.1.1"
+    },
+    "gitHead": "6c1b469a4b5ffaac562f478fc2bbc78731734e81"
+}

package/src/identity.test.ts

@@ -0,0 +1,92 @@
+import Identity, { Strategy } 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)
+
+            expect(fun).toThrow("strategy is not supported")
+        })
+
+        it("Should create a identity", () => {
+            const identity = new Identity()
+
+            expect(typeof identity).toBe("object")
+        })
+
+        it("Should not create a identity with a message strategy if there is no message", () => {
+            const fun = () => new Identity(Strategy.MESSAGE)
+
+            expect(fun).toThrow("The message is not defined")
+        })
+
+        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)
+
+            expect(fun).toThrow("The message is not a string")
+        })
+
+        it("Should create a identity with a message strategy", () => {
+            const identity = new Identity(Strategy.MESSAGE, "message")
+
+            const trapdoor = identity.getTrapdoor()
+            const nullifier = identity.getNullifier()
+            const identitySecret = identity.getSecret()
+
+            expect(typeof identity).toBe("object")
+            expect(trapdoor).toBe(
+                BigInt("58952291509798197436757858062402199043831251943841934828591473955215726495831")
+            )
+            expect(nullifier).toBe(
+                BigInt("44673097405870585416457571638073245190425597599743560105244308998175651589997")
+            )
+            expect(identitySecret).toHaveLength(2)
+            expect(typeof identitySecret).toBe("object")
+        })
+
+        it("Should generate an identity commitment secret", () => {
+            const identity = new Identity(Strategy.MESSAGE, "message")
+            const identityCommitment = identity.genIdentityCommitment()
+
+            expect(identityCommitment).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")
+        })
+
+        it("Should not create a identity with a serialized strategy if the serialize identity cannot be parsed", () => {
+            const fun = () => new Identity(Strategy.SERIALIZED, "{a}")
+
+            expect(fun).toThrow("The serialized identity cannot be parsed")
+        })
+
+        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)
+
+            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)
+
+            expect(identity2).toStrictEqual(identity1)
+        })
+    })
+})

package/src/identity.ts

@@ -0,0 +1,135 @@
+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.
+}
+
+export default class Identity {
+    private _identityTrapdoor: bigint
+    private _identityNullifier: bigint
+
+    private _secret: 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.
+     */
+    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")
+                }
+
+                if (typeof metadata !== "string") {
+                    throw new Error("The message is not a string")
+                }
+
+                const messageHash = sha256(metadata)
+
+                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")
+                }
+
+                if (typeof metadata === "string") {
+                    try {
+                        metadata = JSON.parse(metadata) as SerializedIdentity
+                    } 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")
+                }
+
+                const { identityNullifier, identityTrapdoor, secret } = metadata
+
+                this._identityNullifier = BigNumber.from(`0x${identityNullifier}`).toBigInt()
+                this._identityTrapdoor = BigNumber.from(`0x${identityTrapdoor}`).toBigInt()
+                this._secret = secret.map((item) => BigNumber.from(`0x${item}`).toBigInt())
+
+                break
+            }
+            default:
+                throw new Error("The provided strategy is not supported")
+        }
+    }
+
+    /**
+     * Returns the identity trapdoor.
+     * @returns The identity trapdoor.
+     */
+    public getTrapdoor(): bigint {
+        return this._identityTrapdoor
+    }
+
+    /**
+     * Returns the identity nullifier.
+     * @returns The identity nullifier.
+     */
+    public getNullifier(): bigint {
+        return this._identityNullifier
+    }
+
+    /**
+     * 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.
+     * @returns identity commitment
+     */
+    public genIdentityCommitment(): bigint {
+        return poseidon([this.getSecretHash()])
+    }
+
+    /**
+     * Serializes the class attributes and returns a stringified object.
+     * @returns The stringified serialized 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)
+    }
+}

package/src/index.ts

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

package/src/types/index.ts

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

package/src/utils.ts

@@ -0,0 +1,23 @@
+import { BigNumber } from "@ethersproject/bignumber"
+import { randomBytes } from "@ethersproject/random"
+import _sha256 from "crypto-js/sha256"
+
+/**
+ * Returns an hexadecimal sha256 hash of the message passed as parameter.
+ * @param message The string to hash.
+ * @returns The hexadecimal hash of the message.
+ */
+export function sha256(message: string): string {
+    const hash = _sha256(message)
+
+    return hash.toString()
+}
+
+/**
+ * Generates a random big number.
+ * @param numberOfBytes The number of bytes of the number.
+ * @returns The generated random number.
+ */
+export function genRandomNumber(numberOfBytes = 31): bigint {
+    return BigNumber.from(randomBytes(numberOfBytes)).toBigInt()
+}