quarkdash 1.0.7 → 1.1.0

package/dist/types/cipher/chacha.d.ts

@@ -0,0 +1,67 @@
+import { ICipher } from "../core/types";
+/**
+ * ChaCha20 Based Cipher Implementation
+ */
+export declare class QuarkDashChaCha implements ICipher {
+    private readonly key;
+    private readonly nonce;
+    private static readonly BLOCK_SIZE;
+    private static readonly BLOCKS_PER_BATCH;
+    private static readonly BATCH_SIZE;
+    /**
+     * Create ChaCha20 Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array);
+    /**
+     * Encrypt data async using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt data async using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt data sync using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    encryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Decrypt data sync using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    decryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Process ChaCha20 Cipher
+     * @param data {Uint8Array} Data for processing
+     * @returns {Uint8Array} Processing result
+     * @private
+     */
+    private process;
+    /**
+     * Quarter Round
+     * @param s {Uint8Array} Buffer
+     * @param a {number}
+     * @param b {number}
+     * @param c {number}
+     * @param d {number}
+     * @private
+     */
+    private quarterRound;
+    /**
+     * Generate Keystream Batch
+     * @param startCounter {number} Start counter
+     * @param count {number} Count
+     * @private
+     */
+    private generateKeystreamBatch;
+}

package/dist/types/cipher/cipher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * QuarkDash Ciphers Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.1.0
+ * @author          Elijah Rastorguev
+ * @build           1002
+ * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
+ */
+import { ICipher } from "../core/types";
+/**
+ * Cipher Type
+ */
+export declare enum CipherType {
+    ChaCha20 = 0,
+    Gimli = 1
+}
+/**
+ * Cipher Factory
+ */
+export declare class CipherFactory {
+    /**
+     * Create Cipher
+     * @param algorithm {CipherType} Current cipher type
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     * @returns {ICipher} Cipher class instance
+     */
+    static create(algorithm: CipherType, key: Uint8Array, nonce: Uint8Array): ICipher;
+}

package/dist/types/cipher/gimli.d.ts

@@ -0,0 +1,64 @@
+import { ICipher } from "../core/types";
+/**
+ * Gimli Cipher
+ */
+export declare class QuarkDashGimli implements ICipher {
+    private readonly key;
+    private readonly nonce;
+    private static readonly BLOCK_SIZE;
+    private static readonly BLOCKS_PER_BATCH;
+    private static readonly BATCH_SIZE;
+    /**
+     * Create Gimli Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array);
+    /**
+     * Encrypt data async using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt data async using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt data sync using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    encryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Decrypt data sync using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    decryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Process Gimli Cipher
+     * @param data {Uint8Array} Input buffer
+     * @returns {Uint8Array} Output buffer
+     * @private
+     */
+    private process;
+    /**
+     * Generate keystream batch
+     * @param startCounter {number} Start counter
+     * @param count {number} Count
+     * @private
+     */
+    private generateKeystreamBatch;
+    /**
+     * Gimli Round
+     * @param state {Uint32Array} State buffer
+     * @param round {number} Round number
+     * @private
+     */
+    private gimliRound;
+}

package/dist/types/{kdf.d.ts → core/kdf.d.ts}

@@ -2,10 +2,11 @@
  * QuarkDash Shake256 Based KDF
  *
  * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
