@semaphore-protocol/identity 4.0.0-beta.12 → 4.0.0-beta.13

package/README.md

@@ -84,6 +84,28 @@ const { privateKey, publicKey, commitment } = new Identity()
 const identity = new Identity("your-private-key")
 ```
 
+\# **identity.export**(): _string_
+
+```typescript
+import { Identity } from "@semaphore-protocol/identity"
+
+const identity = new Identity()
+
+const privateKey = identity.export()
+```
+
+\# **identity.import**(privateKey: _string_): _Identity_
+
+```typescript
+import { Identity } from "@semaphore-protocol/identity"
+
+const identity = new Identity()
+
+const privateKey = identity.export()
+
+const identity2 = Identity.import(privateKey)
+```
+
 \# **identity.signMessage**(message: _BigNumberish_): _Signature\<string>_
 
 ```typescript

package/dist/index.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/identity
- * @version 4.0.0-beta.12
+ * @version 4.0.0-beta.13
  * @file A library to create Semaphore identities.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -1869,12 +1869,42 @@ getDefaultExportFromCjs(buffer);
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
+/**
+ * @module TypeChecks
+ * This module provides utility functions to check data types.
+ * It defines a set of supported types and includes functions to check if
+ * a value is defined and if it matches a supported type. These functions
+ * are useful for type checking and validation in the other libraries,
+ * enhancing code robustness and reliability.
+ */
+/** @internal */
+const supportedTypes = [
+    "number",
+    "string",
+    "function",
+    "Array",
+    "Uint8Array",
+    "Buffer",
+    "object",
+    "bigint",
+    "stringified-bigint",
+    "hexadecimal",
+    "bignumber",
+    "bignumberish"
+];
+/**
+ * Returns true if the value is a number, false otherwise.
+ * @param value The value to be checked.
+ */
+function isNumber(value) {
+    return typeof value === "number";
+}
 /**
  * Returns true if the value is a string, false otherwise.
  * @param value The value to be checked.
@@ -1882,6 +1912,65 @@ getDefaultExportFromCjs(buffer);
 function isString(value) {
     return typeof value === "string";
 }
+/**
+ * Returns true if the value is a function, false otherwise.
+ * @param value The value to be checked.
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * Returns true if the value is an object, false otherwise.
+ * Please, note that arrays are also objects in JavaScript.
+ * @param value The value to be checked.
+ */
+function isObject(value) {
+    return typeof value === "object";
+}
+/**
+ * Returns true if the value is an Array instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isArray(value) {
+    return isObject(value) && Array.isArray(value);
+}
+/**
+ * Returns true if the value is a Uint8Array instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+/**
+ * Returns true if the value is a Buffer instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isBuffer(value) {
+    return buffer.Buffer.isBuffer(value);
+}
+/**
+ * Returns true if the value is a bigint, false otherwise.
+ * @param value The value to be checked.
+ */
+function isBigInt(value) {
+    return typeof value === "bigint";
+}
+/**
+ * Checks if the given value is a string that represents a valid bigint.
+ * @param value The value to be checked if it's a stringified bigint.
+ */
+function isStringifiedBigInt(value) {
+    if (!isString(value)) {
+        return false;
+    }
+    try {
+        BigInt(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Checks if a string is a valid hexadecimal string representation.
  * If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more
@@ -1899,10 +1988,79 @@ function isHexadecimal(value, prefix = true) {
     }
     return /^[0-9a-fA-F]+$/.test(value);
 }
+/**
+ * Checks if the given value can be considered as BigNumber.
+ * A value is considered a BigNumber if it is a bigint or a string
+ * that can be converted to a bigint (via `Bigint(s)`).
+ * @param value The value to check.
+ */
+function isBigNumber(value) {
+    return isBigInt(value) || isStringifiedBigInt(value);
+}
+/**
+ * Checks if the given value can be considered as BigNumberish.
+ * A value is considered BigNumberish if it meets
+ * any of the following conditions: it's a number, a bigint, a string
+ * that can be converted to a bigint, a hexadecimal
+ * string, or a Buffer object.
+ * @param value The value to check.
+ */
+function isBigNumberish(value) {
+    return (isNumber(value) ||
+        isBigInt(value) ||
+        isStringifiedBigInt(value) ||
+        isHexadecimal(value) ||
+        isBuffer(value) ||
+        isUint8Array(value));
+}
+/**
+ * Returns true if the value type is the same as the type passed
+ * as the second parameter, false otherwise.
+ * @param value
+ * @param type The expected type.
+ */
+function isType(value, type) {
+    switch (type) {
+        case "number":
+            return isNumber(value);
+        case "string":
+            return isString(value);
+        case "function":
+            return isFunction(value);
+        case "Array":
+            return isArray(value);
+        case "Uint8Array":
+            return isUint8Array(value);
+        case "Buffer":
+            return isBuffer(value);
+        case "object":
+            return isObject(value);
+        case "bigint":
+            return isBigInt(value);
+        case "stringified-bigint":
+            return isStringifiedBigInt(value);
+        case "hexadecimal":
+            return isHexadecimal(value);
+        case "bignumber":
+            return isBigNumber(value);
+        case "bignumberish":
+            return isBigNumberish(value);
+        default:
+            return false;
+    }
+}
+/**
+ * Returns true if the type is being supported by this utility
+ * functions, false otherwise.
+ * @param type The type to be checked.
+ */
+function isSupportedType(type) {
+    return supportedTypes.includes(type);
+}
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -1919,40 +2077,60 @@ function requireString(parameterValue, parameterName) {
     }
 }
 /**
- * @throws Throws a type error if the parameter value is not a hexadecimal string.
- * If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more
- * hexadecimal digits (0-9, a-f, A-F), otherwise no prefix is expected. 'prefix' is optional and
- * if its value it is not explicitly defined it will be set to 'true' by default.
+ * @throws Throws a type error if the parameter value type is not part of the list of types.
  * @param parameterValue The parameter value.
  * @param parameterName The parameter name.
- * @param prefix A boolean to include or not a '0x' or '0X' prefix.
  */
-function requireHexadecimal(parameterValue, parameterName, prefix = true) {
-    if (!isHexadecimal(parameterValue, prefix)) {
-        throw new TypeError(`Parameter '${parameterName}' is not a hexadecimal string`);
+function requireTypes(parameterValue, parameterName, types) {
+    for (const type of types) {
+        if (!isSupportedType(type)) {
+            throw new Error(`Type '${type}' is not supported`);
+        }
     }
+    for (const type of types) {
+        if (isType(parameterValue, type)) {
+            return;
+        }
+    }
+    throw new TypeError(`Parameter '${parameterName}' is none of the following types: ${types.join(", ")}`);
 }
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
 /**
- * Converts an hexadecimal string to a buffer. The hexadecimal string
- * should not start with '0x' or '0X'. It keeps the bytes in the same order.
- * @param value The hexadecimal string to convert.
- * @returns The buffer representation of the hexadecimal string.
+ * Converts bytes to a base64 string. It accepts 'Buffer' or 'Uint8Array'.
+ * @param value The bytes to convert.
+ * @returns The converted base64 string.
  */
-function hexadecimalToBuffer(value) {
-    requireHexadecimal(value, "value", false);
-    if (value.length % 2 !== 0) {
-        value = `0${value}`;
-    }
-    return buffer.Buffer.from(value, "hex");
+function bufferToBase64(value) {
+    requireTypes(value, "value", ["Buffer", "Uint8Array"]);
+    return buffer.Buffer.from(value).toString("base64");
+}
+/**
+ * Converts a base64 string to bytes (i.e. a buffer). This function does not check
+ * if the input value is a valid base64 string. If there are unsupported characters
+ * they will be ignored.
+ * @param value The base64 string to convert.
+ * @returns The converted buffer.
+ */
+function base64ToBuffer(value) {
+    requireString(value, "value");
+    return buffer.Buffer.from(value, "base64");
+}
+/**
+ * Converts text (utf8) to a base64 string.
+ * @param value The text to convert.
+ * @returns The converted base64 string.
+ */
+function textToBase64(value) {
+    requireString(value, "value");
+    return buffer.Buffer.from(value, "utf8").toString("base64");
 }
 
 var poseidon2$1 = {};
@@ -2059,14 +2237,12 @@ function poseidon2(inputs) {
  * and {@link https://www.poseidon-hash.info | Poseidon} for signatures.
  * In addition, the commitment, i.e. the hash of the public key, is used to represent
  * Semaphore identities in groups, adding an additional layer of privacy and security.
- * The private key of the identity is stored as a hexadecimal string or text.
- * The other attributes are stored as stringified bigint.
+ * The private key of the identity can be exported as a base64 string.
  */
 class Identity {
     /**
-     * Initializes the class attributes based on a given private key, which must be a hexadecimal string or a text.
-     * Hexadecimal strings must not start with '0x' or '0X'.
-     * If the private key is not passed as a parameter, a random hexadecimal key will be generated.
+     * Initializes the class attributes based on a given private key, which must be text or a buffer.
+     * If the private key is not passed as a parameter, a random private key will be generated.
      * The EdDSAPoseidon class is used to generate the secret scalar and the public key.
      * Additionally, the constructor computes a commitment of the public key using a hash function (Poseidon).
      *
@@ -2080,28 +2256,15 @@ class Identity {
      * @param privateKey The private key used to derive the public key (hexadecimal or string).
      */
     constructor(privateKey) {
-        let eddsa;
-        if (privateKey) {
-            requireString(privateKey, "privateKey");
-            this._privateKey = privateKey;
-            if (isHexadecimal(privateKey, false)) {
-                eddsa = new eddsaPoseidon.EdDSAPoseidon(hexadecimalToBuffer(privateKey));
-            }
-            else {
-                eddsa = new eddsaPoseidon.EdDSAPoseidon(privateKey);
-            }
-        }
-        else {
-            eddsa = new eddsaPoseidon.EdDSAPoseidon();
-            this._privateKey = eddsa.privateKey;
-        }
+        const eddsa = new eddsaPoseidon.EdDSAPoseidon(privateKey);
+        this._privateKey = eddsa.privateKey;
         this._secretScalar = eddsa.secretScalar;
         this._publicKey = eddsa.publicKey;
         this._commitment = poseidon2_2(this._publicKey);
     }
     /**
      * Returns the private key.
-     * @returns The private key as a string (hexadecimal or text).
+     * @returns The private key as a buffer or text.
      */
     get privateKey() {
         return this._privateKey;
@@ -2127,6 +2290,25 @@ class Identity {
     get commitment() {
         return this._commitment;
     }
+    /**
+     * Returns the private key encoded as a base64 string.
+     * @returns The private key as a base64 string.
+     */
+    export() {
+        if (isString(this._privateKey)) {
+            return textToBase64(this._privateKey);
+        }
+        return bufferToBase64(this.privateKey);
+    }
+    /**
+     * Returns a Semaphore identity based on a private key encoded as a base64 string.
+     * The private key will be converted to a buffer, regardless of its original type.
+     * @param privateKey The private key as a base64 string.
+     * @returns The Semaphore identity.
+     */
+    static import(privateKey) {
+        return new Identity(base64ToBuffer(privateKey));
+    }
     /**
      * Generates a signature for a given message using the private key.
      * This method demonstrates how to sign a message and could be used
@@ -2140,10 +2322,7 @@ class Identity {
      * @returns A {@link https://zkkit.pse.dev/types/_zk_kit_eddsa_poseidon.Signature.html | Signature} object containing the signature components.
      */
     signMessage(message) {
-        const privateKey = isHexadecimal(this.privateKey, false)
-            ? hexadecimalToBuffer(this.privateKey)
-            : this.privateKey;
-        return eddsaPoseidon.signMessage(privateKey, message);
+        return eddsaPoseidon.signMessage(this.privateKey, message);
     }
     /**
      * Verifies a signature against a given message and public key.

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/identity
- * @version 4.0.0-beta.12
+ * @version 4.0.0-beta.13
  * @file A library to create Semaphore identities.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -1867,12 +1867,42 @@ getDefaultExportFromCjs(buffer);
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
+/**
+ * @module TypeChecks
+ * This module provides utility functions to check data types.
+ * It defines a set of supported types and includes functions to check if
+ * a value is defined and if it matches a supported type. These functions
+ * are useful for type checking and validation in the other libraries,
+ * enhancing code robustness and reliability.
+ */
+/** @internal */
+const supportedTypes = [
+    "number",
+    "string",
+    "function",
+    "Array",
+    "Uint8Array",
+    "Buffer",
+    "object",
+    "bigint",
+    "stringified-bigint",
+    "hexadecimal",
+    "bignumber",
+    "bignumberish"
+];
+/**
+ * Returns true if the value is a number, false otherwise.
+ * @param value The value to be checked.
+ */
+function isNumber(value) {
+    return typeof value === "number";
+}
 /**
  * Returns true if the value is a string, false otherwise.
  * @param value The value to be checked.
@@ -1880,6 +1910,65 @@ getDefaultExportFromCjs(buffer);
 function isString(value) {
     return typeof value === "string";
 }
+/**
+ * Returns true if the value is a function, false otherwise.
+ * @param value The value to be checked.
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * Returns true if the value is an object, false otherwise.
+ * Please, note that arrays are also objects in JavaScript.
+ * @param value The value to be checked.
+ */
+function isObject(value) {
+    return typeof value === "object";
+}
+/**
+ * Returns true if the value is an Array instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isArray(value) {
+    return isObject(value) && Array.isArray(value);
+}
+/**
+ * Returns true if the value is a Uint8Array instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+/**
+ * Returns true if the value is a Buffer instance, false otherwise.
+ * @param value The value to be checked.
+ */
+function isBuffer(value) {
+    return buffer.Buffer.isBuffer(value);
+}
+/**
+ * Returns true if the value is a bigint, false otherwise.
+ * @param value The value to be checked.
+ */
+function isBigInt(value) {
+    return typeof value === "bigint";
+}
+/**
+ * Checks if the given value is a string that represents a valid bigint.
+ * @param value The value to be checked if it's a stringified bigint.
+ */
+function isStringifiedBigInt(value) {
+    if (!isString(value)) {
+        return false;
+    }
+    try {
+        BigInt(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Checks if a string is a valid hexadecimal string representation.
  * If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more
@@ -1897,10 +1986,79 @@ function isHexadecimal(value, prefix = true) {
     }
     return /^[0-9a-fA-F]+$/.test(value);
 }
+/**
+ * Checks if the given value can be considered as BigNumber.
+ * A value is considered a BigNumber if it is a bigint or a string
+ * that can be converted to a bigint (via `Bigint(s)`).
+ * @param value The value to check.
+ */
+function isBigNumber(value) {
+    return isBigInt(value) || isStringifiedBigInt(value);
+}
+/**
+ * Checks if the given value can be considered as BigNumberish.
+ * A value is considered BigNumberish if it meets
+ * any of the following conditions: it's a number, a bigint, a string
+ * that can be converted to a bigint, a hexadecimal
+ * string, or a Buffer object.
+ * @param value The value to check.
+ */
+function isBigNumberish(value) {
+    return (isNumber(value) ||
+        isBigInt(value) ||
+        isStringifiedBigInt(value) ||
+        isHexadecimal(value) ||
+        isBuffer(value) ||
+        isUint8Array(value));
+}
+/**
+ * Returns true if the value type is the same as the type passed
+ * as the second parameter, false otherwise.
+ * @param value
+ * @param type The expected type.
+ */
+function isType(value, type) {
+    switch (type) {
+        case "number":
+            return isNumber(value);
+        case "string":
+            return isString(value);
+        case "function":
+            return isFunction(value);
+        case "Array":
+            return isArray(value);
+        case "Uint8Array":
+            return isUint8Array(value);
+        case "Buffer":
+            return isBuffer(value);
+        case "object":
+            return isObject(value);
+        case "bigint":
+            return isBigInt(value);
+        case "stringified-bigint":
+            return isStringifiedBigInt(value);
+        case "hexadecimal":
+            return isHexadecimal(value);
+        case "bignumber":
+            return isBigNumber(value);
+        case "bignumberish":
+            return isBigNumberish(value);
+        default:
+            return false;
+    }
+}
+/**
+ * Returns true if the type is being supported by this utility
+ * functions, false otherwise.
+ * @param type The type to be checked.
+ */
+function isSupportedType(type) {
+    return supportedTypes.includes(type);
+}
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -1917,40 +2075,60 @@ function requireString(parameterValue, parameterName) {
     }
 }
 /**
- * @throws Throws a type error if the parameter value is not a hexadecimal string.
- * If 'prefix' is 'true', the string must start with '0x' or '0X' followed by one or more
- * hexadecimal digits (0-9, a-f, A-F), otherwise no prefix is expected. 'prefix' is optional and
- * if its value it is not explicitly defined it will be set to 'true' by default.
+ * @throws Throws a type error if the parameter value type is not part of the list of types.
  * @param parameterValue The parameter value.
  * @param parameterName The parameter name.
- * @param prefix A boolean to include or not a '0x' or '0X' prefix.
  */
-function requireHexadecimal(parameterValue, parameterName, prefix = true) {
-    if (!isHexadecimal(parameterValue, prefix)) {
-        throw new TypeError(`Parameter '${parameterName}' is not a hexadecimal string`);
+function requireTypes(parameterValue, parameterName, types) {
+    for (const type of types) {
+        if (!isSupportedType(type)) {
+            throw new Error(`Type '${type}' is not supported`);
+        }
     }
+    for (const type of types) {
+        if (isType(parameterValue, type)) {
+            return;
+        }
+    }
+    throw new TypeError(`Parameter '${parameterName}' is none of the following types: ${types.join(", ")}`);
 }
 
 /**
  * @module @zk-kit/utils
- * @version 1.0.0-beta.5
+ * @version 1.2.0
  * @file Essential zero-knowledge utility library for JavaScript developers.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
 /**
- * Converts an hexadecimal string to a buffer. The hexadecimal string
- * should not start with '0x' or '0X'. It keeps the bytes in the same order.
- * @param value The hexadecimal string to convert.
- * @returns The buffer representation of the hexadecimal string.
+ * Converts bytes to a base64 string. It accepts 'Buffer' or 'Uint8Array'.
+ * @param value The bytes to convert.
+ * @returns The converted base64 string.
  */
-function hexadecimalToBuffer(value) {
-    requireHexadecimal(value, "value", false);
-    if (value.length % 2 !== 0) {
-        value = `0${value}`;
-    }
-    return buffer.Buffer.from(value, "hex");
+function bufferToBase64(value) {
+    requireTypes(value, "value", ["Buffer", "Uint8Array"]);
+    return buffer.Buffer.from(value).toString("base64");
+}
+/**
+ * Converts a base64 string to bytes (i.e. a buffer). This function does not check
+ * if the input value is a valid base64 string. If there are unsupported characters
+ * they will be ignored.
+ * @param value The base64 string to convert.
+ * @returns The converted buffer.
+ */
+function base64ToBuffer(value) {
+    requireString(value, "value");
+    return buffer.Buffer.from(value, "base64");
+}
+/**
+ * Converts text (utf8) to a base64 string.
+ * @param value The text to convert.
+ * @returns The converted base64 string.
+ */
+function textToBase64(value) {
+    requireString(value, "value");
+    return buffer.Buffer.from(value, "utf8").toString("base64");
 }
 
 var poseidon2$1 = {};
@@ -2057,14 +2235,12 @@ function poseidon2(inputs) {
  * and {@link https://www.poseidon-hash.info | Poseidon} for signatures.
  * In addition, the commitment, i.e. the hash of the public key, is used to represent
  * Semaphore identities in groups, adding an additional layer of privacy and security.
- * The private key of the identity is stored as a hexadecimal string or text.
- * The other attributes are stored as stringified bigint.
+ * The private key of the identity can be exported as a base64 string.
  */
 class Identity {
     /**
-     * Initializes the class attributes based on a given private key, which must be a hexadecimal string or a text.
-     * Hexadecimal strings must not start with '0x' or '0X'.
-     * If the private key is not passed as a parameter, a random hexadecimal key will be generated.
+     * Initializes the class attributes based on a given private key, which must be text or a buffer.
+     * If the private key is not passed as a parameter, a random private key will be generated.
      * The EdDSAPoseidon class is used to generate the secret scalar and the public key.
      * Additionally, the constructor computes a commitment of the public key using a hash function (Poseidon).
      *
@@ -2078,28 +2254,15 @@ class Identity {
      * @param privateKey The private key used to derive the public key (hexadecimal or string).
      */
     constructor(privateKey) {
-        let eddsa;
-        if (privateKey) {
-            requireString(privateKey, "privateKey");
-            this._privateKey = privateKey;
-            if (isHexadecimal(privateKey, false)) {
-                eddsa = new EdDSAPoseidon(hexadecimalToBuffer(privateKey));
-            }
-            else {
-                eddsa = new EdDSAPoseidon(privateKey);
-            }
-        }
-        else {
-            eddsa = new EdDSAPoseidon();
-            this._privateKey = eddsa.privateKey;
-        }
+        const eddsa = new EdDSAPoseidon(privateKey);
+        this._privateKey = eddsa.privateKey;
         this._secretScalar = eddsa.secretScalar;
         this._publicKey = eddsa.publicKey;
         this._commitment = poseidon2_2(this._publicKey);
     }
     /**
      * Returns the private key.
-     * @returns The private key as a string (hexadecimal or text).
+     * @returns The private key as a buffer or text.
      */
     get privateKey() {
         return this._privateKey;
@@ -2125,6 +2288,25 @@ class Identity {
     get commitment() {
         return this._commitment;
     }
+    /**
+     * Returns the private key encoded as a base64 string.
+     * @returns The private key as a base64 string.
+     */
+    export() {
+        if (isString(this._privateKey)) {
+            return textToBase64(this._privateKey);
+        }
+        return bufferToBase64(this.privateKey);
+    }
+    /**
+     * Returns a Semaphore identity based on a private key encoded as a base64 string.
+     * The private key will be converted to a buffer, regardless of its original type.
+     * @param privateKey The private key as a base64 string.
+     * @returns The Semaphore identity.
+     */
+    static import(privateKey) {
+        return new Identity(base64ToBuffer(privateKey));
+    }
     /**
      * Generates a signature for a given message using the private key.
      * This method demonstrates how to sign a message and could be used
@@ -2138,10 +2320,7 @@ class Identity {
      * @returns A {@link https://zkkit.pse.dev/types/_zk_kit_eddsa_poseidon.Signature.html | Signature} object containing the signature components.
      */
     signMessage(message) {
-        const privateKey = isHexadecimal(this.privateKey, false)
-            ? hexadecimalToBuffer(this.privateKey)
-            : this.privateKey;
-        return signMessage(privateKey, message);
+        return signMessage(this.privateKey, message);
     }
     /**
      * Verifies a signature against a given message and public key.

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { Point } from "@zk-kit/baby-jubjub";
 import { Signature } from "@zk-kit/eddsa-poseidon";
 import type { BigNumberish } from "@zk-kit/utils";
@@ -8,8 +9,7 @@ import type { BigNumberish } from "@zk-kit/utils";
  * and {@link https://www.poseidon-hash.info | Poseidon} for signatures.
  * In addition, the commitment, i.e. the hash of the public key, is used to represent
  * Semaphore identities in groups, adding an additional layer of privacy and security.
- * The private key of the identity is stored as a hexadecimal string or text.
- * The other attributes are stored as stringified bigint.
+ * The private key of the identity can be exported as a base64 string.
  */
 export declare class Identity {
     private _privateKey;
@@ -17,9 +17,8 @@ export declare class Identity {
     private _publicKey;
     private _commitment;
     /**
-     * Initializes the class attributes based on a given private key, which must be a hexadecimal string or a text.
-     * Hexadecimal strings must not start with '0x' or '0X'.
-     * If the private key is not passed as a parameter, a random hexadecimal key will be generated.
+     * Initializes the class attributes based on a given private key, which must be text or a buffer.
+     * If the private key is not passed as a parameter, a random private key will be generated.
      * The EdDSAPoseidon class is used to generate the secret scalar and the public key.
      * Additionally, the constructor computes a commitment of the public key using a hash function (Poseidon).
      *
@@ -32,12 +31,12 @@ export declare class Identity {
      *
      * @param privateKey The private key used to derive the public key (hexadecimal or string).
      */
-    constructor(privateKey?: string);
+    constructor(privateKey?: string | Buffer | Uint8Array);
     /**
      * Returns the private key.
-     * @returns The private key as a string (hexadecimal or text).
+     * @returns The private key as a buffer or text.
      */
-    get privateKey(): string;
+    get privateKey(): string | Buffer | Uint8Array;
     /**
      * Returns the secret scalar.
      * @returns The secret scalar as a string.
@@ -53,6 +52,18 @@ export declare class Identity {
      * @returns The commitment as a string.
      */
     get commitment(): bigint;
+    /**
+     * Returns the private key encoded as a base64 string.
+     * @returns The private key as a base64 string.
+     */
+    export(): string;
+    /**
+     * Returns a Semaphore identity based on a private key encoded as a base64 string.
+     * The private key will be converted to a buffer, regardless of its original type.
+     * @param privateKey The private key as a base64 string.
+     * @returns The Semaphore identity.
+     */
+    static import(privateKey: string): Identity;
     /**
      * Generates a signature for a given message using the private key.
      * This method demonstrates how to sign a message and could be used

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/identity",
-  "version": "4.0.0-beta.12",
+  "version": "4.0.0-beta.13",
   "description": "A library to create Semaphore identities.",
   "type": "module",
   "license": "MIT",
@@ -40,8 +40,8 @@
   },
   "dependencies": {
     "@zk-kit/baby-jubjub": "1.0.1",
-    "@zk-kit/eddsa-poseidon": "1.0.1",
-    "@zk-kit/utils": "1.0.0",
+    "@zk-kit/eddsa-poseidon": "1.0.2",
+    "@zk-kit/utils": "1.2.0",
     "poseidon-lite": "0.2.0"
   }
 }

package/src/index.ts

@@ -1,9 +1,8 @@
 import type { Point } from "@zk-kit/baby-jubjub"
 import { EdDSAPoseidon, Signature, signMessage, verifySignature } from "@zk-kit/eddsa-poseidon"
 import type { BigNumberish } from "@zk-kit/utils"
-import { hexadecimalToBuffer } from "@zk-kit/utils/conversions"
-import { requireString } from "@zk-kit/utils/error-handlers"
-import { isHexadecimal } from "@zk-kit/utils/type-checks"
+import { base64ToBuffer, bufferToBase64, textToBase64 } from "@zk-kit/utils/conversions"
+import { isString } from "@zk-kit/utils/type-checks"
 import { poseidon2 } from "poseidon-lite/poseidon2"
 
 /**
@@ -13,12 +12,11 @@ import { poseidon2 } from "poseidon-lite/poseidon2"
  * and {@link https://www.poseidon-hash.info | Poseidon} for signatures.
  * In addition, the commitment, i.e. the hash of the public key, is used to represent
  * Semaphore identities in groups, adding an additional layer of privacy and security.
- * The private key of the identity is stored as a hexadecimal string or text.
- * The other attributes are stored as stringified bigint.
+ * The private key of the identity can be exported as a base64 string.
  */
 export class Identity {
     // The EdDSA private key, passed as a parameter or generated randomly.
-    private _privateKey: string
+    private _privateKey: string | Buffer | Uint8Array
     // The secret scalar derived from the private key.
     // It is used in circuits to derive the public key.
     private _secretScalar: bigint
@@ -28,9 +26,8 @@ export class Identity {
     private _commitment: bigint
 
     /**
-     * Initializes the class attributes based on a given private key, which must be a hexadecimal string or a text.
-     * Hexadecimal strings must not start with '0x' or '0X'.
-     * If the private key is not passed as a parameter, a random hexadecimal key will be generated.
+     * Initializes the class attributes based on a given private key, which must be text or a buffer.
+     * If the private key is not passed as a parameter, a random private key will be generated.
      * The EdDSAPoseidon class is used to generate the secret scalar and the public key.
      * Additionally, the constructor computes a commitment of the public key using a hash function (Poseidon).
      *
@@ -43,25 +40,10 @@ export class Identity {
      *
      * @param privateKey The private key used to derive the public key (hexadecimal or string).
      */
-    constructor(privateKey?: string) {
-        let eddsa: EdDSAPoseidon
-
-        if (privateKey) {
-            requireString(privateKey, "privateKey")
-
-            this._privateKey = privateKey
-
-            if (isHexadecimal(privateKey, false)) {
-                eddsa = new EdDSAPoseidon(hexadecimalToBuffer(privateKey))
-            } else {
-                eddsa = new EdDSAPoseidon(privateKey)
-            }
-        } else {
-            eddsa = new EdDSAPoseidon()
-
-            this._privateKey = eddsa.privateKey as string
-        }
+    constructor(privateKey?: string | Buffer | Uint8Array) {
+        const eddsa = new EdDSAPoseidon(privateKey)
 
+        this._privateKey = eddsa.privateKey
         this._secretScalar = eddsa.secretScalar
         this._publicKey = eddsa.publicKey
         this._commitment = poseidon2(this._publicKey)
@@ -69,9 +51,9 @@ export class Identity {
 
     /**
      * Returns the private key.
-     * @returns The private key as a string (hexadecimal or text).
+     * @returns The private key as a buffer or text.
      */
-    public get privateKey(): string {
+    public get privateKey(): string | Buffer | Uint8Array {
         return this._privateKey
     }
 
@@ -99,6 +81,28 @@ export class Identity {
         return this._commitment
     }
 
+    /**
+     * Returns the private key encoded as a base64 string.
+     * @returns The private key as a base64 string.
+     */
+    public export(): string {
+        if (isString(this._privateKey)) {
+            return textToBase64(this._privateKey as string)
+        }
+
+        return bufferToBase64(this.privateKey as Buffer | Uint8Array)
+    }
+
+    /**
+     * Returns a Semaphore identity based on a private key encoded as a base64 string.
+     * The private key will be converted to a buffer, regardless of its original type.
+     * @param privateKey The private key as a base64 string.
+     * @returns The Semaphore identity.
+     */
+    static import(privateKey: string): Identity {
+        return new Identity(base64ToBuffer(privateKey))
+    }
+
     /**
      * Generates a signature for a given message using the private key.
      * This method demonstrates how to sign a message and could be used
@@ -112,11 +116,7 @@ export class Identity {
      * @returns A {@link https://zkkit.pse.dev/types/_zk_kit_eddsa_poseidon.Signature.html | Signature} object containing the signature components.
      */
     public signMessage(message: BigNumberish): Signature<bigint> {
-        const privateKey = isHexadecimal(this.privateKey, false)
-            ? hexadecimalToBuffer(this.privateKey)
-            : this.privateKey
-
-        return signMessage(privateKey, message)
+        return signMessage(this.privateKey, message)
     }
 
     /**