@quilibrium/quilibrium-js-verenc-sdk 2.1.0-0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Quilibrium Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+declare function VerencNewProof(data: ArrayBuffer): {
+    proof: Buffer;
+    encryptionKey: Buffer;
+};
+declare function VerencNewProofEncryptOnly(data: ArrayBuffer, encryptionKey: ArrayBuffer): Buffer;
+declare function VerencVerify(proof: ArrayBuffer): {
+    data: Buffer;
+    blindingPubkey: Buffer;
+};
+declare function VerencCompress(proof: ArrayBuffer): {
+    proof: Buffer;
+    recovery: Buffer;
+};
+declare function VerencRecover(recovery: ArrayBuffer): Buffer;
+declare function VerencChunkDataForVerenc(data: ArrayBuffer): Buffer[];
+declare function VerencCombineChunkedData(chunks: ArrayBuffer[]): Buffer;
+declare function VerencVerifyStatement(input: ArrayBuffer, blindingPubkey: ArrayBuffer, statement: ArrayBuffer): boolean;
+
+declare const verenc_VerencChunkDataForVerenc: typeof VerencChunkDataForVerenc;
+declare const verenc_VerencCombineChunkedData: typeof VerencCombineChunkedData;
+declare const verenc_VerencCompress: typeof VerencCompress;
+declare const verenc_VerencNewProof: typeof VerencNewProof;
+declare const verenc_VerencNewProofEncryptOnly: typeof VerencNewProofEncryptOnly;
+declare const verenc_VerencRecover: typeof VerencRecover;
+declare const verenc_VerencVerify: typeof VerencVerify;
+declare const verenc_VerencVerifyStatement: typeof VerencVerifyStatement;
+declare namespace verenc {
+  export {
+    verenc_VerencChunkDataForVerenc as VerencChunkDataForVerenc,
+    verenc_VerencCombineChunkedData as VerencCombineChunkedData,
+    verenc_VerencCompress as VerencCompress,
+    verenc_VerencNewProof as VerencNewProof,
+    verenc_VerencNewProofEncryptOnly as VerencNewProofEncryptOnly,
+    verenc_VerencRecover as VerencRecover,
+    verenc_VerencVerify as VerencVerify,
+    verenc_VerencVerifyStatement as VerencVerifyStatement,
+  };
+}
+
+export { verenc };

package/dist/index.esm.js

