@abhedyam/wasm 1.0.32

package/README.md

@@ -0,0 +1,25 @@
+# Abhedya WASM
+
+WebAssembly bindings for **Abhedya**: Post-Quantum Sanskrit Cryptography.
+
+## Usage
+
+```javascript
+import init, { AbhedyaWasm } from "./abhedya_wasm.js";
+
+async function run() {
+  await init();
+
+  const abhedya = new AbhedyaWasm();
+  abhedya.keygen();
+
+  const plain = new TextEncoder().encode("Hello World");
+  const encrypted = abhedya.encrypt(plain, false); // Standard Mode
+
+  console.log("Encrypted bytes:", encrypted);
+
+  const decrypted = abhedya.decrypt(encrypted);
+  console.log("Decrypted:", new TextDecoder().decode(decrypted));
+}
+run();
+```

package/abhedya_wasm.d.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class AbhedyaWasm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Decrypt a ciphertext
+     */
+    decrypt(ct: Uint8Array): Uint8Array;
+    /**
+     * Encrypt a message (string or bytes)
+     */
+    encrypt(msg: Uint8Array, is_metered: boolean): Uint8Array;
+    /**
+     * Generate a fresh KeyPair
+     */
+    keygen(): any;
+    constructor();
+}

package/abhedya_wasm.js

@@ -0,0 +1,160 @@
+/* @ts-self-types="./abhedya_wasm.d.ts" */
+
+class AbhedyaWasm {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AbhedyaWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_abhedyawasm_free(ptr, 0);
+    }
+    /**
+     * Decrypt a ciphertext
+     * @param {Uint8Array} ct
+     * @returns {Uint8Array}
+     */
+    decrypt(ct) {
+        const ptr0 = passArray8ToWasm0(ct, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.abhedyawasm_decrypt(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * Encrypt a message (string or bytes)
+     * @param {Uint8Array} msg
+     * @param {boolean} is_metered
+     * @returns {Uint8Array}
+     */
+    encrypt(msg, is_metered) {
+        const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.abhedyawasm_encrypt(this.__wbg_ptr, ptr0, len0, is_metered);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v2;
+    }
+    /**
+     * Generate a fresh KeyPair
+     * @returns {any}
+     */
+    keygen() {
+        const ret = wasm.abhedyawasm_keygen(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.abhedyawasm_new();
+        this.__wbg_ptr = ret >>> 0;
+        AbhedyaWasmFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) AbhedyaWasm.prototype[Symbol.dispose] = AbhedyaWasm.prototype.free;
+exports.AbhedyaWasm = AbhedyaWasm;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_getRandomValues_1c61fac11405ffdc: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./abhedya_wasm_bg.js": import0,
+    };
+}
+
+const AbhedyaWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_abhedyawasm_free(ptr >>> 0, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/abhedya_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@abhedyam/wasm",
+  "collaborators": [
+    "ParamTatva <bot@paramtatva.org>"
+  ],
+  "description": "WASM Bindings for Abhedya: Sanskrit-Encoded PQC",
+  "version": "1.0.32",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ParamTatva-org/abhedyam"
+  },
+  "files": [
+    "abhedya_wasm_bg.wasm",
+    "abhedya_wasm.js",
+    "abhedya_wasm.d.ts"
+  ],
+  "main": "abhedya_wasm.js",
+  "types": "abhedya_wasm.d.ts"
+}