+ * @version         1.1.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1001
  * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
  */
 import type { IKDF } from "./types";
 /**

package/dist/types/{mac.d.ts → core/mac.d.ts}

@@ -2,16 +2,19 @@
  * QuarkDash Shake256 Based MAC
  *
  * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
+ * @version         1.1.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1003
  * @website         https://dev.to/devsdaddy
+ * @updated         14.04.2026
  */
 import { IMAC } from "./types";
 /**
  * MAC implementation using Shake-256
  */
 export declare class QuarkDashMAC implements IMAC {
+    private tempBuffer;
+    constructor();
     /**
      * Sign data async
      * @param data {Uint8Array} Data buffer
@@ -29,6 +32,22 @@ export declare class QuarkDashMAC implements IMAC {
      * TODO: GPU Calculations
      */
     verify(data: Uint8Array, key: Uint8Array, tag: Uint8Array): Promise<boolean>;
+    /**
+     * Sign two async
+     * @param data1 {Uint8Array} First buffer
+     * @param data2 {Uint8Array} Second buffer
+     * @param key {Uint8Array} Key
+     * @returns {Promise<Uint8Array>}
+     */
+    signTwo(data1: Uint8Array, data2: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Sign two sync
+     * @param data1 {Uint8Array} First buffer
+     * @param data2 {Uint8Array} Second buffer
+     * @param key {Uint8Array} Key
+     * @returns {Uint8Array}
+     */
+    signTwoSync(data1: Uint8Array, data2: Uint8Array, key: Uint8Array): Uint8Array;
     /**
      * Sign data sync
      * @param data {Uint8Array} Data buffer

package/dist/types/{types.d.ts → core/types.d.ts}

@@ -2,10 +2,11 @@
  * QuarkDash Crypto Types
  *
  * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
+ * @version         1.1.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1001
  * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
  */
 /**
  * Crypto methods async interface
@@ -38,8 +39,10 @@ export interface IKDF {
  */
 export interface IMAC {
     sign(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    signTwo(data1: Uint8Array, data2: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
     verify(data: Uint8Array, key: Uint8Array, tag: Uint8Array): Promise<boolean>;
     signSync(data: Uint8Array, key: Uint8Array): Uint8Array;
+    signTwoSync(data1: Uint8Array, data2: Uint8Array, key: Uint8Array): Uint8Array;
     verifySync(data: Uint8Array, key: Uint8Array, tag: Uint8Array): boolean;
 }
 /**

package/dist/types/{utils.d.ts → core/utils.d.ts}

@@ -117,4 +117,17 @@ export declare class QuarkDashUtils {
      * @returns {bigint} Bigint
      */
     static readUint64(arr: Uint8Array, off: number): bigint;
+    /**
+     * Read Uint32 Little Endian Value
+     * @param arr {Uint8Array} Buffer
+     * @param off {number} Offset
+     */
+    static readUint32LE(arr: Uint8Array, off: number): number;
+    /**
+     * Write Uint32 Little Endian Value
+     * @param v {number} Value
+     * @param arr {Uint8Array} Buffer
+     * @param off {number} Offset
+     */
+    static writeUint32LE(v: number, arr: Uint8Array, off: number): void;
 }

package/dist/types/core/wasm_loader.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Load WASM Module
+ * @param wasmUrl
+ */
+export declare function loadWasmModule(wasmUrl: string): Promise<WebAssembly.Module>;

package/dist/types/crypto.d.ts

@@ -4,11 +4,12 @@
  * @git             https://github.com/devsdaddy/quarkdash
  * @version         1.0.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1105
  * @website         https://dev.to/devsdaddy
+ * @updated         14.04.2026
  */
-import { CipherType } from "./cipher";
-import { ICryptoMethodAsync, ICryptoMethodSync, IKDF, IKeyExchange, IMAC } from "./types";
+import { CipherType } from "./cipher/cipher";
+import { ICryptoMethodAsync, ICryptoMethodSync, IKDF, IKeyExchange, IMAC } from "./core/types";
 /**
  * Quark Dash parsed encrypted packet
  */
@@ -27,6 +28,10 @@ export interface QuarkDashOptions {
     keyExchange: IKeyExchange;
     maxPacketWindow: number;
     timestampToleranceMs: number;
+    WASM: {
+        isEnabled: boolean;
+        shakePath: string;
+    };
 }
 /**
  * QuarkDash Crypto Algorithm Implementation
@@ -37,7 +42,6 @@ export declare class QuarkDash implements ICryptoMethodAsync, ICryptoMethodSync
     private cipher;
     private macKey;
     private sendSeq;
-    private recvSeq;
     private receivedPackets;
     private myKeyPair?;
     private peerPublicKey?;

package/dist/types/{sha.d.ts → hash/sha.d.ts}

@@ -2,10 +2,11 @@
  * QuarkDash SHA Implementations
  *
  * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
+ * @version         1.1.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1001
  * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
  */
 /**
  * SHA-256 Implementation

package/dist/types/hash/shake.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Shake-256 Web Assembly Implementation
+ */
+export declare class Shake256Wasm {
+    static initializedWasm: boolean;
+    private static instance;
+    private static memory;
+    private static shake256Func;
+    private static nextPtr;
+    /**
+     * Alloc
+     * @param size
+     * @private
+     */
+    private static alloc;
+    /**
+     * Initialize WASM Module
+     * @param wasmUrl {string} Path to module
+     */
+    static initWasm(wasmUrl: string): Promise<void>;
+    /**
+     * Shake 256 Using WASM
+     * @param input {Uint8Array} Input buffer
+     * @param outputLen {number} Output length
+     * @returns {Uint8Array} Output buffer
+     */
+    static shake256Wasm(input: Uint8Array, outputLen: number): Uint8Array;
+}
+/**
+ * Returns is wasm shake or not
+ */
+export declare function isWasmShake(): boolean;
+/**
+ * Keccak State
+ */
+export declare class KeccakState {
+    private readonly stateLow;
+    private readonly stateHigh;
+    /**
+     * Create Keccak State
+     */
+    constructor();
+    /**
+     * XOR of byte to state
+     * @param byte
+     * @param index
+     */
+    absorbByte(byte: number, index: number): void;
+    /**
+     * Extract byte from state
+     * @param index {number}
+     */
+    extractByte(index: number): number;
+    /**
+     * Permute Keccak-f[1600]
+     */
+    permute(): void;
+}
+/**
+ * Shake-256 Hash
+ */
+export declare class Shake256 {
+    /**
+     * Shake-256 async
+     * @param input {Uint8Array} Input buffer
+     * @param outputLength {number} Output buffer length
+     * @returns {Uint8Array} Output buffer
+     */
+    static hash(input: Uint8Array, outputLength: number): Promise<Uint8Array>;
+    /**
+     * Shake-256 sync
+     * @param input {Uint8Array} Input buffer
+     * @param outputLength {number} Output buffer length
+     * @returns {Uint8Array} Output buffer
+     */
+    static hashSync(input: Uint8Array, outputLength: number): Uint8Array;
+    /**
+     * Process SHAKE-256
+     * @param input {Uint8Array} Input buffer
+     * @param outputLength {number} Output length
+     * @returns {Uint8Array} Output buffer
+     * @private
+     */
+    private static process;
+}

package/dist/types/index.d.ts

@@ -2,17 +2,22 @@
  * QuarkDash Crypto Library
  *
  * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
+ * @version         1.1.0
  * @author          Elijah Rastorguev
- * @build           1000
+ * @build           1003
  * @website         https://dev.to/devsdaddy
+ * @updated         14.04.2026
  */
-export * from "./types";
-export * from "./utils";
-export * from "./shake";
-export * from "./sha";
-export * from "./kdf";
-export * from "./mac";
-export * from "./cipher";
-export * from "./ringlwe";
+export * from "./core/types";
+export * from "./core/utils";
+export * from "./core/wasm_loader";
+export * from "./core/kdf";
+export * from "./core/mac";
+export * from "./hash/shake";
+export * from "./hash/sha";
+export * from "./cipher/cipher";
+export * from "./cipher/chacha";
+export * from "./cipher/gimli";
+export * from "./session/ringlwe";
+export * from "./session/rringlwe";
 export * from "./crypto";

package/dist/types/{ringlwe.d.ts → session/baselwe.d.ts}

@@ -1,90 +1,12 @@
+import { ICryptoEncapsulated, ICryptoKeyPair } from "../core/types";
 /**
- * QuarkDash Ring-LWE Implementation
- *
- * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
- * @author          Elijah Rastorguev
- * @build           1000
- * @website         https://dev.to/devsdaddy
+ * Base Ring-LWE Function
  */
-import { ICryptoEncapsulated, ICryptoKeyPair, IKeyExchange } from "./types";
-/**
- * Ring-LWE based key exchange implementation
- */
-export declare class QuarkDashKeyExchange implements IKeyExchange {
-    private static readonly N;
-    private static readonly Q;
-    private static readonly ROOT;
-    private static readonly INV_N;
-    /**
-     * Get small polygon
-     * @returns {bigint[]} Small polygon
-     * @private
-     */
-    private static smallPoly;
-    /**
-     * Uniform polygon
-     * @returns {bigint[]}
-     * @private
-     */
-    private static uniformPoly;
-    /**
-     * NTT Operation
-     * @param poly {bigint[]} Polygon
-     * @private
-     */
-    private static ntt;
-    /**
-     * Inverse NTT
-     * @param poly {bigint[]} Polygon
-     * @private
-     */
-    private static invNTT;
-    /**
-     * Multiply
-     * @param a {bigint[]} Polygon
-     * @param b {bigint[]} Polygon
-     * @returns {bigint[]} Multiplied polygons
-     */
-    static multiply(a: bigint[], b: bigint[]): bigint[];
-    /**
-     * Serialize polygon
-     * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} Polygon buffer
-     * @private
-     */
-    private static serializePoly;
-    /**
-     * Deserialize Polygon
-     * @param bytes {Uint8Array} Polygon buffer
-     * @returns {bigint[]} Polygon
-     * @private
-     */
-    private static deserializePoly;
-    /**
-     * Round to bits
-     * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} rounded buffer
-     * @private
-     */
-    private static roundToBits;
-    /**
-     * Modular exponentiation
-     * @param base {bigint} Base
-     * @param exp {bigint} exponential
-     * @param mod {bigint} module
-     * @returns {bigint} Result of modular exponentiation
-     * @private
-     */
-    private static powMod;
-    /**
-     * Modular inverse
-     * @param a {bigint}
-     * @param m {bigint}
-     * @returns {bigint} Inversion result
-     * @private
-     */
-    private static modInverse;
+export declare class BaseRingLWE {
+    protected readonly N = 256;
+    protected readonly Q: any;
+    protected readonly ROOT = 7n;
+    protected readonly INV_N: bigint;
     /**
      * Generate crypto key pair async
      * @returns {ICryptoKeyPair} Crypto key pair
@@ -127,12 +49,86 @@ export declare class QuarkDashKeyExchange implements IKeyExchange {
      */
     decapsulateSync(privateKey: Uint8Array, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
     /**
-     * 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
+     * Modular inverse
+     * @param a {bigint}
+     * @param m {bigint}
+     * @returns {bigint} Inversion result
+     * @private
+     */
+    protected modInverse(a: bigint, m: bigint): bigint;
+    /**
+     * Modular exponentiation
+     * @param base {bigint} Base
+     * @param exp {bigint} exponential
+     * @param mod {bigint} module
+     * @returns {bigint} Result of modular exponentiation
+     * @private
+     */
+    protected powMod(base: bigint, exp: bigint, mod: bigint): bigint;
+    /**
+     * Round to bits
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} rounded buffer
+     * @private
+     */
+    protected roundToBits(poly: bigint[]): Uint8Array;
+    /**
+     * Deserialize Polygon
+     * @param bytes {Uint8Array} Polygon buffer
+     * @returns {bigint[]} Polygon
+     * @private
+     */
+    protected deserializePoly(bytes: Uint8Array): bigint[];
+    /**
+     * Serialize polygon
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} Polygon buffer
      * @private
      */
-    private hashSharedSecret;
+    protected serializePoly(poly: bigint[]): Uint8Array;
+    /**
+     * Multiply
+     * @param a {bigint[]} Polygon
+     * @param b {bigint[]} Polygon
+     * @returns {bigint[]} Multiplied polygons
+     */
+    protected multiply(a: bigint[], b: bigint[]): bigint[];
+    /**
+     * Inverse NTT
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    protected invNTT(poly: bigint[]): bigint[];
+    /**
+     * NTT Operation
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    protected ntt(poly: bigint[]): bigint[];
+    /**
+     * Error polygon
+     * @private
+     */
+    protected errorPoly(): bigint[];
+    /**
+     * Uniform polygon
+     * @returns {bigint[]}
+     * @private
+     */
+    protected uniformPoly(): bigint[];
+    /**
+     * Get small polygon
+     * @returns {bigint[]} Small polygon
+     * @private
+     */
+    protected smallPoly(): bigint[];
+    /**
+     * Hash shared secret
+     * @param ss {Uint8Array} Shared Secret
+     * @param publicKey {Uint8Array} Public Key
+     * @param ciphertext {Uint8Array} Cipher text
+     * @returns {Uint8Array} Hash buffer
+     * @protected
+     */
+    protected hashSharedSecretSync(ss: Uint8Array, publicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
 }

package/dist/types/session/ringlwe.d.ts

@@ -0,0 +1,21 @@
+/**
+ * QuarkDash Ring-LWE Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.1.0
+ * @author          Elijah Rastorguev
+ * @build           1003
+ * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
+ */
+import { IKeyExchange } from "../core/types";
+import { BaseRingLWE } from "./baselwe";
+/**
+ * Ring-LWE based key exchange implementation
+ */
+export declare class QuarkDashRLWE extends BaseRingLWE implements IKeyExchange {
+    protected readonly N = 256;
+    protected readonly Q = 7681n;
+    protected readonly ROOT = 7n;
+    protected readonly INV_N: bigint;
+}

package/dist/types/session/rringlwe.d.ts

@@ -0,0 +1,27 @@
+/**
+ * QuarkDash Radical Ring-LWE Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.1.0
+ * @author          Elijah Rastorguev
+ * @build           1002
+ * @website         https://dev.to/devsdaddy
+ * @updated         13.04.2026
+ */
+import { IKeyExchange } from "../core/types";
+import { BaseRingLWE } from "./baselwe";
+/**
+ * QuarkDash Radical Ring-LWE Implementation
+ */
+export declare class QuarkDashRRLWE extends BaseRingLWE implements IKeyExchange {
+    protected readonly N = 256;
+    protected readonly Q = 12289n;
+    protected readonly ROOT = 7n;
+    protected readonly INV_N: bigint;
+    /**
+     * Override small polynome for Radical Ring-lWE
+     * @returns {bigint[]} Small polynome
+     * @protected
+     */
+    protected smallPoly(): bigint[];
+}