quantumcoin 6.14.2 → 6.14.5

package/src.ts/crypto/hmac.ts

@@ -1,51 +1,51 @@
-/**
- *  An **HMAC** enables verification that a given key was used
- *  to authenticate a payload.
- *
- *  See: [[link-wiki-hmac]]
- *
- *  @_subsection: api/crypto:HMAC  [about-hmac]
- */
-import { createHmac } from "./crypto.js";
-import { getBytes, hexlify } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-
-let locked = false;
-
-const _computeHmac = function(algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array): BytesLike {
-    return createHmac(algorithm, key).update(data).digest();
-}
-
-let __computeHmac = _computeHmac;
-
-/**
- *  Return the HMAC for %%data%% using the %%key%% key with the underlying
- *  %%algo%% used for compression.
- *
- *  @example:
- *    key = id("some-secret")
- *
- *    // Compute the HMAC
- *    computeHmac("sha256", key, "0x1337")
- *    //_result:
- *
- *    // To compute the HMAC of UTF-8 data, the data must be
- *    // converted to UTF-8 bytes
- *    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
- *    //_result:
- *
- */
-export function computeHmac(algorithm: "sha256" | "sha512", _key: BytesLike, _data: BytesLike): string {
-    const key = getBytes(_key, "key");
-    const data = getBytes(_data, "data");
-    return hexlify(__computeHmac(algorithm, key, data));
-}
-computeHmac._ = _computeHmac;
-computeHmac.lock =  function() { locked = true; }
-computeHmac.register = function(func: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike) {
-    if (locked) { throw new Error("computeHmac is locked"); }
-    __computeHmac = func;
-}
-Object.freeze(computeHmac);
+/**
+ *  An **HMAC** enables verification that a given key was used
+ *  to authenticate a payload.
+ *
+ *  See: [[link-wiki-hmac]]
+ *
+ *  @_subsection: api/crypto:HMAC  [about-hmac]
+ */
+import { createHmac } from "./crypto.js";
+import { getBytes, hexlify } from "../utils/index.js";
+
+import type { BytesLike } from "../utils/index.js";
+
+
+let locked = false;
+
+const _computeHmac = function(algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array): BytesLike {
+    return createHmac(algorithm, key).update(data).digest();
+}
+
+let __computeHmac = _computeHmac;
+
+/**
+ *  Return the HMAC for %%data%% using the %%key%% key with the underlying
+ *  %%algo%% used for compression.
+ *
+ *  @example:
+ *    key = id("some-secret")
+ *
+ *    // Compute the HMAC
+ *    computeHmac("sha256", key, "0x1337")
+ *    //_result:
+ *
+ *    // To compute the HMAC of UTF-8 data, the data must be
+ *    // converted to UTF-8 bytes
+ *    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
+ *    //_result:
+ *
+ */
+export function computeHmac(algorithm: "sha256" | "sha512", _key: BytesLike, _data: BytesLike): string {
+    const key = getBytes(_key, "key");
+    const data = getBytes(_data, "data");
+    return hexlify(__computeHmac(algorithm, key, data));
+}
+computeHmac._ = _computeHmac;
+computeHmac.lock =  function() { locked = true; }
+computeHmac.register = function(func: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike) {
+    if (locked) { throw new Error("computeHmac is locked"); }
+    __computeHmac = func;
+}
+Object.freeze(computeHmac);

package/src.ts/crypto/index.ts

