@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/dist/noble/sha512.js

@@ -0,0 +1,301 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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;
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha384 = exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.SHA512 = void 0;
+var _md_1 = require("./_md.js");
+var u64 = __importStar(require("./_u64.js"));
+var utils_1 = require("./utils.js");
+// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):
+// prettier-ignore
+var _a = __read(/* @__PURE__ */ (function () { return u64.split([
+    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
+    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
+    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
+    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
+    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
+    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
+    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
+    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
+    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
+    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
+    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
+    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
+    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
+    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
+    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
+    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
+    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
+    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
+    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
+    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
+].map(function (n) { return BigInt(n); })); })(), 2), SHA512_Kh = _a[0], SHA512_Kl = _a[1];
+// Temporary buffer, not used to store anything between runs
+var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+var SHA512 = /** @class */ (function (_super) {
+    __extends(SHA512, _super);
+    function SHA512() {
+        var _this = _super.call(this, 128, 64, 16, false) || this;
+        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.
+        // Also looks cleaner and easier to verify with spec.
+        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+        // h -- high 32 bits, l -- low 32 bits
+        _this.Ah = 0x6a09e667 | 0;
+        _this.Al = 0xf3bcc908 | 0;
+        _this.Bh = 0xbb67ae85 | 0;
+        _this.Bl = 0x84caa73b | 0;
+        _this.Ch = 0x3c6ef372 | 0;
+        _this.Cl = 0xfe94f82b | 0;
+        _this.Dh = 0xa54ff53a | 0;
+        _this.Dl = 0x5f1d36f1 | 0;
+        _this.Eh = 0x510e527f | 0;
+        _this.El = 0xade682d1 | 0;
+        _this.Fh = 0x9b05688c | 0;
+        _this.Fl = 0x2b3e6c1f | 0;
+        _this.Gh = 0x1f83d9ab | 0;
+        _this.Gl = 0xfb41bd6b | 0;
+        _this.Hh = 0x5be0cd19 | 0;
+        _this.Hl = 0x137e2179 | 0;
+        return _this;
+    }
+    // prettier-ignore
+    SHA512.prototype.get = function () {
+        var _a = this, Ah = _a.Ah, Al = _a.Al, Bh = _a.Bh, Bl = _a.Bl, Ch = _a.Ch, Cl = _a.Cl, Dh = _a.Dh, Dl = _a.Dl, Eh = _a.Eh, El = _a.El, Fh = _a.Fh, Fl = _a.Fl, Gh = _a.Gh, Gl = _a.Gl, Hh = _a.Hh, Hl = _a.Hl;
+        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+    };
+    // prettier-ignore
+    SHA512.prototype.set = function (Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+        this.Ah = Ah | 0;
+        this.Al = Al | 0;
+        this.Bh = Bh | 0;
+        this.Bl = Bl | 0;
+        this.Ch = Ch | 0;
+        this.Cl = Cl | 0;
+        this.Dh = Dh | 0;
+        this.Dl = Dl | 0;
+        this.Eh = Eh | 0;
+        this.El = El | 0;
+        this.Fh = Fh | 0;
+        this.Fl = Fl | 0;
+        this.Gh = Gh | 0;
+        this.Gl = Gl | 0;
+        this.Hh = Hh | 0;
+        this.Hl = Hl | 0;
+    };
+    SHA512.prototype.process = function (view, offset) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
+        for (var i = 0; i < 16; i++, offset += 4) {
+            SHA512_W_H[i] = view.getUint32(offset);
+            SHA512_W_L[i] = view.getUint32((offset += 4));
+        }
+        for (var i = 16; i < 80; i++) {
+            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
+            var W15h = SHA512_W_H[i - 15] | 0;
+            var W15l = SHA512_W_L[i - 15] | 0;
+            var s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
+            var s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
+            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
+            var W2h = SHA512_W_H[i - 2] | 0;
+            var W2l = SHA512_W_L[i - 2] | 0;
+            var s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
+            var s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
+            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
+            var SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+            var SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+            SHA512_W_H[i] = SUMh | 0;
+            SHA512_W_L[i] = SUMl | 0;
+        }
+        var _k = this, Ah = _k.Ah, Al = _k.Al, Bh = _k.Bh, Bl = _k.Bl, Ch = _k.Ch, Cl = _k.Cl, Dh = _k.Dh, Dl = _k.Dl, Eh = _k.Eh, El = _k.El, Fh = _k.Fh, Fl = _k.Fl, Gh = _k.Gh, Gl = _k.Gl, Hh = _k.Hh, Hl = _k.Hl;
+        // Compression function main loop, 80 rounds
+        for (var i = 0; i < 80; i++) {
+            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
+            var sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
+            var sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
+            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            var CHIh = (Eh & Fh) ^ (~Eh & Gh);
+            var CHIl = (El & Fl) ^ (~El & Gl);
+            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
+            // prettier-ignore
+            var T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+            var T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+            var T1l = T1ll | 0;
+            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
+            var sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
+            var sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
+            var MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
+            var MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
+            Hh = Gh | 0;
+            Hl = Gl | 0;
+            Gh = Fh | 0;
+            Gl = Fl | 0;
+            Fh = Eh | 0;
+            Fl = El | 0;
+            (_a = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0), Eh = _a.h, El = _a.l);
+            Dh = Ch | 0;
+            Dl = Cl | 0;
+            Ch = Bh | 0;
+            Cl = Bl | 0;
+            Bh = Ah | 0;
+            Bl = Al | 0;
+            var All = u64.add3L(T1l, sigma0l, MAJl);
+            Ah = u64.add3H(All, T1h, sigma0h, MAJh);
+            Al = All | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        (_b = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0), Ah = _b.h, Al = _b.l);
+        (_c = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0), Bh = _c.h, Bl = _c.l);
+        (_d = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0), Ch = _d.h, Cl = _d.l);
+        (_e = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0), Dh = _e.h, Dl = _e.l);
+        (_f = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0), Eh = _f.h, El = _f.l);
+        (_g = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0), Fh = _g.h, Fl = _g.l);
+        (_h = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0), Gh = _h.h, Gl = _h.l);
+        (_j = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0), Hh = _j.h, Hl = _j.l);
+        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+    };
+    SHA512.prototype.roundClean = function () {
+        SHA512_W_H.fill(0);
+        SHA512_W_L.fill(0);
+    };
+    SHA512.prototype.destroy = function () {
+        this.buffer.fill(0);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    };
+    return SHA512;
+}(_md_1.HashMD));
+exports.SHA512 = SHA512;
+var SHA512_224 = /** @class */ (function (_super) {
+    __extends(SHA512_224, _super);
+    function SHA512_224() {
+        var _this = _super.call(this) || this;
+        // h -- high 32 bits, l -- low 32 bits
+        _this.Ah = 0x8c3d37c8 | 0;
+        _this.Al = 0x19544da2 | 0;
+        _this.Bh = 0x73e19966 | 0;
+        _this.Bl = 0x89dcd4d6 | 0;
+        _this.Ch = 0x1dfab7ae | 0;
+        _this.Cl = 0x32ff9c82 | 0;
+        _this.Dh = 0x679dd514 | 0;
+        _this.Dl = 0x582f9fcf | 0;
+        _this.Eh = 0x0f6d2b69 | 0;
+        _this.El = 0x7bd44da8 | 0;
+        _this.Fh = 0x77e36f73 | 0;
+        _this.Fl = 0x04c48942 | 0;
+        _this.Gh = 0x3f9d85a8 | 0;
+        _this.Gl = 0x6a1d36c8 | 0;
+        _this.Hh = 0x1112e6ad | 0;
+        _this.Hl = 0x91d692a1 | 0;
+        _this.outputLen = 28;
+        return _this;
+    }
+    return SHA512_224;
+}(SHA512));
+var SHA512_256 = /** @class */ (function (_super) {
+    __extends(SHA512_256, _super);
+    function SHA512_256() {
+        var _this = _super.call(this) || this;
+        // h -- high 32 bits, l -- low 32 bits
+        _this.Ah = 0x22312194 | 0;
+        _this.Al = 0xfc2bf72c | 0;
+        _this.Bh = 0x9f555fa3 | 0;
+        _this.Bl = 0xc84c64c2 | 0;
+        _this.Ch = 0x2393b86b | 0;
+        _this.Cl = 0x6f53b151 | 0;
+        _this.Dh = 0x96387719 | 0;
+        _this.Dl = 0x5940eabd | 0;
+        _this.Eh = 0x96283ee2 | 0;
+        _this.El = 0xa88effe3 | 0;
+        _this.Fh = 0xbe5e1e25 | 0;
+        _this.Fl = 0x53863992 | 0;
+        _this.Gh = 0x2b0199fc | 0;
+        _this.Gl = 0x2c85b8aa | 0;
+        _this.Hh = 0x0eb72ddc | 0;
+        _this.Hl = 0x81c52ca2 | 0;
+        _this.outputLen = 32;
+        return _this;
+    }
+    return SHA512_256;
+}(SHA512));
+var SHA384 = /** @class */ (function (_super) {
+    __extends(SHA384, _super);
+    function SHA384() {
+        var _this = _super.call(this) || this;
+        // h -- high 32 bits, l -- low 32 bits
+        _this.Ah = 0xcbbb9d5d | 0;
+        _this.Al = 0xc1059ed8 | 0;
+        _this.Bh = 0x629a292a | 0;
+        _this.Bl = 0x367cd507 | 0;
+        _this.Ch = 0x9159015a | 0;
+        _this.Cl = 0x3070dd17 | 0;
+        _this.Dh = 0x152fecd8 | 0;
+        _this.Dl = 0xf70e5939 | 0;
+        _this.Eh = 0x67332667 | 0;
+        _this.El = 0xffc00b31 | 0;
+        _this.Fh = 0x8eb44a87 | 0;
+        _this.Fl = 0x68581511 | 0;
+        _this.Gh = 0xdb0c2e0d | 0;
+        _this.Gl = 0x64f98fa7 | 0;
+        _this.Hh = 0x47b5481d | 0;
+        _this.Hl = 0xbefa4fa4 | 0;
+        _this.outputLen = 48;
+        return _this;
+    }
+    return SHA384;
+}(SHA512));
+exports.sha512 = (0, utils_1.wrapConstructor)(function () { return new SHA512(); });
+exports.sha512_224 = (0, utils_1.wrapConstructor)(function () { return new SHA512_224(); });
+exports.sha512_256 = (0, utils_1.wrapConstructor)(function () { return new SHA512_256(); });
+exports.sha384 = (0, utils_1.wrapConstructor)(function () { return new SHA384(); });

