quarkdash 1.0.8 → 1.1.0

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,22 +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           1002
- * @website         https://dev.to/devsdaddy
- * @updated         12.04.2026
+ * 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;
+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
@@ -59,86 +49,86 @@ export declare class QuarkDashKeyExchange implements IKeyExchange {
      */
     decapsulateSync(privateKey: Uint8Array, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
     /**
-     * Get small polygon
-     * @returns {bigint[]} Small polygon
+     * Modular inverse
+     * @param a {bigint}
+     * @param m {bigint}
+     * @returns {bigint} Inversion result
      * @private
      */
-    private static smallPoly;
+    protected modInverse(a: bigint, m: bigint): bigint;
     /**
-     * Uniform polygon
-     * @returns {bigint[]}
+     * Modular exponentiation
+     * @param base {bigint} Base
+     * @param exp {bigint} exponential
+     * @param mod {bigint} module
+     * @returns {bigint} Result of modular exponentiation
      * @private
      */
-    private static uniformPoly;
+    protected powMod(base: bigint, exp: bigint, mod: bigint): bigint;
     /**
-     * Error polygon
+     * Round to bits
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} rounded buffer
      * @private
      */
-    private static errorPoly;
+    protected roundToBits(poly: bigint[]): Uint8Array;
     /**
-     * NTT Operation
-     * @param poly {bigint[]} Polygon
+     * Deserialize Polygon
+     * @param bytes {Uint8Array} Polygon buffer
+     * @returns {bigint[]} Polygon
      * @private
      */
-    private static ntt;
+    protected deserializePoly(bytes: Uint8Array): bigint[];
     /**
-     * Inverse NTT
+     * Serialize polygon
      * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} Polygon buffer
      * @private
      */
-    private static invNTT;
+    protected serializePoly(poly: bigint[]): Uint8Array;
     /**
      * Multiply
      * @param a {bigint[]} Polygon
      * @param b {bigint[]} Polygon
      * @returns {bigint[]} Multiplied polygons
      */
-    static multiply(a: bigint[], b: bigint[]): bigint[];
+    protected multiply(a: bigint[], b: bigint[]): bigint[];
     /**
-     * Serialize polygon
+     * Inverse NTT
      * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} Polygon buffer
      * @private
      */
-    private static serializePoly;
+    protected invNTT(poly: bigint[]): bigint[];
     /**
-     * Deserialize Polygon
-     * @param bytes {Uint8Array} Polygon buffer
-     * @returns {bigint[]} Polygon
+     * NTT Operation
+     * @param poly {bigint[]} Polygon
      * @private
      */
-    private static deserializePoly;
+    protected ntt(poly: bigint[]): bigint[];
     /**
-     * Round to bits
-     * @param poly {bigint[]} Polygon
-     * @returns {Uint8Array} rounded buffer
+     * Error polygon
      * @private
      */
-    private static roundToBits;
+    protected errorPoly(): bigint[];
     /**
-     * Modular exponentiation
-     * @param base {bigint} Base
-     * @param exp {bigint} exponential
-     * @param mod {bigint} module
-     * @returns {bigint} Result of modular exponentiation
+     * Uniform polygon
+     * @returns {bigint[]}
      * @private
      */
-    private static powMod;
+    protected uniformPoly(): bigint[];
     /**
-     * Modular inverse
-     * @param a {bigint}
-     * @param m {bigint}
-     * @returns {bigint} Inversion result
+     * Get small polygon
+     * @returns {bigint[]} Small polygon
      * @private
      */
-    private static modInverse;
+    protected smallPoly(): bigint[];
     /**
      * 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
+     * @param ss {Uint8Array} Shared Secret
+     * @param publicKey {Uint8Array} Public Key
+     * @param ciphertext {Uint8Array} Cipher text
+     * @returns {Uint8Array} Hash buffer
+     * @protected
      */
-    private static hashSharedSecret;
+    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[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quarkdash",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "QuarkDash - pure typescript hybrid cryptographic protocol that provides post-quantum security, high performance, and attack resistance.",
   "keywords": [
     "quark",
@@ -39,26 +39,34 @@
   "scripts": {
     "update-docs": "ts-node docutil.ts",
     "clean": "rm -rf dist",
-    "build": "npm run clean && npm run update-docs && npm run build:esm && npm run build:cjs && npm run build:types",
+    "build": "npm run clean && npm run update-docs && npm run build:esm && npm run build:cjs && npm run build:types && npm run copy_wasm",
     "build:esm": "tsc -p tsconfig.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --declaration --outDir dist/types",
+    "copy_wasm": "cp -r \"wasm/shake.wasm\" \"dist/\"",
     "test": "jest --coverage",
     "test:watch": "jest --watch",
     "bench": "ts-node --compiler-options '{\"module\":\"CommonJS\"}' benchmarks/bench.ts",
     "prepublishOnly": "npm run build && npm test"
   },
+  "files": [
+    "wasm", "dist"
+  ],
   "devDependencies": {
     "@types/jest": "^29.5.0",
     "@types/node": "^20.0.0",
-    "ts-morph": "^27.0.2",
+    "copyfiles": "^2.4.1",
     "jest": "^29.5.0",
     "ts-jest": "^29.1.0",
+    "ts-morph": "^27.0.2",
     "ts-node": "^10.9.0",
     "typescript": "^5.0.0",
     "ws": "^8.14.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "fs": "^0.0.1-security",
+    "path": "^0.12.7"
+  },
   "engines": {
     "node": ">=16.0.0"
   }