quantumcoin 6.14.4 → 7.0.1

package/src.ts/crypto/hmac.ts

@@ -1,51 +0,0 @@
-/**
- *  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 +0,0 @@
-/**
- *  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 +0,0 @@
-/**
- *  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 +0,0 @@
-/**
- *  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 +0,0 @@
-/**
- *  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 +0,0 @@
-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);

package/src.ts/crypto/scrypt.ts

@@ -1,114 +0,0 @@
-import { scrypt as _nobleSync, scryptAsync as _nobleAsync } from "@noble/hashes/scrypt";
-
-import { getBytes, hexlify as H } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-/**
- *  A callback during long-running operations to update any
- *  UI or provide programatic access to the progress.
- *
- *  The %%percent%% is a value between ``0`` and ``1``.
- *
- *  @_docloc: api/crypto:Passwords
- */
-export type ProgressCallback = (percent: number) => void;
-
-
-let lockedSync = false, lockedAsync = false;
-
-const _scryptAsync = async function(passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback) {
-    return await _nobleAsync(passwd, salt, { N, r, p, dkLen, onProgress });
-}
-const _scryptSync = function(passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) {
-    return _nobleSync(passwd, salt, { N, r, p, dkLen });
-}
-
-let __scryptAsync: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback) => Promise<BytesLike> = _scryptAsync;
-let __scryptSync: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike = _scryptSync
-
-
-/**
- *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
- *  derivation to increase the resource cost to brute-force a password
- *  for a given key.
- *
- *  This means this algorithm is intentionally slow, and can be tuned to
- *  become slower. As computation and memory speed improve over time,
- *  increasing the difficulty maintains the cost of an attacker.
- *
- *  For example, if a target time of 5 seconds is used, a legitimate user
- *  which knows their password requires only 5 seconds to unlock their
- *  account. A 6 character password has 68 billion possibilities, which
- *  would require an attacker to invest over 10,000 years of CPU time. This
- *  is of course a crude example (as password generally aren't random),
- *  but demonstrates to value of imposing large costs to decryption.
- *
- *  For this reason, if building a UI which involved decrypting or
- *  encrypting datsa using scrypt, it is recommended to use a
- *  [[ProgressCallback]] (as event short periods can seem lik an eternity
- *  if the UI freezes). Including the phrase //"decrypting"// in the UI
- *  can also help, assuring the user their waiting is for a good reason.
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @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 scrypt
- *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-export async function scrypt(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback): Promise<string> {
-    const passwd = getBytes(_passwd, "passwd");
-    const salt = getBytes(_salt, "salt");
-    return H(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));
-}
-scrypt._ = _scryptAsync;
-scrypt.lock = function(): void { lockedAsync = true; }
-scrypt.register = function(func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback) => Promise<BytesLike>) {
-    if (lockedAsync) { throw new Error("scrypt is locked"); }
-    __scryptAsync = func;
-}
-Object.freeze(scrypt);
-
-/**
- *  Provides a synchronous variant of [[scrypt]].
- *
- *  This will completely lock up and freeze the UI in a browser and will
- *  prevent any event loop from progressing. For this reason, it is
- *  preferred to use the [async variant](scrypt).
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @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 scrypt
- *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-export function scryptSync(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number): string {
-    const passwd = getBytes(_passwd, "passwd");
-    const salt = getBytes(_salt, "salt");
-    return H(__scryptSync(passwd, salt, N, r, p, dkLen));
-}
-scryptSync._ = _scryptSync;
-scryptSync.lock = function(): void { lockedSync = true; }
-scryptSync.register = function(func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike) {
-    if (lockedSync) { throw new Error("scryptSync is locked"); }
-    __scryptSync = func;
-}
-Object.freeze(scryptSync);

package/src.ts/crypto/sha2.ts

@@ -1,78 +0,0 @@
-import { createHash } from "./crypto.js";
-
-import { getBytes, hexlify } from "../utils/index.js";
-
-import type { BytesLike } from "../utils/index.js";
-
-
-const _sha256 = function(data: Uint8Array): Uint8Array {
-    return createHash("sha256").update(data).digest();
-}
-
-const _sha512 = function(data: Uint8Array): Uint8Array {
-    return createHash("sha512").update(data).digest();
-}
-
-let __sha256: (data: Uint8Array) => BytesLike = _sha256;
-let __sha512: (data: Uint8Array) => BytesLike = _sha512;
-
-let locked256 = false, locked512 = false;
-
-
-/**
- *  Compute the cryptographic SHA2-256 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha256("0x")
- *    //_result:
- *
- *    sha256("0x1337")
- *    //_result:
- *
- *    sha256(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-export function sha256(_data: BytesLike): string {
-    const data = getBytes(_data, "data");
-    return hexlify(__sha256(data));
-}
-sha256._ = _sha256;
-sha256.lock = function(): void { locked256 = true; }
-sha256.register = function(func: (data: Uint8Array) => BytesLike): void {
-    if (locked256) { throw new Error("sha256 is locked"); }
-    __sha256 = func;
-}
-Object.freeze(sha256);
-
-
-/**
- *  Compute the cryptographic SHA2-512 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha512("0x")
- *    //_result:
- *
- *    sha512("0x1337")
- *    //_result:
- *
- *    sha512(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- */
-export function sha512(_data: BytesLike): string {
-    const data = getBytes(_data, "data");
-    return hexlify(__sha512(data));
-}
-sha512._ = _sha512;
-sha512.lock = function(): void { locked512 = true; }
-sha512.register = function(func: (data: Uint8Array) => BytesLike): void {
-    if (locked512) { throw new Error("sha512 is locked"); }
-    __sha512 = func;
-}
-Object.freeze(sha256);