package/dist/noble/utils.d.ts

@@ -0,0 +1,90 @@
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+export type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array | Uint16Array | Int16Array | Uint32Array | Int32Array;
+export declare const u8: (arr: TypedArray) => Uint8Array;
+export declare const u32: (arr: TypedArray) => Uint32Array;
+export declare const createView: (arr: TypedArray) => DataView;
+export declare const rotr: (word: number, shift: number) => number;
+export declare const rotl: (word: number, shift: number) => number;
+export declare const isLE: boolean;
+export declare const byteSwap: (word: number) => number;
+export declare const byteSwapIfBE: (n: number) => number;
+export declare function byteSwap32(arr: Uint32Array): void;
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare const nextTick: () => Promise<void>;
+export declare function asyncLoop(iters: number, tick: number, cb: (i: number) => void): Promise<void>;
+export type Input = Uint8Array | string;
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+export declare function toBytes(data: Input): Uint8Array;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+export declare abstract class Hash<T extends Hash<T>> {
+    abstract blockLen: number;
+    abstract outputLen: number;
+    abstract update(buf: Input): this;
+    abstract digestInto(buf: Uint8Array): void;
+    abstract digest(): Uint8Array;
+    /**
+     * Resets internal state. Makes Hash instance unusable.
+     * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed
+   * by user, they will need to manually call `destroy()` when zeroing is necessary.
+     */
+    abstract destroy(): void;
+    /**
+     * Clones hash instance. Unsafe: doesn't check whether `to` is valid. Can be used as `clone()`
+     * when no options are passed.
+     * Reasons to use `_cloneInto` instead of clone: 1) performance 2) reuse instance => all internal
+   * buffers are overwritten => causes buffer overwrite which is used for digest in some cases.
+     * There are no guarantees for clean-up because it's impossible in JS.
+     */
+    abstract _cloneInto(to?: T): T;
+    clone(): T;
+}
+/**
+ * XOF: streaming API to read digest in chunks.
+ * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.
+ * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot
+ * destroy state, next call can require more bytes.
+ */
+export type HashXOF<T extends Hash<T>> = Hash<T> & {
+    xof(bytes: number): Uint8Array;
+    xofInto(buf: Uint8Array): Uint8Array;
+};
+type EmptyObj = {};
+export declare function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(defaults: T1, opts?: T2): T1 & T2;
+export type CHash = ReturnType<typeof wrapConstructor>;
+export declare function wrapConstructor<T extends Hash<T>>(hashCons: () => Hash<T>): {
+    (msg: Input): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(): Hash<T>;
+};
+export declare function wrapConstructorWithOpts<H extends Hash<H>, T extends Object>(hashCons: (opts?: T) => Hash<H>): {
+    (msg: Input, opts?: T): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(opts: T): Hash<H>;
+};
+export declare function wrapXOFConstructorWithOpts<H extends HashXOF<H>, T extends Object>(hashCons: (opts?: T) => HashXOF<H>): {
+    (msg: Input, opts?: T): Uint8Array;
+    outputLen: number;
+    blockLen: number;
+    create(opts: T): HashXOF<H>;
+};
+/**
+ * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+ */
+export declare function randomBytes(bytesLength?: number): Uint8Array;
+export {};