@@ -0,0 +1,383 @@
+import { Buffer as Buffer$1 } from 'buffer';
+
+let wasm;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+heap.length;
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+/**
+* @param {string} data
+* @returns {string}
+*/
+function js_new_verenc_proof(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_new_verenc_proof(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} data
+* @param {string} encryption_key
+* @returns {string}
+*/
+function js_new_verenc_proof_encrypt_only(data, encryption_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(encryption_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.js_new_verenc_proof_encrypt_only(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+* @param {string} proof
+* @returns {string}
+*/
+function js_verenc_verify(proof) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_verify(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} proof
+* @returns {string}
+*/
+function js_verenc_compress(proof) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_compress(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} recovery
+* @returns {string}
+*/
+function js_verenc_recover(recovery) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(recovery, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_recover(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} data
+* @returns {string}
+*/
+function js_chunk_data_for_verenc(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_chunk_data_for_verenc(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} chunks
+* @returns {string}
+*/
+function js_combine_chunked_data(chunks) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(chunks, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_combine_chunked_data(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} input
+* @param {string} blinding_pubkey
+* @param {string} statement
+* @returns {string}
+*/
+function js_verenc_verify_statement(input, blinding_pubkey, statement) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(blinding_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(statement, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_verenc_verify_statement(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred4_0 = r0;
+        deferred4_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+class VerencError extends Error {
+}
+function VerencNewProof(data) {
+    const result = JSON.parse(js_new_verenc_proof(Buffer.from(data).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.proof && result.encryption_key) {
+            return {
+                proof: Buffer.from(result.proof, 'hex'),
+                encryptionKey: Buffer.from(result.encryption_key, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencNewProofEncryptOnly(data, encryptionKey) {
+    const result = JSON.parse(js_new_verenc_proof_encrypt_only(Buffer.from(data).toString('hex'), Buffer.from(encryptionKey).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencVerify(proof) {
+    const result = JSON.parse(js_verenc_verify(Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.data && result.blinding_pubkey) {
+            return {
+                data: Buffer.from(result.data, 'hex'),
+                blindingPubkey: Buffer.from(result.blinding_pubkey, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencCompress(proof) {
+    const result = JSON.parse(js_verenc_compress(Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.proof && result.recovery) {
+            return {
+                proof: Buffer.from(result.proof, 'hex'),
+                recovery: Buffer.from(result.recovery, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencRecover(recovery) {
+    const result = JSON.parse(js_verenc_recover(Buffer.from(recovery).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencChunkDataForVerenc(data) {
+    const result = JSON.parse(js_chunk_data_for_verenc(Buffer.from(data).toString('hex')));
+    if (Array.isArray(result)) {
+        return result.map(chunk => Buffer.from(chunk, 'hex'));
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencCombineChunkedData(chunks) {
+    const result = JSON.parse(js_combine_chunked_data(JSON.stringify(chunks.map(c => Buffer.from(c).toString('hex')))));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencVerifyStatement(input, blindingPubkey, statement) {
+    const result = JSON.parse(js_verenc_verify_statement(Buffer.from(input).toString('hex'), Buffer.from(blindingPubkey).toString('hex'), Buffer.from(statement).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+
+var verenc = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    VerencChunkDataForVerenc: VerencChunkDataForVerenc,
+    VerencCombineChunkedData: VerencCombineChunkedData,
+    VerencCompress: VerencCompress,
+    VerencNewProof: VerencNewProof,
+    VerencNewProofEncryptOnly: VerencNewProofEncryptOnly,
+    VerencRecover: VerencRecover,
+    VerencVerify: VerencVerify,
+    VerencVerifyStatement: VerencVerifyStatement
+});
+
+window.Buffer = Buffer$1;
+
+export { verenc };

package/dist/index.js

@@ -0,0 +1,385 @@
+'use strict';
+
+var buffer = require('buffer');
+
+let wasm;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+heap.length;
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+/**
+* @param {string} data
+* @returns {string}
+*/
+function js_new_verenc_proof(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_new_verenc_proof(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} data
+* @param {string} encryption_key
+* @returns {string}
+*/
+function js_new_verenc_proof_encrypt_only(data, encryption_key) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(encryption_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.js_new_verenc_proof_encrypt_only(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred3_0 = r0;
+        deferred3_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+* @param {string} proof
+* @returns {string}
+*/
+function js_verenc_verify(proof) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_verify(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} proof
+* @returns {string}
+*/
+function js_verenc_compress(proof) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_compress(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} recovery
+* @returns {string}
+*/
+function js_verenc_recover(recovery) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(recovery, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_verenc_recover(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} data
+* @returns {string}
+*/
+function js_chunk_data_for_verenc(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_chunk_data_for_verenc(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} chunks
+* @returns {string}
+*/
+function js_combine_chunked_data(chunks) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(chunks, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.js_combine_chunked_data(retptr, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred2_0 = r0;
+        deferred2_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+* @param {string} input
+* @param {string} blinding_pubkey
+* @param {string} statement
+* @returns {string}
+*/
+function js_verenc_verify_statement(input, blinding_pubkey, statement) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(blinding_pubkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(statement, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_verenc_verify_statement(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred4_0 = r0;
+        deferred4_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+class VerencError extends Error {
+}
+function VerencNewProof(data) {
+    const result = JSON.parse(js_new_verenc_proof(Buffer.from(data).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.proof && result.encryption_key) {
+            return {
+                proof: Buffer.from(result.proof, 'hex'),
+                encryptionKey: Buffer.from(result.encryption_key, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencNewProofEncryptOnly(data, encryptionKey) {
+    const result = JSON.parse(js_new_verenc_proof_encrypt_only(Buffer.from(data).toString('hex'), Buffer.from(encryptionKey).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencVerify(proof) {
+    const result = JSON.parse(js_verenc_verify(Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.data && result.blinding_pubkey) {
+            return {
+                data: Buffer.from(result.data, 'hex'),
+                blindingPubkey: Buffer.from(result.blinding_pubkey, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencCompress(proof) {
+    const result = JSON.parse(js_verenc_compress(Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'object') {
+        if (result.proof && result.recovery) {
+            return {
+                proof: Buffer.from(result.proof, 'hex'),
+                recovery: Buffer.from(result.recovery, 'hex'),
+            };
+        }
+    }
+    throw new VerencError(result.error || "unknown response");
+}
+function VerencRecover(recovery) {
+    const result = JSON.parse(js_verenc_recover(Buffer.from(recovery).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencChunkDataForVerenc(data) {
+    const result = JSON.parse(js_chunk_data_for_verenc(Buffer.from(data).toString('hex')));
+    if (Array.isArray(result)) {
+        return result.map(chunk => Buffer.from(chunk, 'hex'));
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencCombineChunkedData(chunks) {
+    const result = JSON.parse(js_combine_chunked_data(JSON.stringify(chunks.map(c => Buffer.from(c).toString('hex')))));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+function VerencVerifyStatement(input, blindingPubkey, statement) {
+    const result = JSON.parse(js_verenc_verify_statement(Buffer.from(input).toString('hex'), Buffer.from(blindingPubkey).toString('hex'), Buffer.from(statement).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new VerencError(result.error);
+    }
+}
+
+var verenc = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    VerencChunkDataForVerenc: VerencChunkDataForVerenc,
+    VerencCombineChunkedData: VerencCombineChunkedData,
+    VerencCompress: VerencCompress,
+    VerencNewProof: VerencNewProof,
+    VerencNewProofEncryptOnly: VerencNewProofEncryptOnly,
+    VerencRecover: VerencRecover,
+    VerencVerify: VerencVerify,
+    VerencVerifyStatement: VerencVerifyStatement
+});
+
+window.Buffer = buffer.Buffer;
+
+exports.verenc = verenc;

package/dist/verenc/verenc.d.ts

@@ -0,0 +1,17 @@
+export declare function VerencNewProof(data: ArrayBuffer): {
+    proof: Buffer;
+    encryptionKey: Buffer;
+};
+export declare function VerencNewProofEncryptOnly(data: ArrayBuffer, encryptionKey: ArrayBuffer): Buffer;
+export declare function VerencVerify(proof: ArrayBuffer): {
+    data: Buffer;
+    blindingPubkey: Buffer;
+};
+export declare function VerencCompress(proof: ArrayBuffer): {
+    proof: Buffer;
+    recovery: Buffer;
+};
+export declare function VerencRecover(recovery: ArrayBuffer): Buffer;
+export declare function VerencChunkDataForVerenc(data: ArrayBuffer): Buffer[];
+export declare function VerencCombineChunkedData(chunks: ArrayBuffer[]): Buffer;
+export declare function VerencVerifyStatement(input: ArrayBuffer, blindingPubkey: ArrayBuffer, statement: ArrayBuffer): boolean;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@quilibrium/quilibrium-js-verenc-sdk",
+  "version": "2.1.0-0",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "clean": "rimraf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "base58-js": "^2.0.0",
+    "buffer": "^6.0.3",
+    "multiformats": "^13.3.1",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-dropzone": "^14.3.5"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@rollup/plugin-wasm": "^6.2.2",
+    "@types/react": "^19.0.7",
+    "@types/react-dom": "^19.0.3",
+    "rollup": "^4.30.1",
+    "rollup-plugin-dts": "^6.1.1",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5.7.3"
+  }
+}