@@ -1,59 +1,59 @@
-/**
- *  A fundamental building block of Ethereum is the underlying
- *  cryptographic primitives.
- *
- *  @_section: api/crypto:Cryptographic Functions   [about-crypto]
- */
-
-null
-
-// We import all these so we can export lock()
-import { computeHmac } from "./hmac.js";
-import { keccak256 } from "./keccak.js";
-import { ripemd160 } from "./ripemd160.js";
-import { pbkdf2 } from "./pbkdf2.js";
-import { randomBytes } from "./random.js";
-import { scrypt, scryptSync } from "./scrypt.js";
-import { sha256, sha512 } from "./sha2.js";
-
-export {
-    computeHmac,
-
-    randomBytes,
-
-    keccak256,
-    ripemd160,
-    sha256, sha512,
-
-    pbkdf2,
-    scrypt, scryptSync
-};
-
-export { SigningKey } from "./signing-key.js";
-export { Signature } from "./signature.js";
-
-/**
- *  Once called, prevents any future change to the underlying cryptographic
- *  primitives using the ``.register`` feature for hooks.
- */
-function lock(): void {
-    computeHmac.lock();
-    keccak256.lock();
-    pbkdf2.lock();
-    randomBytes.lock();
-    ripemd160.lock();
-    scrypt.lock();
-    scryptSync.lock();
-    sha256.lock();
-    sha512.lock();
-    randomBytes.lock();
-}
-
-export { lock };
-
-/////////////////////////////
-// Types
-
-export type { ProgressCallback } from "./scrypt.js";
-
-export type { SignatureLike } from "./signature.js";
+/**
+ *  A fundamental building block of Ethereum is the underlying
+ *  cryptographic primitives.
+ *
+ *  @_section: api/crypto:Cryptographic Functions   [about-crypto]
+ */
+
+null
+
+// We import all these so we can export lock()
+import { computeHmac } from "./hmac.js";
+import { keccak256 } from "./keccak.js";
+import { ripemd160 } from "./ripemd160.js";
+import { pbkdf2 } from "./pbkdf2.js";
+import { randomBytes } from "./random.js";
+import { scrypt, scryptSync } from "./scrypt.js";
+import { sha256, sha512 } from "./sha2.js";
+
+export {
+    computeHmac,
+
+    randomBytes,
+
+    keccak256,
+    ripemd160,
+    sha256, sha512,
+
+    pbkdf2,
+    scrypt, scryptSync
+};
+
+export { SigningKey } from "./signing-key.js";
+export { Signature } from "./signature.js";
+
+/**
+ *  Once called, prevents any future change to the underlying cryptographic
+ *  primitives using the ``.register`` feature for hooks.
+ */
+function lock(): void {
+    computeHmac.lock();
+    keccak256.lock();
+    pbkdf2.lock();
+    randomBytes.lock();
+    ripemd160.lock();
+    scrypt.lock();
+    scryptSync.lock();
+    sha256.lock();
+    sha512.lock();
+    randomBytes.lock();
+}
+
+export { lock };
+
+/////////////////////////////
+// Types
+
+export type { ProgressCallback } from "./scrypt.js";
+
+export type { SignatureLike } from "./signature.js";

package/src.ts/crypto/keccak.ts