package/dist/noble/utils.js

@@ -0,0 +1,278 @@
+"use strict";
+/*
+THIS IMPLEMENTATION WAS TAKEN FROM `@noble/hashes`
+
+original source: https://github.com/paulmillr/noble-hashes/blob/6ae82e75d4c354d53a488e95b1bfe9cba90bd6ff/src/utils.ts#L1
+
+it was modified and adapted to this repository to re-use already defined stuff
+
+the main reason for copying over and not using as dependency is because of different target in the `tsconfig.json`
+
+`@noble/hashes` targets es2020, which tends to cause problems with some other (older) packages sometimes
+
+this repo targets ES5+
+*/
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.byteSwap32 = exports.byteSwapIfBE = exports.byteSwap = exports.isLE = exports.rotl = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;
+var uint8array_utils_1 = require("@harmoniclabs/uint8array-utils");
+var assert_1 = require("../utils/assert.js");
+var crypto_1 = require("./crypto.js");
+// Cast array to different type
+var u8 = function (arr) { return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength); };
+exports.u8 = u8;
+var u32 = function (arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+};
+exports.u32 = u32;
+// Cast array to view
+var createView = function (arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+};
+exports.createView = createView;
+// The rotate right (circular right shift) operation for uint32
+var rotr = function (word, shift) { return (word << (32 - shift)) | (word >>> shift); };
+exports.rotr = rotr;
+// The rotate left (circular left shift) operation for uint32
+var rotl = function (word, shift) {
+    return (word << shift) | ((word >>> (32 - shift)) >>> 0);
+};
+exports.rotl = rotl;
+exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+// The byte swap operation for uint32
+var byteSwap = function (word) {
+    return ((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff);
+};
+exports.byteSwap = byteSwap;
+// Conditionally byte swap if on a big-endian platform
+exports.byteSwapIfBE = exports.isLE ? function (n) { return n; } : function (n) { return (0, exports.byteSwap)(n); };
+// In place byte swap for Uint32Array
+function byteSwap32(arr) {
+    for (var i = 0; i < arr.length; i++) {
+        arr[i] = (0, exports.byteSwap)(arr[i]);
+    }
+}
+exports.byteSwap32 = byteSwap32;
+// Array where index 0xf0 (240) is mapped to string 'f0'
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, function (_, i) {
+    return i.toString(16).padStart(2, '0');
+});
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    (0, assert_1.assertBytes)(bytes);
+    // pre-caching improves the speed 6x
+    var hex = '';
+    for (var i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+// We use optimized technique to convert hex string to byte array
+var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+function asciiToBase16(char) {
+    if (char >= asciis._0 && char <= asciis._9)
+        return char - asciis._0;
+    if (char >= asciis._A && char <= asciis._F)
+        return char - (asciis._A - 10);
+    if (char >= asciis._a && char <= asciis._f)
+        return char - (asciis._a - 10);
+    return;
+}
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    var hl = hex.length;
+    var al = hl / 2;
+    if (hl % 2)
+        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+    var array = new Uint8Array(al);
+    for (var ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        var n1 = asciiToBase16(hex.charCodeAt(hi));
+        var n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            var char = hex[hi] + hex[hi + 1];
+            throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2;
+    }
+    return array;
+}
+exports.hexToBytes = hexToBytes;
+// There is no setImmediate in browser and setTimeout is slow.
+// call of async fn will return Promise, which will be fullfiled only on
+// next scheduler queue processing step and this is exactly what we need.
+var nextTick = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_b) {
+    return [2 /*return*/];
+}); }); };
+exports.nextTick = nextTick;
+// Returns control to thread each 'tick' ms to avoid blocking
+function asyncLoop(iters, tick, cb) {
+    return __awaiter(this, void 0, void 0, function () {
+        var ts, i, diff;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    ts = Date.now();
+                    i = 0;
+                    _b.label = 1;
+                case 1:
+                    if (!(i < iters)) return [3 /*break*/, 4];
+                    cb(i);
+                    diff = Date.now() - ts;
+                    if (diff >= 0 && diff < tick)
+                        return [3 /*break*/, 3];
+                    return [4 /*yield*/, (0, exports.nextTick)()];
+                case 2:
+                    _b.sent();
+                    ts += diff;
+                    _b.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.asyncLoop = asyncLoop;
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = (0, uint8array_utils_1.fromUtf8)(data);
+    (0, assert_1.assertBytes)(data);
+    return data;
+}
+exports.toBytes = toBytes;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function concatBytes() {
+    var arrays = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        arrays[_i] = arguments[_i];
+    }
+    var sum = 0;
+    for (var i = 0; i < arrays.length; i++) {
+        var a = arrays[i];
+        (0, assert_1.assertBytes)(a);
+        sum += a.length;
+    }
+    var res = new Uint8Array(sum);
+    for (var i = 0, pad = 0; i < arrays.length; i++) {
+        var a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+exports.concatBytes = concatBytes;
+// For runtime check if class implements interface
+var Hash = /** @class */ (function () {
+    function Hash() {
+    }
+    // Safe version that clones internal state
+    Hash.prototype.clone = function () {
+        return this._cloneInto();
+    };
+    return Hash;
+}());
+exports.Hash = Hash;
+var toStr = {}.toString;
+function checkOpts(defaults, opts) {
+    if (opts !== undefined && toStr.call(opts) !== '[object Object]')
+        throw new Error('Options should be object or undefined');
+    var merged = Object.assign(defaults, opts);
+    return merged;
+}
+exports.checkOpts = checkOpts;
+function wrapConstructor(hashCons) {
+    var hashC = function (msg) { return hashCons().update(toBytes(msg)).digest(); };
+    var tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = function () { return hashCons(); };
+    return hashC;
+}
+exports.wrapConstructor = wrapConstructor;
+function wrapConstructorWithOpts(hashCons) {
+    var hashC = function (msg, opts) { return hashCons(opts).update(toBytes(msg)).digest(); };
+    var tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = function (opts) { return hashCons(opts); };
+    return hashC;
+}
+exports.wrapConstructorWithOpts = wrapConstructorWithOpts;
+function wrapXOFConstructorWithOpts(hashCons) {
+    var hashC = function (msg, opts) { return hashCons(opts).update(toBytes(msg)).digest(); };
+    var tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = function (opts) { return hashCons(opts); };
+    return hashC;
+}
+exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
+/**
+ * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+ */
+function randomBytes(bytesLength) {
+    if (bytesLength === void 0) { bytesLength = 32; }
+    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    var bytes = new Uint8Array(bytesLength);
+    for (var i = 0; i < bytesLength; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return bytes;
+}
+exports.randomBytes = randomBytes;

package/dist/ripemd_160.d.ts

@@ -0,0 +1 @@
+export declare function ripemd160(input: Uint8Array | string): Uint8Array;