@degenerate/rules 0.1.1 → 0.1.3

package/dist/generic/src/_settings/cryptography-settings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This contains the settings for the proofs around encryption, hashing and signing.
+ */
+import * as crypto from 'crypto';
+/**
+ * This contains the settings for the cryptography. settings
+ */
+export declare const CryptoSettings: {
+    TextEncoding: crypto.Encoding;
+    Hash: {
+        Algorithm: string;
+        Digest: crypto.BinaryToTextEncoding;
+    };
+};
+/**
+ * This contains the values for the elliptical curvers for encryption
+ */
+export declare enum EllipticalCurvesEncryption {
+    Curve25519 = "curve25519"
+}
+/**
+ * This contains the values for the elliptical curvers for signing
+ */
+export declare enum EllipticalCurvesSigning {
+    Curve25519 = "ed25519"
+}
+//# sourceMappingURL=cryptography-settings.d.ts.map

package/dist/generic/src/_settings/cryptography-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cryptography-settings.d.ts","sourceRoot":"","sources":["../../../../../generic/src/_settings/cryptography-settings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC;;GAEG;AACH,eAAO,MAAM,cAAc;kBACC,MAAM,CAAC,QAAQ;;;gBAGlB,MAAM,CAAC,oBAAoB;;CAEnD,CAAC;AAEF;;GAEG;AACH,oBAAY,0BAA0B;IAClC,UAAU,eAAe;CAC5B;AAED;;GAEG;AACH,oBAAY,uBAAuB;IAC/B,UAAU,YAAY;CACzB"}

package/dist/generic/src/_settings/cryptography-settings.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EllipticalCurvesSigning = exports.EllipticalCurvesEncryption = exports.CryptoSettings = void 0;
+/**
+ * This contains the settings for the cryptography. settings
+ */
+exports.CryptoSettings = {
+    TextEncoding: 'utf8', // "utf8" | "ascii" | "latin1"
+    Hash: {
+        Algorithm: 'sha256',
+        Digest: 'hex', // "hex" | "base64" | "base64url" | "binary"
+    },
+};
+/**
+ * This contains the values for the elliptical curvers for encryption
+ */
+var EllipticalCurvesEncryption;
+(function (EllipticalCurvesEncryption) {
+    EllipticalCurvesEncryption["Curve25519"] = "curve25519";
+})(EllipticalCurvesEncryption || (exports.EllipticalCurvesEncryption = EllipticalCurvesEncryption = {}));
+/**
+ * This contains the values for the elliptical curvers for signing
+ */
+var EllipticalCurvesSigning;
+(function (EllipticalCurvesSigning) {
+    EllipticalCurvesSigning["Curve25519"] = "ed25519";
+})(EllipticalCurvesSigning || (exports.EllipticalCurvesSigning = EllipticalCurvesSigning = {}));

package/dist/generic/src/crypto/calculate-combined-hash.d.ts

@@ -0,0 +1,13 @@
+import * as crypto from 'crypto';
+/**
+ * Calculates a combined hash from the input string and the previous hash.
+ *
+ * @param timestamp - The timestamp to be included in the new hash.
+ * @param inputString - The input string to be hashed.
+ * @param previousHash - The previous hash to be included in the new hash.
+ * @param encoding - The encoding to use for the hash.
+ * @returns The combined hash.
+ */
+declare const calculateCombinedHash: (timestamp: number, inputString: string, previousHash: string, encoding: crypto.BinaryToTextEncoding) => string;
+export { calculateCombinedHash };
+//# sourceMappingURL=calculate-combined-hash.d.ts.map

package/dist/generic/src/crypto/calculate-combined-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-combined-hash.d.ts","sourceRoot":"","sources":["../../../../../generic/src/crypto/calculate-combined-hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAGjC;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,cAAe,MAAM,eAAe,MAAM,gBAAgB,MAAM,YAC7E,MAAM,CAAC,oBAAoB,KAAG,MAK3C,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/generic/src/crypto/calculate-combined-hash.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCombinedHash = void 0;
+const crypto = __importStar(require("crypto"));
+const cryptography_settings_1 = require("../_settings/cryptography-settings");
+/**
+ * Calculates a combined hash from the input string and the previous hash.
+ *
+ * @param timestamp - The timestamp to be included in the new hash.
+ * @param inputString - The input string to be hashed.
+ * @param previousHash - The previous hash to be included in the new hash.
+ * @param encoding - The encoding to use for the hash.
+ * @returns The combined hash.
+ */
+const calculateCombinedHash = (timestamp, inputString, previousHash, encoding) => {
+    const stringifiedFunctionAndPreviousHash = `${timestamp}${inputString}${previousHash}`;
+    const combinedHash = crypto.createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm)
+        .update(stringifiedFunctionAndPreviousHash).digest(encoding);
+    return combinedHash;
+};
+exports.calculateCombinedHash = calculateCombinedHash;