@@ -1,54 +1,54 @@
-/**
- *  Cryptographic hashing functions
- *
- *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
- */
-
-import { keccak_256 } from "@noble/hashes/sha3";
-
-import { getBytes, hexlify } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-
-let locked = false;
-
-const _keccak256 = function(data: Uint8Array): Uint8Array {
-    return keccak_256(data);
-}
-
-let __keccak256: (data: Uint8Array) => BytesLike = _keccak256;
-
-/**
- *  Compute the cryptographic KECCAK256 hash of %%data%%.
- *
- *  The %%data%% **must** be a data representation, to compute the
- *  hash of UTF-8 data use the [[id]] function.
- *
- *  @returns DataHexstring
- *  @example:
- *    keccak256("0x")
- *    //_result:
- *
- *    keccak256("0x1337")
- *    //_result:
- *
- *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- *    // Strings are assumed to be DataHexString, otherwise it will
- *    // throw. To hash UTF-8 data, see the note above.
- *    keccak256("Hello World")
- *    //_error:
- */
-export function keccak256(_data: BytesLike): string {
-    const data = getBytes(_data, "data");
-    return hexlify(__keccak256(data));
-}
-keccak256._ = _keccak256;
-keccak256.lock = function(): void { locked = true; }
-keccak256.register = function(func: (data: Uint8Array) => BytesLike) {
-    if (locked) { throw new TypeError("keccak256 is locked"); }
-    __keccak256 = func;
-}
-Object.freeze(keccak256);
+/**
+ *  Cryptographic hashing functions
+ *
+ *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
+ */
+
+import { keccak_256 } from "@noble/hashes/sha3";
+
+import { getBytes, hexlify } from "../utils/index.js";
+
+import type { BytesLike } from "../utils/index.js";
+
+
+let locked = false;
+
+const _keccak256 = function(data: Uint8Array): Uint8Array {
+    return keccak_256(data);
+}
+
+let __keccak256: (data: Uint8Array) => BytesLike = _keccak256;
+
+/**
+ *  Compute the cryptographic KECCAK256 hash of %%data%%.
+ *
+ *  The %%data%% **must** be a data representation, to compute the
+ *  hash of UTF-8 data use the [[id]] function.
+ *
+ *  @returns DataHexstring
+ *  @example:
+ *    keccak256("0x")
+ *    //_result:
+ *
+ *    keccak256("0x1337")
+ *    //_result:
+ *
+ *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ *    // Strings are assumed to be DataHexString, otherwise it will
+ *    // throw. To hash UTF-8 data, see the note above.
+ *    keccak256("Hello World")
+ *    //_error:
+ */
+export function keccak256(_data: BytesLike): string {
+    const data = getBytes(_data, "data");
+    return hexlify(__keccak256(data));
+}
+keccak256._ = _keccak256;
+keccak256.lock = function(): void { locked = true; }
+keccak256.register = function(func: (data: Uint8Array) => BytesLike) {
+    if (locked) { throw new TypeError("keccak256 is locked"); }
+    __keccak256 = func;
+}
+Object.freeze(keccak256);

package/src.ts/crypto/pbkdf2.ts

@@ -1,55 +1,55 @@
-/**
- *  A **Password-Based Key-Derivation Function** is designed to create
- *  a sequence of bytes suitible as a **key** from a human-rememberable
- *  password.
- *
- *  @_subsection: api/crypto:Passwords  [about-pbkdf]
- */
-
-import { pbkdf2Sync } from "./crypto.js";
-
-import { getBytes, hexlify } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-
-let locked = false;
-
-const _pbkdf2 = function(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512"): BytesLike {
-    return pbkdf2Sync(password, salt, iterations, keylen, algo);
-}
-
-let __pbkdf2 = _pbkdf2;
-
-/**
- *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
- *  the %%salt%% and using %%iterations%% of %%algo%%.
- *
- *  This PBKDF is outdated and should not be used in new projects, but is
- *  required to decrypt older files.
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the PBKDF2
- *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
- *    //_result:
- */
-export function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string {
-    const password = getBytes(_password, "password");
-    const salt = getBytes(_salt, "salt");
-    return hexlify(__pbkdf2(password, salt, iterations, keylen, algo));
-}
-pbkdf2._ = _pbkdf2;
-pbkdf2.lock = function(): void { locked = true; }
-pbkdf2.register = function(func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) {
-    if (locked) { throw new Error("pbkdf2 is locked"); }
-    __pbkdf2 = func;
-}
-Object.freeze(pbkdf2);
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+
+import { pbkdf2Sync } from "./crypto.js";
+
+import { getBytes, hexlify } from "../utils/index.js";
+
+import type { BytesLike } from "../utils/index.js";
+
+
+let locked = false;
+
+const _pbkdf2 = function(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512"): BytesLike {
+    return pbkdf2Sync(password, salt, iterations, keylen, algo);
+}
+
+let __pbkdf2 = _pbkdf2;
+
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+export function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string {
+    const password = getBytes(_password, "password");
+    const salt = getBytes(_salt, "salt");
+    return hexlify(__pbkdf2(password, salt, iterations, keylen, algo));
+}
+pbkdf2._ = _pbkdf2;
+pbkdf2.lock = function(): void { locked = true; }
+pbkdf2.register = function(func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) {
+    if (locked) { throw new Error("pbkdf2 is locked"); }
+    __pbkdf2 = func;
+}
+Object.freeze(pbkdf2);

package/src.ts/crypto/random.ts

