@quilibrium/quilibrium-js-bls48581-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/bls48581/bls48581.d.ts

@@ -0,0 +1,19 @@
+export declare function BLS48581CommitRaw(data: ArrayBuffer, poly_size: number): Buffer;
+export declare function BLS48581ProveRaw(data: ArrayBuffer, index: number, poly_size: number): Buffer;
+export declare function BLS48581VerifyRaw(data: ArrayBuffer, commit: ArrayBuffer, index: number, proof: ArrayBuffer, poly_size: number): Buffer;
+export declare function BLS48581Keygen(): {
+    secretKey: Buffer;
+    publicKey: Buffer;
+    proofOfPossessionSig: Buffer;
+};
+export declare function BLS48581Sign(secretKey: ArrayBuffer, msg: ArrayBuffer, domain: ArrayBuffer): Buffer;
+export declare function BLS48581Verify(publicKey: ArrayBuffer, signature: ArrayBuffer, msg: ArrayBuffer, domain: ArrayBuffer): boolean;
+export declare function BLS48581Aggregate(publicKeys: ArrayBuffer[], signatures: ArrayBuffer[]): {
+    aggregatePublicKey: Buffer;
+    aggregateSignature: Buffer;
+};
+export declare function BLS48581ProveMultiple(commitments: ArrayBuffer[], polys: ArrayBuffer[], indices: number[], poly_size: number): {
+    d: Buffer;
+    proof: Buffer;
+};
+export declare function BLS48581VerifyMultiple(commitments: ArrayBuffer[], evaluations: ArrayBuffer[], indices: number[], poly_size: number, d: ArrayBuffer, proof: ArrayBuffer): boolean;

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+declare function BLS48581CommitRaw(data: ArrayBuffer, poly_size: number): Buffer;
+declare function BLS48581ProveRaw(data: ArrayBuffer, index: number, poly_size: number): Buffer;
+declare function BLS48581VerifyRaw(data: ArrayBuffer, commit: ArrayBuffer, index: number, proof: ArrayBuffer, poly_size: number): Buffer;
+declare function BLS48581Keygen(): {
+    secretKey: Buffer;
+    publicKey: Buffer;
+    proofOfPossessionSig: Buffer;
+};
+declare function BLS48581Sign(secretKey: ArrayBuffer, msg: ArrayBuffer, domain: ArrayBuffer): Buffer;
+declare function BLS48581Verify(publicKey: ArrayBuffer, signature: ArrayBuffer, msg: ArrayBuffer, domain: ArrayBuffer): boolean;
+declare function BLS48581Aggregate(publicKeys: ArrayBuffer[], signatures: ArrayBuffer[]): {
+    aggregatePublicKey: Buffer;
+    aggregateSignature: Buffer;
+};
+declare function BLS48581ProveMultiple(commitments: ArrayBuffer[], polys: ArrayBuffer[], indices: number[], poly_size: number): {
+    d: Buffer;
+    proof: Buffer;
+};
+declare function BLS48581VerifyMultiple(commitments: ArrayBuffer[], evaluations: ArrayBuffer[], indices: number[], poly_size: number, d: ArrayBuffer, proof: ArrayBuffer): boolean;
+
+declare const bls48581_BLS48581Aggregate: typeof BLS48581Aggregate;
+declare const bls48581_BLS48581CommitRaw: typeof BLS48581CommitRaw;
+declare const bls48581_BLS48581Keygen: typeof BLS48581Keygen;
+declare const bls48581_BLS48581ProveMultiple: typeof BLS48581ProveMultiple;
+declare const bls48581_BLS48581ProveRaw: typeof BLS48581ProveRaw;
+declare const bls48581_BLS48581Sign: typeof BLS48581Sign;
+declare const bls48581_BLS48581Verify: typeof BLS48581Verify;
+declare const bls48581_BLS48581VerifyMultiple: typeof BLS48581VerifyMultiple;
+declare const bls48581_BLS48581VerifyRaw: typeof BLS48581VerifyRaw;
+declare namespace bls48581 {
+  export {
+    bls48581_BLS48581Aggregate as BLS48581Aggregate,
+    bls48581_BLS48581CommitRaw as BLS48581CommitRaw,
+    bls48581_BLS48581Keygen as BLS48581Keygen,
+    bls48581_BLS48581ProveMultiple as BLS48581ProveMultiple,
+    bls48581_BLS48581ProveRaw as BLS48581ProveRaw,
+    bls48581_BLS48581Sign as BLS48581Sign,
+    bls48581_BLS48581Verify as BLS48581Verify,
+    bls48581_BLS48581VerifyMultiple as BLS48581VerifyMultiple,
+    bls48581_BLS48581VerifyRaw as BLS48581VerifyRaw,
+  };
+}
+
+export { bls48581 as verenc };

