quarkdash 1.0.8 → 1.1.0

package/src/ringlwe.ts

@@ -1,340 +0,0 @@
-/**
- * QuarkDash Ring-LWE Implementation
- *
- * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
- * @author          Elijah Rastorguev
- * @build           1002
- * @website         https://dev.to/devsdaddy
- * @updated         12.04.2026
- */
-/* Import Required Modules */
-import {ICryptoEncapsulated, ICryptoKeyPair, IKeyExchange} from "./types";
-import {QuarkDashUtils} from "./utils";
-import {SHA256} from "./sha";
-
-/**
- * Ring-LWE based key exchange implementation
- */
-export class QuarkDashKeyExchange implements IKeyExchange {
-    // Ring-LWE Constants
-    private static readonly N = 256;
-    private static readonly Q = 7681n;
-    private static readonly ROOT = 7n;
-    private static readonly INV_N = this.modInverse(BigInt(this.N), this.Q);
-
-    /**
-     * Generate crypto key pair async
-     * @returns {ICryptoKeyPair} Crypto key pair
-     * TODO: GPU Calculations
-     */
-    public async generateKeyPair(): Promise<ICryptoKeyPair> {
-        return this.generateKeyPairSync();
-    }
-
-    /**
-     * Generate crypto key pair sync
-     * @returns {ICryptoKeyPair} Crypto key pair
-     */
-    public generateKeyPairSync(): ICryptoKeyPair {
-        const a = QuarkDashKeyExchange.uniformPoly();
-        const s = QuarkDashKeyExchange.smallPoly();
-        const e = QuarkDashKeyExchange.errorPoly();
-        const as = QuarkDashKeyExchange.multiply(a, s);
-        const b = new Array<bigint>(QuarkDashKeyExchange.N);
-        for (let i = 0; i < QuarkDashKeyExchange.N; i++) {
-            b[i] = (as[i] + e[i]) % QuarkDashKeyExchange.Q;
-        }
-        const publicKey = QuarkDashUtils.concatBytes(
-            QuarkDashKeyExchange.serializePoly(a),
-            QuarkDashKeyExchange.serializePoly(b)
-        );
-        const privateKey = QuarkDashKeyExchange.serializePoly(s);
-        return { publicKey, privateKey };
-    }
-
-    /**
-     * Encapsulate async
-     * @param publicKey {Uint8Array} Public key buffer
-     * @returns {Promise<ICryptoEncapsulated>} Encapsulated data
-     * TODO: GPU Calculations
-     */
-    public async encapsulate(publicKey: Uint8Array): Promise<ICryptoEncapsulated> {
-        return this.encapsulateSync(publicKey);
-    }
-
-    /**
-     * Encapsulate sync
-     * @param publicKey {Uint8Array} Public key buffer
-     * @returns {ICryptoEncapsulated} Encapsulated data
-     */
-    public encapsulateSync(publicKey: Uint8Array): ICryptoEncapsulated {
-        const aBytes = publicKey.slice(0, QuarkDashKeyExchange.N * 2);
-        const bBytes = publicKey.slice(QuarkDashKeyExchange.N * 2);
-        const a = QuarkDashKeyExchange.deserializePoly(aBytes);
-        const b = QuarkDashKeyExchange.deserializePoly(bBytes);
-        const sp = QuarkDashKeyExchange.smallPoly();
-        const ep = QuarkDashKeyExchange.errorPoly();
-        const uArr = QuarkDashKeyExchange.multiply(a, sp);
-        for (let i = 0; i < QuarkDashKeyExchange.N; i++) {
-            uArr[i] = (uArr[i] + ep[i]) % QuarkDashKeyExchange.Q;
-        }
-        const w = QuarkDashKeyExchange.multiply(b, sp);
-        const rawSecret = QuarkDashKeyExchange.roundToBits(w);
-        const ciphertext = QuarkDashKeyExchange.serializePoly(uArr);
-        const sharedSecret = QuarkDashKeyExchange.hashSharedSecret(rawSecret, publicKey, ciphertext);
-        return { ciphertext, sharedSecret };
-    }
-
-    /**
-     * Decapsulate async
-     * @param privateKey {Uint8Array} Private key buffer
-     * @param peerPublicKey {Uint8Array} Peer public key
-     * @param ciphertext {Uint8Array} Cipher text buffer
-     * @returns {Promise<Uint8Array>} Buffer data
-     * TODO: GPU Calculations
-     */
-    public async decapsulate(privateKey: Uint8Array, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array> {
-        return this.decapsulateSync(privateKey, peerPublicKey, ciphertext);
-    }
-
-    /**
-     * Decapsulate sync
-     * @param privateKey {Uint8Array} Private key buffer
-     * @param peerPublicKey{Uint8Array} Peer public key buffer
-     * @param ciphertext {Uint8Array} Cipher text buffer
-     * @returns {Uint8Array} Buffer data
-     */
-    public decapsulateSync(privateKey: Uint8Array, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array {
-        const s = QuarkDashKeyExchange.deserializePoly(privateKey);
-        const u = QuarkDashKeyExchange.deserializePoly(ciphertext);
-        const w = QuarkDashKeyExchange.multiply(u, s);
-        const rawSecret = QuarkDashKeyExchange.roundToBits(w);
-        return QuarkDashKeyExchange.hashSharedSecret(rawSecret, peerPublicKey, ciphertext);
-    }
-
-    /**
-     * Get small polygon
-     * @returns {bigint[]} Small polygon
-     * @private
-     */
-    private static smallPoly(): bigint[] {
-        const poly = new Array<bigint>(this.N);
-        const bytesNeeded = Math.ceil(this.N * 2 / 8);
-        const randomBytes = QuarkDashUtils.randomBytes(bytesNeeded);
-        for (let i = 0; i < this.N; i++) {
-            const byteIdx = Math.floor(i * 2 / 8);
-            const bitShift = (i * 2) % 8;
-            const val = (randomBytes[byteIdx] >> bitShift) & 0x03; // 0..3
-            if (val === 0) poly[i] = -1n;
-            else if (val === 1) poly[i] = 0n;
-            else if (val === 2) poly[i] = 1n;
-            else {
-                poly[i] = 1n;
-            }
-        }
-        return poly;
-    }
-
-    /**
-     * Uniform polygon
-     * @returns {bigint[]}
-     * @private
-     */
-    private static uniformPoly(): bigint[] {
-        const poly = new Array<bigint>(this.N);
-        const bytes = QuarkDashUtils.randomBytes(this.N * 2);
-        for (let i = 0; i < this.N; i++) {
-            const val = (bytes[2 * i] | (bytes[2 * i + 1] << 8)) % Number(this.Q);
-            poly[i] = BigInt(val);
-        }
-        return poly;
-    }
-
-    /**
-     * Error polygon
-     * @private
-     */
-    private static errorPoly(): bigint[] {
-        const poly = new Array<bigint>(this.N);
-        const SIGMA = 3.19;
-        for (let i = 0; i < this.N; i++) {
-            let sum = 0;
-            const randBytes = QuarkDashUtils.randomBytes(12);
-            for (let j = 0; j < 12; j++) {
-                sum += randBytes[j];
-            }
-            // Центрируем и масштабируем к [-6,6]
-            const centered = (sum / 255) - 6;
-            const error = Math.floor(centered * SIGMA);
-            poly[i] = BigInt(Math.max(-Number(this.Q), Math.min(Number(this.Q) - 1, error)));
-        }
-        return poly;
-    }
-
-    /**
-     * NTT Operation
-     * @param poly {bigint[]} Polygon
-     * @private
-     */
-    private static ntt(poly: bigint[]): bigint[] {
-        const res = [...poly];
-        let len = 2;
-        while (len <= this.N) {
-            const wlen = this.powMod(this.ROOT, BigInt(this.N / len), this.Q);
-            for (let i = 0; i < this.N; i += len) {
-                let w = 1n;
-                for (let j = 0; j < len / 2; j++) {
-                    const u = res[i + j];
-                    const v = (res[i + j + len / 2] * w) % this.Q;
-                    res[i + j] = (u + v) % this.Q;
-                    res[i + j + len / 2] = (u - v + this.Q) % this.Q;
-                    w = (w * wlen) % this.Q;
-                }
-            }
-            len <<= 1;
-        }
-        return res;
-    }
-
-    /**
-     * Inverse NTT
-     * @param poly {bigint[]} Polygon
-     * @private
-     */
-    private static invNTT(poly: bigint[]): bigint[] {
-        const res = [...poly];
-        let len = this.N;
-        while (len >= 2) {
-            const wlen = this.powMod(this.ROOT, BigInt(this.N / len), this.Q);
-            for (let i = 0; i < this.N; i += len) {
-                let w = 1n;
-                for (let j = 0; j < len / 2; j++) {
-                    const u = res[i + j];
-                    const v = res[i + j + len / 2];
-                    res[i + j] = (u + v) % this.Q;
-                    res[i + j + len / 2] = ((u - v + this.Q) * w) % this.Q;
-                    w = (w * wlen) % this.Q;
-                }
-            }
-            len >>= 1;
-        }
-        for (let i = 0; i < this.N; i++) {
-            res[i] = (res[i] * this.INV_N) % this.Q;
-        }
-        return res;
-    }
-
-    /**
-     * Multiply
-     * @param a {bigint[]} Polygon
-     * @param b {bigint[]} Polygon
-     * @returns {bigint[]} Multiplied polygons
-     */
-    public static multiply(a: bigint[], b: bigint[]): bigint[] {
-        const aNTT = this.ntt(a);
-        const bNTT = this.ntt(b);
-        const prod = new Array<bigint>(this.N);
-        for (let i = 0; i < this.N; i++) {
-            prod[i] = (aNTT[i] * bNTT[i]) % this.Q;
-        }
-        return this.invNTT(prod);
-    }
-
-    /**
-     * Serialize polygon
-     * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} Polygon buffer
-     * @private
-     */
-    private static serializePoly(poly: bigint[]): Uint8Array {
-        const bytes = new Uint8Array(this.N * 2);
-        for (let i = 0; i < this.N; i++) {
-            const val = Number(poly[i]);
-            bytes[2 * i] = val & 0xFF;
-            bytes[2 * i + 1] = (val >> 8) & 0xFF;
-        }
-        return bytes;
-    }
-
-    /**
-     * Deserialize Polygon
-     * @param bytes {Uint8Array} Polygon buffer
-     * @returns {bigint[]} Polygon
-     * @private
-     */
-    private static deserializePoly(bytes: Uint8Array): bigint[] {
-        const poly = new Array<bigint>(this.N);
-        for (let i = 0; i < this.N; i++) {
-            const val = bytes[2 * i] | (bytes[2 * i + 1] << 8);
-            poly[i] = BigInt(val);
-        }
-        return poly;
-    }
-
-    /**
-     * Round to bits
-     * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} rounded buffer
-     * @private
-     */
-    private static roundToBits(poly: bigint[]): Uint8Array {
-        const result = new Uint8Array(32);
-        for (let i = 0; i < this.N; i++) {
-            const bit = (Number(poly[i]) > Number(this.Q) / 2) ? 1 : 0;
-            if (bit) result[i >> 3] |= (1 << (i & 7));
-        }
-        return result;
-    }
-
-    /**
-     * Modular exponentiation
-     * @param base {bigint} Base
-     * @param exp {bigint} exponential
-     * @param mod {bigint} module
-     * @returns {bigint} Result of modular exponentiation
-     * @private
-     */
-    private static powMod(base: bigint, exp: bigint, mod: bigint): bigint {
-        let result = 1n;
-        let b = base % mod;
-        let e = exp;
-        while (e > 0n) {
-            if (e & 1n) result = (result * b) % mod;
-            b = (b * b) % mod;
-            e >>= 1n;
-        }
-        return result;
-    }
-
-    /**
-     * Modular inverse
-     * @param a {bigint}
-     * @param m {bigint}
-     * @returns {bigint} Inversion result
-     * @private
-     */
-    private static modInverse(a: bigint, m: bigint): bigint {
-        let [old_r, r] = [a, m];
-        let [old_s, s] = [1n, 0n];
-        while (r !== 0n) {
-            const q = old_r / r;
-            [old_r, r] = [r, old_r - q * r];
-            [old_s, s] = [s, old_s - q * s];
-        }
-        return (old_s % m + m) % m;
-    }
-
-    /**
-     * Hash shared secret
-     * @param ss {Uint8Array} Shared secret buffer
-     * @param publicKey {Uint8Array} Public key buffer
-     * @param ciphertext {Uint8Array} Cipher text buffer
-     * @returns {Uint8Array} Shared secret hash
-     * @private
-     */
-    private static hashSharedSecret(ss: Uint8Array, publicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array {
-        const data = QuarkDashUtils.concatBytes(ss, publicKey, ciphertext);
-        return SHA256.hash(data, true) as Uint8Array;
-    }
-}

package/src/sha.ts

@@ -1,265 +0,0 @@
-/**
- * QuarkDash SHA Implementations
- *
- * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
- * @author          Elijah Rastorguev
- * @build           1000
- * @website         https://dev.to/devsdaddy
- */
-/**
- * SHA-256 Implementation
- */
-export class SHA256 {
-    // Constants
-    private static readonly K: number[] = [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-    ];
-
-    /**
-     * Right Rotate
-     * @param value {number} Value to rotate
-     * @param amount {number} Rotate amount
-     * @private
-     */
-    private static rightRotate(value: number, amount: number): number {
-        return (value >>> amount) | (value << (32 - amount));
-    }
-
-    /**
-     * Get SHA256 Hash
-     * @param data {string|Uint8Array} Raw string or bytes array
-     * @param returnBytes {boolean} Returns HEX String or Uint8Array
-     * @returns {string|Uint8Array} HEX String or Uint8Array
-     */
-    static hash(data: string | Uint8Array, returnBytes : boolean = false): string | Uint8Array {
-        const msgBytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-
-        // Initial hash values
-        let h0 = 0x6a09e667;
-        let h1 = 0xbb67ae85;
-        let h2 = 0x3c6ef372;
-        let h3 = 0xa54ff53a;
-        let h4 = 0x510e527f;
-        let h5 = 0x9b05688c;
-        let h6 = 0x1f83d9ab;
-        let h7 = 0x5be0cd19;
-
-        // Pre-processing: padding
-        const ml = msgBytes.length * 8;
-        const padded = new Uint8Array(((ml + 64 + 511) & ~511) / 8);
-        padded.set(msgBytes);
-        padded[msgBytes.length] = 0x80;
-
-        // Append length
-        const dv = new DataView(padded.buffer);
-        dv.setUint32(padded.length - 8, 0, false);
-        dv.setUint32(padded.length - 4, ml, false);
-
-        // Process chunks
-        for (let i = 0; i < padded.length; i += 64) {
-            const w = new Array(64).fill(0);
-
-            // Prepare message schedule
-            for (let j = 0; j < 16; j++) {
-                w[j] = dv.getUint32(i + j * 4, false);
-            }
-
-            for (let j = 16; j < 64; j++) {
-                const s0 = this.rightRotate(w[j - 15], 7) ^ this.rightRotate(w[j - 15], 18) ^ (w[j - 15] >>> 3);
-                const s1 = this.rightRotate(w[j - 2], 17) ^ this.rightRotate(w[j - 2], 19) ^ (w[j - 2] >>> 10);
-                w[j] = (w[j - 16] + s0 + w[j - 7] + s1) >>> 0;
-            }
-
-            // Initialize working variables
-            let a = h0;
-            let b = h1;
-            let c = h2;
-            let d = h3;
-            let e = h4;
-            let f = h5;
-            let g = h6;
-            let h = h7;
-
-            // Main loop
-            for (let j = 0; j < 64; j++) {
-                const S1 = this.rightRotate(e, 6) ^ this.rightRotate(e, 11) ^ this.rightRotate(e, 25);
-                const ch = (e & f) ^ ((~e) & g);
-                const temp1 = (h + S1 + ch + this.K[j] + w[j]) >>> 0;
-                const S0 = this.rightRotate(a, 2) ^ this.rightRotate(a, 13) ^ this.rightRotate(a, 22);
-                const maj = (a & b) ^ (a & c) ^ (b & c);
-                const temp2 = (S0 + maj) >>> 0;
-
-                h = g;
-                g = f;
-                f = e;
-                e = (d + temp1) >>> 0;
-                d = c;
-                c = b;
-                b = a;
-                a = (temp1 + temp2) >>> 0;
-            }
-
-            // Update hash values
-            h0 = (h0 + a) >>> 0;
-            h1 = (h1 + b) >>> 0;
-            h2 = (h2 + c) >>> 0;
-            h3 = (h3 + d) >>> 0;
-            h4 = (h4 + e) >>> 0;
-            h5 = (h5 + f) >>> 0;
-            h6 = (h6 + g) >>> 0;
-            h7 = (h7 + h) >>> 0;
-        }
-
-        // Produce final hash
-        const result = new Uint8Array(32);
-        const resultView = new DataView(result.buffer);
-        resultView.setUint32(0, h0, false);
-        resultView.setUint32(4, h1, false);
-        resultView.setUint32(8, h2, false);
-        resultView.setUint32(12, h3, false);
-        resultView.setUint32(16, h4, false);
-        resultView.setUint32(20, h5, false);
-        resultView.setUint32(24, h6, false);
-        resultView.setUint32(28, h7, false);
-
-        return (returnBytes) ? result as Uint8Array : Array.from(result).map(b => b.toString(16).padStart(2, '0')).join('') as string;
-    }
-}
-
-/**
- * SHA-512 Implementation
- */
-export class SHA512 {
-    // Constants
-    private static readonly K: bigint[] = [
-        0x428a2f98d728ae22n, 0x7137449123ef65cdn, 0xb5c0fbcfec4d3b2fn, 0xe9b5dba58189dbbcn,
-        0x3956c25bf348b538n, 0x59f111f1b605d019n, 0x923f82a4af194f9bn, 0xab1c5ed5da6d8118n,
-        0xd807aa98a3030242n, 0x12835b0145706fben, 0x243185be4ee4b28cn, 0x550c7dc3d5ffb4e2n,
-        0x72be5d74f27b896fn, 0x80deb1fe3b1696b1n, 0x9bdc06a725c71235n, 0xc19bf174cf692694n,
-        0xe49b69c19ef14ad2n, 0xefbe4786384f25e3n, 0x0fc19dc68b8cd5b5n, 0x240ca1cc77ac9c65n,
-        0x2de92c6f592b0275n, 0x4a7484aa6ea6e483n, 0x5cb0a9dcbd41fbd4n, 0x76f988da831153b5n,
-        0x983e5152ee66dfabn, 0xa831c66d2db43210n, 0xb00327c898fb213fn, 0xbf597fc7beef0ee4n,
-        0xc6e00bf33da88fc2n, 0xd5a79147930aa725n, 0x06ca6351e003826fn, 0x142929670a0e6e70n,
-        0x27b70a8546d22ffcn, 0x2e1b21385c26c926n, 0x4d2c6dfc5ac42aedn, 0x53380d139d95b3dfn,
-        0x650a73548baf63den, 0x766a0abb3c77b2a8n, 0x81c2c92e47edaee6n, 0x92722c851482353bn,
-        0xa2bfe8a14cf10364n, 0xa81a664bbc423001n, 0xc24b8b70d0f89791n, 0xc76c51a30654be30n,
-        0xd192e819d6ef5218n, 0xd69906245565a910n, 0xf40e35855771202an, 0x106aa07032bbd1b8n,
-        0x19a4c116b8d2d0c8n, 0x1e376c085141ab53n, 0x2748774cdf8eeb99n, 0x34b0bcb5e19b48a8n,
-        0x391c0cb3c5c95a63n, 0x4ed8aa4ae3418acbn, 0x5b9cca4f7763e373n, 0x682e6ff3d6b2b8a3n,
-        0x748f82ee5defb2fcn, 0x78a5636f43172f60n, 0x84c87814a1f0ab72n, 0x8cc702081a6439ecn,
-        0x90befffa23631e28n, 0xa4506cebde82bde9n, 0xbef9a3f7b2c67915n, 0xc67178f2e372532bn,
-        0xca273eceea26619cn, 0xd186b8c721c0c207n, 0xeada7dd6cde0eb1en, 0xf57d4f7fee6ed178n,
-        0x06f067aa72176fban, 0x0a637dc5a2c898a6n, 0x113f9804bef90daen, 0x1b710b35131c471bn,
-        0x28db77f523047d84n, 0x32caab7b40c72493n, 0x3c9ebe0a15c9bebcn, 0x431d67c49c100d4cn,
-        0x4cc5d4becb3e42b6n, 0x597f299cfc657e2an, 0x5fcb6fab3ad6faecn, 0x6c44198c4a475817n
-    ];
-
-    /**
-     * Bitint right rotate
-     * @param value {number} Value
-     * @param amount {number} Rotate amount
-     * @private
-     */
-    private static rightRotate(value: bigint, amount: number): bigint {
-        return (value >> BigInt(amount)) | (value << (64n - BigInt(amount)));
-    }
-
-    /**
-     * Get SHA512 Hash
-     * @param data {string|Uint8Array} Raw string or bytes array
-     * @param returnBytes {boolean} Returns HEX String or Uint8Array
-     * @returns {string|Uint8Array} HEX String or Uint8Array
-     */
-    static hash(data: string | Uint8Array, returnBytes : boolean = false): string | Uint8Array {
-        const msgBytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-
-        // Initial hash values
-        let h0 = 0x6a09e667f3bcc908n;
-        let h1 = 0xbb67ae8584caa73bn;
-        let h2 = 0x3c6ef372fe94f82bn;
-        let h3 = 0xa54ff53a5f1d36f1n;
-        let h4 = 0x510e527fade682d1n;
-        let h5 = 0x9b05688c2b3e6c1fn;
-        let h6 = 0x1f83d9abfb41bd6bn;
-        let h7 = 0x5be0cd19137e2179n;
-
-        const ml = BigInt(msgBytes.length * 8);
-        const padded = new Uint8Array((((Number(ml) + 128 + 1023) & ~1023) / 8));
-        padded.set(msgBytes);
-        padded[msgBytes.length] = 0x80;
-
-        const dv = new DataView(padded.buffer);
-        dv.setBigUint64(padded.length - 8, ml, false);
-
-        for (let i = 0; i < padded.length; i += 128) {
-            const w = new Array(80).fill(0n);
-
-            for (let j = 0; j < 16; j++) {
-                w[j] = dv.getBigUint64(i + j * 8, false);
-            }
-
-            for (let j = 16; j < 80; j++) {
-                const s0 = this.rightRotate(w[j - 15], 1) ^ this.rightRotate(w[j - 15], 8) ^ (w[j - 15] >> 7n);
-                const s1 = this.rightRotate(w[j - 2], 19) ^ this.rightRotate(w[j - 2], 61) ^ (w[j - 2] >> 6n);
-                w[j] = (w[j - 16] + s0 + w[j - 7] + s1) & 0xffffffffffffffffn;
-            }
-
-            let a = h0;
-            let b = h1;
-            let c = h2;
-            let d = h3;
-            let e = h4;
-            let f = h5;
-            let g = h6;
-            let h = h7;
-
-            for (let j = 0; j < 80; j++) {
-                const S1 = this.rightRotate(e, 14) ^ this.rightRotate(e, 18) ^ this.rightRotate(e, 41);
-                const ch = (e & f) ^ ((~e) & g);
-                const temp1 = (h + S1 + ch + this.K[j] + w[j]) & 0xffffffffffffffffn;
-                const S0 = this.rightRotate(a, 28) ^ this.rightRotate(a, 34) ^ this.rightRotate(a, 39);
-                const maj = (a & b) ^ (a & c) ^ (b & c);
-                const temp2 = (S0 + maj) & 0xffffffffffffffffn;
-
-                h = g;
-                g = f;
-                f = e;
-                e = (d + temp1) & 0xffffffffffffffffn;
-                d = c;
-                c = b;
-                b = a;
-                a = (temp1 + temp2) & 0xffffffffffffffffn;
-            }
-
-            h0 = (h0 + a) & 0xffffffffffffffffn;
-            h1 = (h1 + b) & 0xffffffffffffffffn;
-            h2 = (h2 + c) & 0xffffffffffffffffn;
-            h3 = (h3 + d) & 0xffffffffffffffffn;
-            h4 = (h4 + e) & 0xffffffffffffffffn;
-            h5 = (h5 + f) & 0xffffffffffffffffn;
-            h6 = (h6 + g) & 0xffffffffffffffffn;
-            h7 = (h7 + h) & 0xffffffffffffffffn;
-        }
-
-        const result = new Uint8Array(64);
-        const resultView = new DataView(result.buffer);
-        resultView.setBigUint64(0, h0, false);
-        resultView.setBigUint64(8, h1, false);
-        resultView.setBigUint64(16, h2, false);
-        resultView.setBigUint64(24, h3, false);
-        resultView.setBigUint64(32, h4, false);
-        resultView.setBigUint64(40, h5, false);
-        resultView.setBigUint64(48, h6, false);
-        resultView.setBigUint64(56, h7, false);
-
-        return (returnBytes) ? result as Uint8Array : Array.from(result).map(b => b.toString(16).padStart(2, '0')).join('') as string;
-    }
-}