package/dist/generic/src/crypto/calculate-hash.d.ts

@@ -0,0 +1,7 @@
+import * as crypto from 'crypto';
+/**
+ * Calculates the hash of the input string.
+ */
+declare const calculateHash: (inputString: string, encoding: crypto.BinaryToTextEncoding) => string;
+export { calculateHash };
+//# sourceMappingURL=calculate-hash.d.ts.map

package/dist/generic/src/crypto/calculate-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-hash.d.ts","sourceRoot":"","sources":["../../../../../generic/src/crypto/calculate-hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAGjC;;GAEG;AACH,QAAA,MAAM,aAAa,gBAAiB,MAAM,YAAY,MAAM,CAAC,oBAAoB,KAAG,MAInF,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/generic/src/crypto/calculate-hash.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateHash = void 0;
+const crypto = __importStar(require("crypto"));
+const cryptography_settings_1 = require("../_settings/cryptography-settings");
+/**
+ * Calculates the hash of the input string.
+ */
+const calculateHash = (inputString, encoding) => {
+    const combinedHash = crypto.createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm)
+        .update(inputString).digest(encoding);
+    return combinedHash;
+};
+exports.calculateHash = calculateHash;

package/dist/generic/src/crypto/index.d.ts

@@ -0,0 +1,13 @@
+export * from './calculate-hash';
+export * from './calculate-combined-hash';
+export * from './private-public-keys/generation/create-256-private-key-from-mnemonic';
+export * from './private-public-keys/generation/create-entropy-for-elliptical-curve';
+export * from './private-public-keys/generation/create-random-256-private-key';
+export * from './private-public-keys/generation/generate-key-pair';
+export * from './private-public-keys/generation/get-private-public-key-from-keypair';
+export * from './private-public-keys/create-key-pair-from-private-key';
+export * from './private-public-keys/create-key-pair-from-mnemonic';
+export * from './signature/create-crypto-signature';
+export * from './signature/verify-crypto-signature-by-data';
+export * from './signature/verify-crypto-signature-by-hash';
+//# sourceMappingURL=index.d.ts.map

package/dist/generic/src/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../generic/src/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAK1C,cAAc,uEAAuE,CAAC;AACtF,cAAc,sEAAsE,CAAC;AACrF,cAAc,gEAAgE,CAAC;AAC/E,cAAc,oDAAoD,CAAC;AACnE,cAAc,sEAAsE,CAAC;AAGrF,cAAc,wDAAwD,CAAC;AACvE,cAAc,qDAAqD,CAAC;AAMpE,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC"}

package/dist/generic/src/crypto/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculate-hash"), exports);
+__exportStar(require("./calculate-combined-hash"), exports);
+//#region folder private-public-keys
+//#region folder generation
+__exportStar(require("./private-public-keys/generation/create-256-private-key-from-mnemonic"), exports);
+__exportStar(require("./private-public-keys/generation/create-entropy-for-elliptical-curve"), exports);
+__exportStar(require("./private-public-keys/generation/create-random-256-private-key"), exports);
+__exportStar(require("./private-public-keys/generation/generate-key-pair"), exports);
+__exportStar(require("./private-public-keys/generation/get-private-public-key-from-keypair"), exports);
+//#endregion folder generation
+__exportStar(require("./private-public-keys/create-key-pair-from-private-key"), exports);
+__exportStar(require("./private-public-keys/create-key-pair-from-mnemonic"), exports);
+//#endregion folder private-public-keys
+//#region folder signature
+__exportStar(require("./signature/create-crypto-signature"), exports);
+__exportStar(require("./signature/verify-crypto-signature-by-data"), exports);
+__exportStar(require("./signature/verify-crypto-signature-by-hash"), exports);
+//#endregion folder signature

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-mnemonic.d.ts