package/dist/index.esm.js

@@ -0,0 +1,454 @@
+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
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_commit_raw(data, poly_size) {
+    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_commit_raw(retptr, ptr0, len0, poly_size);
+        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 {bigint} index
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_prove_raw(data, index, poly_size) {
+    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_prove_raw(retptr, ptr0, len0, index, poly_size);
+        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} commit
+* @param {bigint} index
+* @param {string} proof
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_verify_raw(data, commit, index, proof, poly_size) {
+    let deferred4_0;
+    let deferred4_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(commit, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_verify_raw(retptr, ptr0, len0, ptr1, len1, index, ptr2, len2, poly_size);
+        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);
+    }
+}
+
+/**
+* @returns {string}
+*/
+function js_bls_keygen() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.js_bls_keygen(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+* @param {string} sk
+* @param {string} msg
+* @param {string} domain
+* @returns {string}
+*/
+function js_bls_sign(sk, msg, domain) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(sk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_bls_sign(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);
+    }
+}
+
+/**
+* @param {string} pk
+* @param {string} sig
+* @param {string} msg
+* @param {string} domain
+* @returns {string}
+*/
+function js_bls_verify(pk, sig, msg, domain) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sig, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.js_bls_verify(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred5_0 = r0;
+        deferred5_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+* @param {string} pks
+* @param {string} sigs
+* @returns {string}
+*/
+function js_bls_aggregate(pks, sigs) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pks, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sigs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.js_bls_aggregate(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} commitments
+* @param {string} polys
+* @param {string} indices
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_prove_multiple(commitments, polys, indices, poly_size) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commitments, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(polys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(indices, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_prove_multiple(retptr, ptr0, len0, ptr1, len1, ptr2, len2, poly_size);
+        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);
+    }
+}
+
+/**
+* @param {string} commits
+* @param {string} y_bytes
+* @param {string} indices
+* @param {bigint} poly_size
+* @param {string} c_q_bytes
+* @param {string} proof_bytes
+* @returns {string}
+*/
+function js_verify_multiple(commits, y_bytes, indices, poly_size, c_q_bytes, proof_bytes) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commits, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(y_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(indices, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(c_q_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(proof_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.js_verify_multiple(retptr, ptr0, len0, ptr1, len1, ptr2, len2, poly_size, ptr3, len3, ptr4, len4);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred6_0 = r0;
+        deferred6_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+
+class BLS48581Error extends Error {
+}
+function BLS48581CommitRaw(data, poly_size) {
+    const result = JSON.parse(js_commit_raw(Buffer.from(data).toString('hex'), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581ProveRaw(data, index, poly_size) {
+    const result = JSON.parse(js_prove_raw(Buffer.from(data).toString('hex'), BigInt(index), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581VerifyRaw(data, commit, index, proof, poly_size) {
+    const result = JSON.parse(js_verify_raw(Buffer.from(data).toString('hex'), Buffer.from(commit).toString('hex'), BigInt(index), Buffer.from(proof).toString('hex'), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Keygen() {
+    const result = JSON.parse(js_bls_keygen());
+    if (typeof (result) == 'object') {
+        if (result.secret_key && result.public_key && result.proof_of_possession_sig) {
+            return {
+                secretKey: Buffer.from(result.secret_key, 'hex'),
+                publicKey: Buffer.from(result.public_key, 'hex'),
+                proofOfPossessionSig: Buffer.from(result.proof_of_possession_sig, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581Sign(secretKey, msg, domain) {
+    const result = JSON.parse(js_bls_sign(Buffer.from(secretKey).toString('hex'), Buffer.from(msg).toString('hex'), Buffer.from(domain).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Verify(publicKey, signature, msg, domain) {
+    const result = JSON.parse(js_bls_verify(Buffer.from(publicKey).toString('hex'), Buffer.from(signature).toString('hex'), Buffer.from(msg).toString('hex'), Buffer.from(domain).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Aggregate(publicKeys, signatures) {
+    const result = JSON.parse(js_bls_aggregate(JSON.stringify(publicKeys.map(p => Buffer.from(p).toString('hex'))), JSON.stringify(signatures.map(s => Buffer.from(s).toString('hex')))));
+    if (typeof (result) == 'object') {
+        if (result.aggregate_public_key && result.aggregate_signature) {
+            return {
+                aggregatePublicKey: Buffer.from(result.aggregate_public_key, 'hex'),
+                aggregateSignature: Buffer.from(result.aggregate_signature, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581ProveMultiple(commitments, polys, indices, poly_size) {
+    const result = JSON.parse(js_prove_multiple(JSON.stringify(commitments.map(c => Buffer.from(c).toString('hex'))), JSON.stringify(polys.map(p => Buffer.from(p).toString('hex'))), JSON.stringify(indices), BigInt(poly_size)));
+    if (typeof (result) == 'object') {
+        if (result.d && result.proof) {
+            return {
+                d: Buffer.from(result.d, 'hex'),
+                proof: Buffer.from(result.proof, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581VerifyMultiple(commitments, evaluations, indices, poly_size, d, proof) {
+    const result = JSON.parse(js_verify_multiple(JSON.stringify(commitments.map(c => Buffer.from(c).toString('hex'))), JSON.stringify(evaluations.map(e => Buffer.from(e).toString('hex'))), JSON.stringify(indices), BigInt(poly_size), Buffer.from(d).toString('hex'), Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+
+var bls48581 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BLS48581Aggregate: BLS48581Aggregate,
+    BLS48581CommitRaw: BLS48581CommitRaw,
+    BLS48581Keygen: BLS48581Keygen,
+    BLS48581ProveMultiple: BLS48581ProveMultiple,
+    BLS48581ProveRaw: BLS48581ProveRaw,
+    BLS48581Sign: BLS48581Sign,
+    BLS48581Verify: BLS48581Verify,
+    BLS48581VerifyMultiple: BLS48581VerifyMultiple,
+    BLS48581VerifyRaw: BLS48581VerifyRaw
+});
+
+window.Buffer = Buffer$1;
+
+export { bls48581 as verenc };

package/dist/index.js

@@ -0,0 +1,456 @@
+'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
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_commit_raw(data, poly_size) {
+    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_commit_raw(retptr, ptr0, len0, poly_size);
+        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 {bigint} index
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_prove_raw(data, index, poly_size) {
+    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_prove_raw(retptr, ptr0, len0, index, poly_size);
+        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} commit
+* @param {bigint} index
+* @param {string} proof
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_verify_raw(data, commit, index, proof, poly_size) {
+    let deferred4_0;
+    let deferred4_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(commit, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(proof, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_verify_raw(retptr, ptr0, len0, ptr1, len1, index, ptr2, len2, poly_size);
+        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);
+    }
+}
+
+/**
+* @returns {string}
+*/
+function js_bls_keygen() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.js_bls_keygen(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+* @param {string} sk
+* @param {string} msg
+* @param {string} domain
+* @returns {string}
+*/
+function js_bls_sign(sk, msg, domain) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(sk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_bls_sign(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);
+    }
+}
+
+/**
+* @param {string} pk
+* @param {string} sig
+* @param {string} msg
+* @param {string} domain
+* @returns {string}
+*/
+function js_bls_verify(pk, sig, msg, domain) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sig, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(msg, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(domain, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        wasm.js_bls_verify(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred5_0 = r0;
+        deferred5_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+
+/**
+* @param {string} pks
+* @param {string} sigs
+* @returns {string}
+*/
+function js_bls_aggregate(pks, sigs) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(pks, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(sigs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.js_bls_aggregate(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} commitments
+* @param {string} polys
+* @param {string} indices
+* @param {bigint} poly_size
+* @returns {string}
+*/
+function js_prove_multiple(commitments, polys, indices, poly_size) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commitments, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(polys, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(indices, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.js_prove_multiple(retptr, ptr0, len0, ptr1, len1, ptr2, len2, poly_size);
+        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);
+    }
+}
+
+/**
+* @param {string} commits
+* @param {string} y_bytes
+* @param {string} indices
+* @param {bigint} poly_size
+* @param {string} c_q_bytes
+* @param {string} proof_bytes
+* @returns {string}
+*/
+function js_verify_multiple(commits, y_bytes, indices, poly_size, c_q_bytes, proof_bytes) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(commits, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(y_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(indices, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(c_q_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(proof_bytes, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.js_verify_multiple(retptr, ptr0, len0, ptr1, len1, ptr2, len2, poly_size, ptr3, len3, ptr4, len4);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        deferred6_0 = r0;
+        deferred6_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+
+class BLS48581Error extends Error {
+}
+function BLS48581CommitRaw(data, poly_size) {
+    const result = JSON.parse(js_commit_raw(Buffer.from(data).toString('hex'), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581ProveRaw(data, index, poly_size) {
+    const result = JSON.parse(js_prove_raw(Buffer.from(data).toString('hex'), BigInt(index), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581VerifyRaw(data, commit, index, proof, poly_size) {
+    const result = JSON.parse(js_verify_raw(Buffer.from(data).toString('hex'), Buffer.from(commit).toString('hex'), BigInt(index), Buffer.from(proof).toString('hex'), BigInt(poly_size)));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Keygen() {
+    const result = JSON.parse(js_bls_keygen());
+    if (typeof (result) == 'object') {
+        if (result.secret_key && result.public_key && result.proof_of_possession_sig) {
+            return {
+                secretKey: Buffer.from(result.secret_key, 'hex'),
+                publicKey: Buffer.from(result.public_key, 'hex'),
+                proofOfPossessionSig: Buffer.from(result.proof_of_possession_sig, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581Sign(secretKey, msg, domain) {
+    const result = JSON.parse(js_bls_sign(Buffer.from(secretKey).toString('hex'), Buffer.from(msg).toString('hex'), Buffer.from(domain).toString('hex')));
+    if (typeof (result) == 'string') {
+        return Buffer.from(result, 'hex');
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Verify(publicKey, signature, msg, domain) {
+    const result = JSON.parse(js_bls_verify(Buffer.from(publicKey).toString('hex'), Buffer.from(signature).toString('hex'), Buffer.from(msg).toString('hex'), Buffer.from(domain).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+function BLS48581Aggregate(publicKeys, signatures) {
+    const result = JSON.parse(js_bls_aggregate(JSON.stringify(publicKeys.map(p => Buffer.from(p).toString('hex'))), JSON.stringify(signatures.map(s => Buffer.from(s).toString('hex')))));
+    if (typeof (result) == 'object') {
+        if (result.aggregate_public_key && result.aggregate_signature) {
+            return {
+                aggregatePublicKey: Buffer.from(result.aggregate_public_key, 'hex'),
+                aggregateSignature: Buffer.from(result.aggregate_signature, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581ProveMultiple(commitments, polys, indices, poly_size) {
+    const result = JSON.parse(js_prove_multiple(JSON.stringify(commitments.map(c => Buffer.from(c).toString('hex'))), JSON.stringify(polys.map(p => Buffer.from(p).toString('hex'))), JSON.stringify(indices), BigInt(poly_size)));
+    if (typeof (result) == 'object') {
+        if (result.d && result.proof) {
+            return {
+                d: Buffer.from(result.d, 'hex'),
+                proof: Buffer.from(result.proof, 'hex'),
+            };
+        }
+    }
+    throw new BLS48581Error("unknown response");
+}
+function BLS48581VerifyMultiple(commitments, evaluations, indices, poly_size, d, proof) {
+    const result = JSON.parse(js_verify_multiple(JSON.stringify(commitments.map(c => Buffer.from(c).toString('hex'))), JSON.stringify(evaluations.map(e => Buffer.from(e).toString('hex'))), JSON.stringify(indices), BigInt(poly_size), Buffer.from(d).toString('hex'), Buffer.from(proof).toString('hex')));
+    if (typeof (result) == 'boolean') {
+        return result;
+    }
+    else {
+        throw new BLS48581Error(result.error);
+    }
+}
+
+var bls48581 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BLS48581Aggregate: BLS48581Aggregate,
+    BLS48581CommitRaw: BLS48581CommitRaw,
+    BLS48581Keygen: BLS48581Keygen,
+    BLS48581ProveMultiple: BLS48581ProveMultiple,
+    BLS48581ProveRaw: BLS48581ProveRaw,
+    BLS48581Sign: BLS48581Sign,
+    BLS48581Verify: BLS48581Verify,
+    BLS48581VerifyMultiple: BLS48581VerifyMultiple,
+    BLS48581VerifyRaw: BLS48581VerifyRaw
+});
+
+window.Buffer = buffer.Buffer;
+
+exports.verenc = bls48581;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@quilibrium/quilibrium-js-bls48581-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"
+  }
+}