@twin.org/crypto 0.0.2-next.20 → 0.0.2-next.22

package/dist/esm/index.mjs

@@ -24,9 +24,8 @@ import * as otp from 'micro-key-producer/otp.js';
 class Bech32 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bech32";
+    static CLASS_NAME = "Bech32";
     /**
      * Encode the buffer.
      * @param humanReadablePart The header.
@@ -34,8 +33,8 @@ class Bech32 {
      * @returns The encoded data.
      */
     static encode(humanReadablePart, data) {
-        Guards.stringValue(Bech32._CLASS_NAME, "humanReadablePart", humanReadablePart);
-        Guards.uint8Array(Bech32._CLASS_NAME, "data", data);
+        Guards.stringValue(Bech32.CLASS_NAME, "humanReadablePart", humanReadablePart);
+        Guards.uint8Array(Bech32.CLASS_NAME, "data", data);
         return bech32.encode(humanReadablePart, bech32.toWords(data));
     }
     /**
@@ -45,7 +44,7 @@ class Bech32 {
      * @throws An error if the decoding fails.
      */
     static decode(bech) {
-        Guards.stringValue(Bech32._CLASS_NAME, "bech", bech);
+        Guards.stringValue(Bech32.CLASS_NAME, "bech", bech);
         try {
             const result = bech32.decodeToBytes(bech);
             return {
@@ -55,19 +54,19 @@ class Bech32 {
         }
         catch (err) {
             if (BaseError.isErrorMessage(err, /checksum/)) {
-                throw new GeneralError(Bech32._CLASS_NAME, "invalidChecksum", { bech: bech32 });
+                throw new GeneralError(Bech32.CLASS_NAME, "invalidChecksum", { bech32 });
             }
             else if (BaseError.isErrorMessage(err, /between prefix and data only/i)) {
-                throw new GeneralError(Bech32._CLASS_NAME, "separatorMisused", { bech: bech32 });
+                throw new GeneralError(Bech32.CLASS_NAME, "separatorMisused", { bech32 });
             }
             else if (BaseError.isErrorMessage(err, /lowercase or uppercase/i)) {
-                throw new GeneralError(Bech32._CLASS_NAME, "lowerUpper", { bech: bech32 });
+                throw new GeneralError(Bech32.CLASS_NAME, "lowerUpper", { bech32 });
             }
             else if (BaseError.isErrorMessage(err, /must be at least/i) ||
                 BaseError.isErrorMessage(err, /wrong string length/i)) {
-                throw new GeneralError(Bech32._CLASS_NAME, "dataTooShort", { bech: bech32 });
+                throw new GeneralError(Bech32.CLASS_NAME, "dataTooShort", { bech32 });
             }
-            throw new GeneralError(Bech32._CLASS_NAME, "decodeFailed", { bech: bech32 }, err);
+            throw new GeneralError(Bech32.CLASS_NAME, "decodeFailed", { bech32 }, err);
         }
     }
     /**
@@ -103,9 +102,8 @@ class Ed25519 {
     static PUBLIC_KEY_SIZE = 32;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Ed25519";
+    static CLASS_NAME = "Ed25519";
     /**
      * Public returns the PublicKey corresponding to private.
      * @param privateKey The private key to get the corresponding public key.
@@ -113,9 +111,9 @@ class Ed25519 {
      * @throws Error if the private key is not the correct length.
      */
     static publicKeyFromPrivateKey(privateKey) {
-        Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -130,10 +128,10 @@ class Ed25519 {
      * @throws Error if the private key is not the correct length.
      */
     static sign(privateKey, block) {
-        Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
-        Guards.uint8Array(Ed25519._CLASS_NAME, "block", block);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "block", block);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey ? privateKey.length : 0
             });
@@ -149,11 +147,11 @@ class Ed25519 {
      * @throws Error if the public key is not the correct length.
      */
     static verify(publicKey, block, signature) {
-        Guards.uint8Array(Ed25519._CLASS_NAME, "publicKey", publicKey);
-        Guards.uint8Array(Ed25519._CLASS_NAME, "block", block);
-        Guards.uint8Array(Ed25519._CLASS_NAME, "signature", signature);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "publicKey", publicKey);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "block", block);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "signature", signature);
         if (publicKey.length !== Ed25519.PUBLIC_KEY_SIZE) {
-            throw new GeneralError(Ed25519._CLASS_NAME, "publicKeyLength", {
+            throw new GeneralError(Ed25519.CLASS_NAME, "publicKeyLength", {
                 requiredSize: Ed25519.PUBLIC_KEY_SIZE,
                 actualSize: publicKey ? publicKey.length : 0
             });
@@ -171,9 +169,9 @@ class Ed25519 {
      * @returns The private key in PKCS8 format.
      */
     static async privateKeyToPkcs8(privateKey) {
-        Guards.uint8Array(Ed25519._CLASS_NAME, "privateKey", privateKey);
+        Guards.uint8Array(Ed25519.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Ed25519.PRIVATE_KEY_SIZE) {
-            throw new GeneralError(Ed25519._CLASS_NAME, "privateKeyLength", {
+            throw new GeneralError(Ed25519.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Ed25519.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -192,7 +190,7 @@ class Ed25519 {
      * @returns The raw private key.
      */
     static async pkcs8ToPrivateKey(cryptoKey) {
-        Guards.defined(Ed25519._CLASS_NAME, "cryptoKey", cryptoKey);
+        Guards.defined(Ed25519.CLASS_NAME, "cryptoKey", cryptoKey);
         // crypto.subtle.exportKey does not support Ed25519 keys in raw format.
         // so we export as PKCS8 and remove the ASN.1 sequence prefix.
         const pkcs8Bytes = await crypto.subtle.exportKey("pkcs8", cryptoKey);
@@ -216,9 +214,8 @@ class Secp256k1 {
     static PUBLIC_KEY_SIZE = 33;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Secp256k1";
+    static CLASS_NAME = "Secp256k1";
     /**
      * Public returns the PublicKey corresponding to private.
      * @param privateKey The private key to get the corresponding public key.
@@ -226,9 +223,9 @@ class Secp256k1 {
      * @throws Error if the private key is not the correct length.
      */
     static publicKeyFromPrivateKey(privateKey) {
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "privateKey", privateKey);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "privateKey", privateKey);
         if (privateKey.length !== Secp256k1.PRIVATE_KEY_SIZE) {
-            throw new GeneralError(Secp256k1._CLASS_NAME, "privateKeyLength", {
+            throw new GeneralError(Secp256k1.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Secp256k1.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -243,10 +240,10 @@ class Secp256k1 {
      * @throws Error if the private key is not the correct length.
      */
     static sign(privateKey, block) {
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "privateKey", privateKey);
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "block", block);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "privateKey", privateKey);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "block", block);
         if (privateKey.length !== Secp256k1.PRIVATE_KEY_SIZE) {
-            throw new GeneralError(Secp256k1._CLASS_NAME, "privateKeyLength", {
+            throw new GeneralError(Secp256k1.CLASS_NAME, "privateKeyLength", {
                 requiredSize: Secp256k1.PRIVATE_KEY_SIZE,
                 actualSize: privateKey.length
             });
@@ -263,11 +260,11 @@ class Secp256k1 {
      * @throws Error if the public key is not the correct length.
      */
     static verify(publicKey, block, signature) {
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "publicKey", publicKey);
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "block", block);
-        Guards.uint8Array(Secp256k1._CLASS_NAME, "signature", signature);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "publicKey", publicKey);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "block", block);
+        Guards.uint8Array(Secp256k1.CLASS_NAME, "signature", signature);
         if (publicKey.length !== Secp256k1.PUBLIC_KEY_SIZE) {
-            throw new GeneralError(Secp256k1._CLASS_NAME, "publicKeyLength", {
+            throw new GeneralError(Secp256k1.CLASS_NAME, "publicKeyLength", {
                 requiredSize: Secp256k1.PUBLIC_KEY_SIZE,
                 actualSize: publicKey ? publicKey.length : 0
             });
@@ -301,9 +298,8 @@ class Blake2b {
     static SIZE_512 = 64;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Blake2b";
+    static CLASS_NAME = "Blake2b";
     /**
      * The instance of the hash.
      * @internal
@@ -328,7 +324,7 @@ class Blake2b {
      * @returns The sum 160 of the block.
      */
     static sum160(block, key) {
-        Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_160, key).update(block).digest();
     }
     /**
@@ -338,7 +334,7 @@ class Blake2b {
      * @returns The sum 256 of the block.
      */
     static sum256(block, key) {
-        Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_256, key).update(block).digest();
     }
     /**
@@ -348,7 +344,7 @@ class Blake2b {
      * @returns The sum 512 of the block.
      */
     static sum512(block, key) {
-        Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         return new Blake2b(Blake2b.SIZE_512, key).update(block).digest();
     }
     /**
@@ -357,7 +353,7 @@ class Blake2b {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Blake2b._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake2b.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -468,9 +464,8 @@ const KeyType = {
 class Slip0010 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Slip0010";
+    static CLASS_NAME = "Slip0010";
     /**
      * Get the master key from the seed.
      * @param seed The seed to generate the master key from.
@@ -489,7 +484,7 @@ class Slip0010 {
             };
         }
         catch (error) {
-            throw new GeneralError(Slip0010._CLASS_NAME, "invalidSeed", { seed: Converter.bytesToUtf8(seed) }, error);
+            throw new GeneralError(Slip0010.CLASS_NAME, "invalidSeed", { seed: Converter.bytesToUtf8(seed) }, error);
         }
     }
     /**
@@ -545,9 +540,8 @@ class Slip0010 {
 class Bip44 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bip44";
+    static CLASS_NAME = "Bip44";
     /**
      * Generate a bip44 key pair from the seed and parts.
      * @param seed The account seed.
@@ -576,7 +570,7 @@ class Bip44 {
                 publicKey
             };
         }
-        throw new GeneralError(Bip44._CLASS_NAME, "unsupportedKeyType", { keyType });
+        throw new GeneralError(Bip44.CLASS_NAME, "unsupportedKeyType", { keyType });
     }
     /**
      * Generate a bip44 path based on all its parts.
@@ -651,9 +645,8 @@ class Bip44 {
 class ChaCha20Poly1305 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "ChaCha20Poly1305";
+    static CLASS_NAME = "ChaCha20Poly1305";
     /**
      * The cipher instance.
      * @internal
@@ -666,8 +659,8 @@ class ChaCha20Poly1305 {
      * @param aad The additional authenticated data.
      */
     constructor(key, nonce, aad) {
-        Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "key", key);
-        Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "nonce", nonce);
+        Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "key", key);
+        Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "nonce", nonce);
         this._instance = chacha20poly1305(key, nonce, aad);
     }
     /**
@@ -676,7 +669,7 @@ class ChaCha20Poly1305 {
      * @returns The block encrypted.
      */
     encrypt(block) {
-        Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "block", block);
+        Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "block", block);
         return this._instance.encrypt(block);
     }
     /**
@@ -685,7 +678,7 @@ class ChaCha20Poly1305 {
      * @returns The block decrypted.
      */
     decrypt(block) {
-        Guards.uint8Array(ChaCha20Poly1305._CLASS_NAME, "block", block);
+        Guards.uint8Array(ChaCha20Poly1305.CLASS_NAME, "block", block);
         return this._instance.decrypt(block);
     }
 }
@@ -698,16 +691,15 @@ class ChaCha20Poly1305 {
 class X25519 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "X25519";
+    static CLASS_NAME = "X25519";
     /**
      * Convert Ed25519 private key to X25519 private key.
      * @param ed25519PrivateKey The ed25519 private key to convert.
      * @returns The x25519 private key.
      */
     static convertPrivateKeyToX25519(ed25519PrivateKey) {
-        Guards.uint8Array(X25519._CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
+        Guards.uint8Array(X25519.CLASS_NAME, "ed25519PrivateKey", ed25519PrivateKey);
         return ed25519.utils.toMontgomerySecret(ed25519PrivateKey.slice(0, Ed25519.PRIVATE_KEY_SIZE));
     }
     /**
@@ -717,7 +709,7 @@ class X25519 {
      * @throws GeneralError On invalid public key.
      */
     static convertPublicKeyToX25519(ed25519PublicKey) {
-        Guards.uint8Array(X25519._CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
+        Guards.uint8Array(X25519.CLASS_NAME, "ed25519PublicKey", ed25519PublicKey);
         return ed25519.utils.toMontgomery(ed25519PublicKey);
     }
 }
@@ -730,9 +722,8 @@ class X25519 {
 class Zip215 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Zip215";
+    static CLASS_NAME = "Zip215";
     /**
      * Verify reports whether sig is a valid signature of block by
      * publicKey, using precisely-specified validation criteria (ZIP 215) suitable
@@ -743,9 +734,9 @@ class Zip215 {
      * @returns True if the signature is valid.
      */
     static verify(publicKey, block, sig) {
-        Guards.uint8Array(Zip215._CLASS_NAME, "publicKey", publicKey);
-        Guards.uint8Array(Zip215._CLASS_NAME, "block", block);
-        Guards.uint8Array(Zip215._CLASS_NAME, "sig", sig);
+        Guards.uint8Array(Zip215.CLASS_NAME, "publicKey", publicKey);
+        Guards.uint8Array(Zip215.CLASS_NAME, "block", block);
+        Guards.uint8Array(Zip215.CLASS_NAME, "sig", sig);
         if (publicKey.length !== Ed25519.PUBLIC_KEY_SIZE) {
             return false;
         }
@@ -769,9 +760,8 @@ class Blake3 {
     static SIZE_512 = 64;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Blake3";
+    static CLASS_NAME = "Blake3";
     /**
      * The instance of the hash.
      * @internal
@@ -796,7 +786,7 @@ class Blake3 {
      * @returns The sum 256 of the block.
      */
     static sum256(block, key) {
-        Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         return new Blake3(Blake3.SIZE_256, key).update(block).digest();
     }
     /**
@@ -806,7 +796,7 @@ class Blake3 {
      * @returns The sum 512 of the block.
      */
     static sum512(block, key) {
-        Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         return new Blake3(Blake3.SIZE_512, key).update(block).digest();
     }
     /**
@@ -815,7 +805,7 @@ class Blake3 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Blake3._CLASS_NAME, "block", block);
+        Guards.uint8Array(Blake3.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -836,9 +826,8 @@ class Blake3 {
 class HmacSha1 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha1";
+    static CLASS_NAME = "HmacSha1";
     /**
      * The instance of the hash.
      * @internal
@@ -859,8 +848,8 @@ class HmacSha1 {
      * @returns The sum of the block.
      */
     static sum(key, block) {
-        Guards.uint8Array(HmacSha1._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha1._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha1.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha1.CLASS_NAME, "block", block);
         return new HmacSha1(key).update(block).digest();
     }
     /**
@@ -869,7 +858,7 @@ class HmacSha1 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(HmacSha1._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha1.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -898,9 +887,8 @@ class HmacSha256 {
     static SIZE_224 = 224;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha256";
+    static CLASS_NAME = "HmacSha256";
     /**
      * The instance of the hash.
      * @internal
@@ -914,7 +902,7 @@ class HmacSha256 {
      */
     constructor(key, bits = HmacSha256.SIZE_256) {
         if (bits !== HmacSha256.SIZE_224 && bits !== HmacSha256.SIZE_256) {
-            throw new GeneralError(HmacSha256._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new GeneralError(HmacSha256.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         this._instance = hmac.create(bits === HmacSha256.SIZE_256 ? sha256 : sha224, key);
     }
@@ -925,8 +913,8 @@ class HmacSha256 {
      * @returns The sum 224 of the block.
      */
     static sum224(key, block) {
-        Guards.uint8Array(HmacSha256._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha256.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         const instance = new HmacSha256(key, HmacSha256.SIZE_224);
         instance.update(block);
         return instance.digest();
@@ -938,8 +926,8 @@ class HmacSha256 {
      * @returns The sum 256 of the block.
      */
     static sum256(key, block) {
-        Guards.uint8Array(HmacSha256._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha256.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         const instance = new HmacSha256(key, HmacSha256.SIZE_256);
         instance.update(block);
         return instance.digest();
@@ -950,7 +938,7 @@ class HmacSha256 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(HmacSha256._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha256.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -988,9 +976,8 @@ class HmacSha512 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "HmacSha512";
+    static CLASS_NAME = "HmacSha512";
     /**
      * The instance of the hash.
      * @internal
@@ -1007,7 +994,7 @@ class HmacSha512 {
             bits !== HmacSha512.SIZE_256 &&
             bits !== HmacSha512.SIZE_384 &&
             bits !== HmacSha512.SIZE_512) {
-            throw new GeneralError(HmacSha512._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new GeneralError(HmacSha512.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === HmacSha512.SIZE_224) {
             this._instance = hmac.create(sha512_224, key);
@@ -1029,8 +1016,8 @@ class HmacSha512 {
      * @returns The sum 512 of the block.
      */
     static sum512(key, block) {
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_512);
         instance.update(block);
         return instance.digest();
@@ -1042,8 +1029,8 @@ class HmacSha512 {
      * @returns The sum 384 of the block.
      */
     static sum384(key, block) {
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_384);
         instance.update(block);
         return instance.digest();
@@ -1055,8 +1042,8 @@ class HmacSha512 {
      * @returns The sum 256 of the block.
      */
     static sum256(key, block) {
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_256);
         instance.update(block);
         return instance.digest();
@@ -1068,8 +1055,8 @@ class HmacSha512 {
      * @returns The sum 224 of the block.
      */
     static sum224(key, block) {
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "key", key);
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "key", key);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         const instance = new HmacSha512(key, HmacSha512.SIZE_224);
         instance.update(block);
         return instance.digest();
@@ -1080,7 +1067,7 @@ class HmacSha512 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(HmacSha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(HmacSha512.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1101,9 +1088,8 @@ class HmacSha512 {
 class Pbkdf2 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Pbkdf2";
+    static CLASS_NAME = "Pbkdf2";
     /**
      * Derive a key from the parameters using Sha256.
      * @param password The password to derive the key from.
@@ -1113,10 +1099,10 @@ class Pbkdf2 {
      * @returns The derived key.
      */
     static sha256(password, salt, iterations, keyLength) {
-        Guards.uint8Array(Pbkdf2._CLASS_NAME, "password", password);
-        Guards.uint8Array(Pbkdf2._CLASS_NAME, "salt", salt);
-        Guards.number(Pbkdf2._CLASS_NAME, "iterations", iterations);
-        Guards.number(Pbkdf2._CLASS_NAME, "keyLength", keyLength);
+        Guards.uint8Array(Pbkdf2.CLASS_NAME, "password", password);
+        Guards.uint8Array(Pbkdf2.CLASS_NAME, "salt", salt);
+        Guards.number(Pbkdf2.CLASS_NAME, "iterations", iterations);
+        Guards.number(Pbkdf2.CLASS_NAME, "keyLength", keyLength);
         return pbkdf2(sha256, password, salt, { c: iterations, dkLen: keyLength });
     }
     /**
@@ -1128,10 +1114,10 @@ class Pbkdf2 {
      * @returns The derived key.
      */
     static sha512(password, salt, iterations, keyLength) {
-        Guards.uint8Array(Pbkdf2._CLASS_NAME, "password", password);
-        Guards.uint8Array(Pbkdf2._CLASS_NAME, "salt", salt);
-        Guards.number(Pbkdf2._CLASS_NAME, "iterations", iterations);
-        Guards.number(Pbkdf2._CLASS_NAME, "keyLength", keyLength);
+        Guards.uint8Array(Pbkdf2.CLASS_NAME, "password", password);
+        Guards.uint8Array(Pbkdf2.CLASS_NAME, "salt", salt);
+        Guards.number(Pbkdf2.CLASS_NAME, "iterations", iterations);
+        Guards.number(Pbkdf2.CLASS_NAME, "keyLength", keyLength);
         return pbkdf2(sha512, password, salt, { c: iterations, dkLen: keyLength });
     }
 }
@@ -1144,9 +1130,8 @@ class Pbkdf2 {
 class Sha1 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha1";
+    static CLASS_NAME = "Sha1";
     /**
      * The instance of the hash.
      * @internal
@@ -1165,7 +1150,7 @@ class Sha1 {
      * @returns The sum of the block.
      */
     static sum(block) {
-        Guards.uint8Array(Sha1._CLASS_NAME, "block", block);
+        Guards.uint8Array(Sha1.CLASS_NAME, "block", block);
         return new Sha1().update(block).digest();
     }
     /**
@@ -1174,7 +1159,7 @@ class Sha1 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Sha1._CLASS_NAME, "block", block);
+        Guards.uint8Array(Sha1.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1203,9 +1188,8 @@ class Sha256 {
     static SIZE_224 = 224;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha256";
+    static CLASS_NAME = "Sha256";
     /**
      * The instance of the hash.
      * @internal
@@ -1218,7 +1202,7 @@ class Sha256 {
      */
     constructor(bits = Sha256.SIZE_256) {
         if (bits !== Sha256.SIZE_224 && bits !== Sha256.SIZE_256) {
-            throw new GeneralError(Sha256._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new GeneralError(Sha256.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         this._instance = bits === Sha256.SIZE_256 ? sha256.create() : sha224.create();
     }
@@ -1248,7 +1232,7 @@ class Sha256 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Sha256._CLASS_NAME, "block", block);
+        Guards.uint8Array(Sha256.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1286,9 +1270,8 @@ class Sha3 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha3";
+    static CLASS_NAME = "Sha3";
     /**
      * The instance of the hash.
      * @internal
@@ -1304,7 +1287,7 @@ class Sha3 {
             bits !== Sha3.SIZE_256 &&
             bits !== Sha3.SIZE_384 &&
             bits !== Sha3.SIZE_512) {
-            throw new GeneralError(Sha3._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new GeneralError(Sha3.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === Sha3.SIZE_224) {
             // eslint-disable-next-line camelcase
@@ -1369,7 +1352,7 @@ class Sha3 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Sha3._CLASS_NAME, "block", block);
+        Guards.uint8Array(Sha3.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1407,9 +1390,8 @@ class Sha512 {
     static SIZE_512 = 512;
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Sha512";
+    static CLASS_NAME = "Sha512";
     /**
      * The instance of the hash.
      * @internal
@@ -1425,7 +1407,7 @@ class Sha512 {
             bits !== Sha512.SIZE_256 &&
             bits !== Sha512.SIZE_384 &&
             bits !== Sha512.SIZE_512) {
-            throw new GeneralError(Sha512._CLASS_NAME, "bitSize", { bitSize: bits });
+            throw new GeneralError(Sha512.CLASS_NAME, "bitSize", { bitSize: bits });
         }
         if (bits === Sha512.SIZE_224) {
             this._instance = sha512_224.create();
@@ -1486,7 +1468,7 @@ class Sha512 {
      * @returns The instance for chaining.
      */
     update(block) {
-        Guards.uint8Array(Sha512._CLASS_NAME, "block", block);
+        Guards.uint8Array(Sha512.CLASS_NAME, "block", block);
         this._instance.update(block);
         return this;
     }
@@ -1507,16 +1489,15 @@ class Sha512 {
 class PemHelper {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "PemHelper";
+    static CLASS_NAME = "PemHelper";
     /**
      * Strip the PEM content of its headers, footers, and newlines.
      * @param pemContent The PEM content to strip.
      * @returns The stripped PEM content in bas64 format.
      */
     static stripPemMarkers(pemContent) {
-        Guards.string(PemHelper._CLASS_NAME, "pemContent", pemContent);
+        Guards.string(PemHelper.CLASS_NAME, "pemContent", pemContent);
         return pemContent
             .replace(/-----BEGIN.*-----/, "")
             .replace(/-----END.*-----/, "")
@@ -1531,8 +1512,8 @@ class PemHelper {
      * @returns The formatted PEM content.
      */
     static formatPem(marker, base64Content, lineLength = 64) {
-        Guards.stringValue(PemHelper._CLASS_NAME, "marker", marker);
-        Guards.stringBase64(PemHelper._CLASS_NAME, "base64Content", base64Content);
+        Guards.stringValue(PemHelper.CLASS_NAME, "marker", marker);
+        Guards.stringBase64(PemHelper.CLASS_NAME, "base64Content", base64Content);
         const lines = [];
         for (let i = 0; i < base64Content.length; i += lineLength) {
             lines.push(base64Content.slice(i, i + lineLength));
@@ -1549,9 +1530,8 @@ class PemHelper {
 class Bip39 {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Bip39";
+    static CLASS_NAME = "Bip39";
     /**
      * Generate a random mnemonic.
      * @param strength The strength of the mnemonic to generate, defaults to 256.
@@ -1560,10 +1540,10 @@ class Bip39 {
      * @throws Error if the length is not a multiple of 32.
      */
     static randomMnemonic(strength = 256, words = wordlist) {
-        Guards.number(Bip39._CLASS_NAME, "strength", strength);
-        Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        Guards.number(Bip39.CLASS_NAME, "strength", strength);
+        Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         if (strength % 32 !== 0) {
-            throw new GuardError(Bip39._CLASS_NAME, "guard.length32Multiple", "strength", strength);
+            throw new GuardError(Bip39.CLASS_NAME, "guard.length32Multiple", "strength", strength);
         }
         return bip39.generateMnemonic(words, strength);
     }
@@ -1575,10 +1555,10 @@ class Bip39 {
      * @throws Error if the length of the entropy is not a multiple of 4, or is less than 16 or greater than 32.
      */
     static entropyToMnemonic(entropy, words = wordlist) {
-        Guards.uint8Array(Bip39._CLASS_NAME, "entropy", entropy);
-        Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        Guards.uint8Array(Bip39.CLASS_NAME, "entropy", entropy);
+        Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-            throw new GuardError(Bip39._CLASS_NAME, "guard.lengthEntropy", "entropy", entropy.length);
+            throw new GuardError(Bip39.CLASS_NAME, "guard.lengthEntropy", "entropy", entropy.length);
         }
         return bip39.entropyToMnemonic(entropy, words);
     }
@@ -1589,7 +1569,7 @@ class Bip39 {
      * @returns The seed.
      */
     static mnemonicToSeed(mnemonic, password) {
-        Guards.stringValue(Bip39._CLASS_NAME, "mnemonic", mnemonic);
+        Guards.stringValue(Bip39.CLASS_NAME, "mnemonic", mnemonic);
         return bip39.mnemonicToSeedSync(mnemonic, password);
     }
     /**
@@ -1600,8 +1580,8 @@ class Bip39 {
      * @throws Error if the number of words is not a multiple of 3.
      */
     static mnemonicToEntropy(mnemonic, words = wordlist) {
-        Guards.stringValue(Bip39._CLASS_NAME, "mnemonic", mnemonic);
-        Guards.arrayValue(Bip39._CLASS_NAME, "words", words);
+        Guards.stringValue(Bip39.CLASS_NAME, "mnemonic", mnemonic);
+        Guards.arrayValue(Bip39.CLASS_NAME, "words", words);
         return bip39.mnemonicToEntropy(mnemonic, words);
     }
     /**
@@ -1612,8 +1592,8 @@ class Bip39 {
      * @returns True if the mnemonic is valid.
      */
     static validateMnemonic(mnemonic, wordCount = 24, words = wordlist) {
-        Guards.string(Bip39._CLASS_NAME, "mnemonic", mnemonic);
-        Guards.integer(Bip39._CLASS_NAME, "wordCount", wordCount);
+        Guards.string(Bip39.CLASS_NAME, "mnemonic", mnemonic);
+        Guards.integer(Bip39.CLASS_NAME, "wordCount", wordCount);
         const mnemonicSplit = mnemonic.split(/\s+/);
         if (mnemonicSplit.length !== wordCount) {
             return false;
@@ -1631,9 +1611,8 @@ class Bip39 {
 class Hotp {
     /**
      * Runtime name for the class.
-     * @internal
      */
-    static _CLASS_NAME = "Hotp";
+    static CLASS_NAME = "Hotp";
     /**
      * Generate a counter based One Time Password.
      * @param key Key for the one time password.
@@ -1642,8 +1621,8 @@ class Hotp {
      * @returns The one time password.
      */
     static generate(key, counter) {
-        Guards.uint8Array(Hotp._CLASS_NAME, "key", key);
-        Guards.number(Hotp._CLASS_NAME, "counter", counter);
+        Guards.uint8Array(Hotp.CLASS_NAME, "key", key);
+        Guards.number(Hotp.CLASS_NAME, "counter", counter);
         return otp.hotp({ secret: key, digits: 6, algorithm: "sha1", interval: 30 }, counter);
     }
 }
@@ -1679,7 +1658,7 @@ class Totp {
         for (let i = -window; i < window; i++) {
             const intervalWindow = i * interval * 1000;
             if (timestamp + intervalWindow > 0) {
-                const gen = this.generate(key, interval, timestamp + intervalWindow);
+                const gen = Totp.generate(key, interval, timestamp + intervalWindow);
                 if (gen === token) {
                     // We have found a matching code
                     return i;
@@ -1774,7 +1753,8 @@ class PasswordValidator {
                     property,
                     reason: "validation.minLengthRequired",
                     properties: {
-                        minLength
+                        minLength,
+                        actualLength: password.length
                     }
                 });
             }
@@ -1784,7 +1764,8 @@ class PasswordValidator {
                     property,
                     reason: "validation.maxLengthRequired",
                     properties: {
-                        maxLength
+                        maxLength,
+                        actualLength: password.length
                     }
                 });
             }