@@ -0,0 +1,12 @@
+import * as Elliptic from 'elliptic';
+import { EllipticalCurvesSigning, EllipticalCurvesEncryption } from '../../_settings/cryptography-settings';
+/**
+ * This function creates a key pair from a mnemonic using the elliptic library.
+ *
+ * @param curve the elliptical curve to create the key pair for.
+ * @param mnemonic the mnemonic to create the key pair from.
+ * @returns
+ */
+declare const createKeyPairFromMnemonic: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, mnemonic: string) => Elliptic.ec.KeyPair;
+export { createKeyPairFromMnemonic };
+//# sourceMappingURL=create-key-pair-from-mnemonic.d.ts.map

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-key-pair-from-mnemonic.d.ts","sourceRoot":"","sources":["../../../../../../generic/src/crypto/private-public-keys/create-key-pair-from-mnemonic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAkB,MAAM,uCAAuC,CAAC;AAE5H;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,UAAW,uBAAuB,GAAG,0BAA0B,YAAY,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAO9H,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-mnemonic.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyPairFromMnemonic = void 0;
+/* eslint-disable new-cap */
+const Elliptic = __importStar(require("elliptic"));
+const crypto = __importStar(require("crypto"));
+const cryptography_settings_1 = require("../../_settings/cryptography-settings");
+/**
+ * This function creates a key pair from a mnemonic using the elliptic library.
+ *
+ * @param curve the elliptical curve to create the key pair for.
+ * @param mnemonic the mnemonic to create the key pair from.
+ * @returns
+ */
+const createKeyPairFromMnemonic = (curve, mnemonic) => {
+    const ellipticalCurve = new Elliptic.ec(curve);
+    const hash = crypto.createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm).update(mnemonic, cryptography_settings_1.CryptoSettings.TextEncoding).digest(cryptography_settings_1.CryptoSettings.Hash.Digest);
+    const keyPair = ellipticalCurve.keyFromPrivate(hash);
+    return keyPair;
+};
+exports.createKeyPairFromMnemonic = createKeyPairFromMnemonic;

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-private-key.d.ts

@@ -0,0 +1,11 @@
+import * as Elliptic from 'elliptic';
+import { EllipticalCurvesSigning, EllipticalCurvesEncryption } from '../../_settings/cryptography-settings';
+/**
+ * This function creates a key pair from a private key using the elliptic library.
+ * @param curve the elliptical curve to create the key pair for.
+ * @param privateKey the private key in hexadecimal format.
+ * @returns
+ */
+declare const createKeyPairFromPrivateKey: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, privateKey: string) => Elliptic.ec.KeyPair;
+export { createKeyPairFromPrivateKey };
+//# sourceMappingURL=create-key-pair-from-private-key.d.ts.map

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-private-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-key-pair-from-private-key.d.ts","sourceRoot":"","sources":["../../../../../../generic/src/crypto/private-public-keys/create-key-pair-from-private-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AAE5G;;;;;GAKG;AACH,QAAA,MAAM,2BAA2B,UAAW,uBAAuB,GAAG,0BAA0B,cAChF,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAMpC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/create-key-pair-from-private-key.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyPairFromPrivateKey = void 0;
+/* eslint-disable new-cap */
+const Elliptic = __importStar(require("elliptic"));
+/**
+ * This function creates a key pair from a private key using the elliptic library.
+ * @param curve the elliptical curve to create the key pair for.
+ * @param privateKey the private key in hexadecimal format.
+ * @returns
+ */
+const createKeyPairFromPrivateKey = (curve, privateKey) => {
+    const ellipticalCurve = new Elliptic.ec(curve);
+    const keyPair = ellipticalCurve.keyFromPrivate(privateKey);
+    return keyPair;
+};
+exports.createKeyPairFromPrivateKey = createKeyPairFromPrivateKey;

package/dist/generic/src/crypto/private-public-keys/generation/create-256-private-key-from-mnemonic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a random private key from the mnemonic phrase.
+ *
+ * @returns A random private key as a hexadecimal string.
+ */
+declare const create256PrivateKeyFromMnemonic: () => {
+    privateKey: string;
+    mnemonic: string;
+};
+export { create256PrivateKeyFromMnemonic };
+//# sourceMappingURL=create-256-private-key-from-mnemonic.d.ts.map