@@ -1,36 +1,36 @@
-/**
- *  A **Cryptographically Secure Random Value** is one that has been
- *  generated with additional care take to prevent side-channels
- *  from allowing others to detect it and prevent others from through
- *  coincidence generate the same values.
- *
- *  @_subsection: api/crypto:Random Values  [about-crypto-random]
- */
-import { randomBytes as crypto_random } from "./crypto.js";
-
-let locked = false;
-
-const _randomBytes = function(length: number): Uint8Array {
-    return new Uint8Array(crypto_random(length));
-}
-
-let __randomBytes = _randomBytes;
-
-/**
- *  Return %%length%% bytes of cryptographically secure random data.
- *
- *  @example:
- *    randomBytes(8)
- *    //_result:
- */
-export function randomBytes(length: number): Uint8Array {
-    return __randomBytes(length);
-}
-
-randomBytes._ = _randomBytes;
-randomBytes.lock = function(): void { locked = true; }
-randomBytes.register = function(func: (length: number) => Uint8Array) {
-    if (locked) { throw new Error("randomBytes is locked"); }
-    __randomBytes = func;
-}
-Object.freeze(randomBytes);
+/**
+ *  A **Cryptographically Secure Random Value** is one that has been
+ *  generated with additional care take to prevent side-channels
+ *  from allowing others to detect it and prevent others from through
+ *  coincidence generate the same values.
+ *
+ *  @_subsection: api/crypto:Random Values  [about-crypto-random]
+ */
+import { randomBytes as crypto_random } from "./crypto.js";
+
+let locked = false;
+
+const _randomBytes = function(length: number): Uint8Array {
+    return new Uint8Array(crypto_random(length));
+}
+
+let __randomBytes = _randomBytes;
+
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+export function randomBytes(length: number): Uint8Array {
+    return __randomBytes(length);
+}
+
+randomBytes._ = _randomBytes;
+randomBytes.lock = function(): void { locked = true; }
+randomBytes.register = function(func: (length: number) => Uint8Array) {
+    if (locked) { throw new Error("randomBytes is locked"); }
+    __randomBytes = func;
+}
+Object.freeze(randomBytes);

package/src.ts/crypto/ripemd160.ts

@@ -1,43 +1,43 @@
-import { ripemd160 as noble_ripemd160 } from "@noble/hashes/ripemd160";
-
-import { getBytes,  hexlify } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-
-let locked = false;
-
-const _ripemd160 = function(data: Uint8Array): Uint8Array {
-    return noble_ripemd160(data);
-}
-
-let __ripemd160: (data: Uint8Array) => BytesLike = _ripemd160;
-
-/**
- *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    ripemd160("0x")
- *    //_result:
- *
- *    ripemd160("0x1337")
- *    //_result:
- *
- *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-export function ripemd160(_data: BytesLike): string {
-    const data = getBytes(_data, "data");
-    return hexlify(__ripemd160(data));
-}
-ripemd160._ = _ripemd160;
-ripemd160.lock = function(): void { locked = true; }
-ripemd160.register = function(func: (data: Uint8Array) => BytesLike) {
-    if (locked) { throw new TypeError("ripemd160 is locked"); }
-    __ripemd160 = func;
-}
-Object.freeze(ripemd160);
+import { ripemd160 as noble_ripemd160 } from "@noble/hashes/ripemd160";
+
+import { getBytes,  hexlify } from "../utils/index.js";
+
+import type { BytesLike } from "../utils/index.js";
+
+
+let locked = false;
+
+const _ripemd160 = function(data: Uint8Array): Uint8Array {
+    return noble_ripemd160(data);
+}
+
+let __ripemd160: (data: Uint8Array) => BytesLike = _ripemd160;
+
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export function ripemd160(_data: BytesLike): string {
+    const data = getBytes(_data, "data");
+    return hexlify(__ripemd160(data));
+}
+ripemd160._ = _ripemd160;
+ripemd160.lock = function(): void { locked = true; }
+ripemd160.register = function(func: (data: Uint8Array) => BytesLike) {
+    if (locked) { throw new TypeError("ripemd160 is locked"); }
+    __ripemd160 = func;
+}
+Object.freeze(ripemd160);