package/dist/generic/src/crypto/private-public-keys/generation/create-256-private-key-from-mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-256-private-key-from-mnemonic.d.ts","sourceRoot":"","sources":["../../../../../../../generic/src/crypto/private-public-keys/generation/create-256-private-key-from-mnemonic.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,QAAA,MAAM,+BAA+B,QAAO;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAWjF,CAAC;AAEF,OAAO,EAAE,+BAA+B,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/generation/create-256-private-key-from-mnemonic.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create256PrivateKeyFromMnemonic = void 0;
+const crypto = __importStar(require("crypto"));
+const bip39 = __importStar(require("bip39"));
+const cryptography_settings_1 = require("../../../_settings/cryptography-settings");
+/**
+ * Generates a random private key from the mnemonic phrase.
+ *
+ * @returns A random private key as a hexadecimal string.
+ */
+const create256PrivateKeyFromMnemonic = () => {
+    // Generate a random mnemonic phrase
+    const mnemonic = bip39.generateMnemonic(256); // 256 bits is the strength of the mnemonic
+    // Create a SHA-256 hash of the mnemonic
+    const hash = crypto.createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm).update(mnemonic, cryptography_settings_1.CryptoSettings.TextEncoding).digest(cryptography_settings_1.CryptoSettings.Hash.Digest);
+    return {
+        privateKey: hash,
+        mnemonic: mnemonic,
+    };
+};
+exports.create256PrivateKeyFromMnemonic = create256PrivateKeyFromMnemonic;

package/dist/generic/src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.d.ts

@@ -0,0 +1,10 @@
+import { EllipticalCurvesEncryption, EllipticalCurvesSigning } from '../../../_settings/cryptography-settings';
+/**
+ * Creates entropy for an elliptical curve.
+ *
+ * @param signingCurve - The elliptical curve to create entropy for.
+ * @returns The entropy for the elliptical curve.
+ */
+declare const createEntropyForEllipitalCurve: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption) => string;
+export { createEntropyForEllipitalCurve };
+//# sourceMappingURL=create-entropy-for-elliptical-curve.d.ts.map

package/dist/generic/src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-entropy-for-elliptical-curve.d.ts","sourceRoot":"","sources":["../../../../../../../generic/src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AAG/G;;;;;GAKG;AACH,QAAA,MAAM,8BAA8B,UAAW,uBAAuB,GAAG,0BAA0B,KAAG,MAOrG,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/generation/create-entropy-for-elliptical-curve.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntropyForEllipitalCurve = void 0;
+const Elliptic = __importStar(require("elliptic"));
+/**
+ * Creates entropy for an elliptical curve.
+ *
+ * @param signingCurve - The elliptical curve to create entropy for.
+ * @returns The entropy for the elliptical curve.
+ */
+const createEntropyForEllipitalCurve = (curve) => {
+    const ecKey = new Elliptic.ec(curve);
+    const hashStrength = ecKey.hash.hmacStrength;
+    const entropy = Elliptic.rand(hashStrength);
+    return entropy;
+};
+exports.createEntropyForEllipitalCurve = createEntropyForEllipitalCurve;

package/dist/generic/src/crypto/private-public-keys/generation/create-random-256-private-key.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a random private key 256 bits in length.
+ *
+ * @returns A random private key (256 bits) as a hexadecimal string.
+ */
+declare const createRandom256PrivateKey: () => string;
+export { createRandom256PrivateKey };
+//# sourceMappingURL=create-random-256-private-key.d.ts.map

package/dist/generic/src/crypto/private-public-keys/generation/create-random-256-private-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-random-256-private-key.d.ts","sourceRoot":"","sources":["../../../../../../../generic/src/crypto/private-public-keys/generation/create-random-256-private-key.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,QAAA,MAAM,yBAAyB,QAAO,MAQrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/generation/create-random-256-private-key.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRandom256PrivateKey = void 0;
+const crypto = __importStar(require("crypto"));
+const cryptography_settings_1 = require("../../../_settings/cryptography-settings");
+/**
+ * Generates a random private key 256 bits in length.
+ *
+ * @returns A random private key (256 bits) as a hexadecimal string.
+ */
+const createRandom256PrivateKey = () => {
+    // Generate 32 random bytes
+    const randomBytes = crypto.randomBytes(32);
+    // Create a SHA-256 hash of the random bytes
+    const hash = crypto.createHash(cryptography_settings_1.CryptoSettings.Hash.Algorithm).update(randomBytes).digest(cryptography_settings_1.CryptoSettings.Hash.Digest);
+    return hash;
+};
+exports.createRandom256PrivateKey = createRandom256PrivateKey;

package/dist/generic/src/crypto/private-public-keys/generation/generate-key-pair.d.ts

@@ -0,0 +1,11 @@
+import { EllipticalCurvesSigning, EllipticalCurvesEncryption } from '../../../_settings/cryptography-settings';
+import * as Elliptic from 'elliptic';
+/**
+ * This function generates a key pair from a private key and entropy using the elliptic library.
+ *
+ * @param privateKey the private key in hexadecimal format
+ * @param entropy the entropy in hexadecimal format
+ */
+declare const generateKeyPair: (curve: EllipticalCurvesSigning | EllipticalCurvesEncryption, privateKey: string, entropy: string) => Elliptic.ec.KeyPair;
+export { generateKeyPair };
+//# sourceMappingURL=generate-key-pair.d.ts.map

package/dist/generic/src/crypto/private-public-keys/generation/generate-key-pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-key-pair.d.ts","sourceRoot":"","sources":["../../../../../../../generic/src/crypto/private-public-keys/generation/generate-key-pair.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,0CAA0C,CAAC;AAC/G,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;;GAKG;AACH,QAAA,MAAM,eAAe,UAAW,uBAAuB,GAAG,0BAA0B,cAAc,MAAM,WAC3F,MAAM,KAAG,QAAQ,CAAC,EAAE,CAAC,OAMjC,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/generation/generate-key-pair.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKeyPair = void 0;
+const Elliptic = __importStar(require("elliptic"));
+/**
+ * This function generates a key pair from a private key and entropy using the elliptic library.
+ *
+ * @param privateKey the private key in hexadecimal format
+ * @param entropy the entropy in hexadecimal format
+ */
+const generateKeyPair = (curve, privateKey, entropy) => {
+    const ellipticalCurve = new Elliptic.ec(curve);
+    const keyPair = ellipticalCurve.genKeyPair({ pers: privateKey, entropy: entropy });
+    return keyPair;
+};
+exports.generateKeyPair = generateKeyPair;

package/dist/generic/src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.d.ts

@@ -0,0 +1,15 @@
+import * as Elliptic from 'elliptic';
+/**
+ * This function gets the private key from a key pair.
+ *
+ * @param keyPair the key pair to get the private key from
+ */
+declare const getPrivateKeyFromKeyPair: (keyPair: Elliptic.ec.KeyPair) => string;
+/**
+ * This function gets the public key from a key pair.
+ *
+ * @param keyPair the key pair to get the public key from
+ */
+declare const getPublicKeyFromKeyPair: (keyPair: Elliptic.ec.KeyPair) => string;
+export { getPrivateKeyFromKeyPair, getPublicKeyFromKeyPair };
+//# sourceMappingURL=get-private-public-key-from-keypair.d.ts.map

package/dist/generic/src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-private-public-key-from-keypair.d.ts","sourceRoot":"","sources":["../../../../../../../generic/src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;GAIG;AACH,QAAA,MAAM,wBAAwB,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAEhE,CAAC;AAEF;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,KAAG,MAE/D,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/generic/src/crypto/private-public-keys/generation/get-private-public-key-from-keypair.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicKeyFromKeyPair = exports.getPrivateKeyFromKeyPair = void 0;
+/**
+ * This function gets the private key from a key pair.
+ *
+ * @param keyPair the key pair to get the private key from
+ */
+const getPrivateKeyFromKeyPair = (keyPair) => {
+    return keyPair.getPrivate('hex');
+};
+exports.getPrivateKeyFromKeyPair = getPrivateKeyFromKeyPair;
+/**
+ * This function gets the public key from a key pair.
+ *
+ * @param keyPair the key pair to get the public key from
+ */
+const getPublicKeyFromKeyPair = (keyPair) => {
+    return keyPair.getPublic('hex');
+};
+exports.getPublicKeyFromKeyPair = getPublicKeyFromKeyPair;

package/dist/generic/src/crypto/signature/create-crypto-signature.d.ts

@@ -0,0 +1,9 @@
+import * as Elliptic from 'elliptic';
+/**
+ * This function creates a signature for a hash using an elliptical curve.
+ * @param keyPair the key pair to use for signing.
+ * @param hashToSign the hash to sign.
+ */
+declare const createEllipticalCurveSignature: (keyPair: Elliptic.ec.KeyPair, hashToSign: string) => string;
+export { createEllipticalCurveSignature };
+//# sourceMappingURL=create-crypto-signature.d.ts.map

package/dist/generic/src/crypto/signature/create-crypto-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-crypto-signature.d.ts","sourceRoot":"","sources":["../../../../../../generic/src/crypto/signature/create-crypto-signature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC;;;;GAIG;AACH,QAAA,MAAM,8BAA8B,YAAa,QAAQ,CAAC,EAAE,CAAC,OAAO,cAAc,MAAM,KAAG,MAG1F,CAAC;AAEF,OAAO,EAAE,8BAA8B,EAAE,CAAC"}