@intuweb3/sdk
Version:
INTU SDK - Modern blockchain interaction toolkit
280 lines • 19.6 kB
JavaScript
import wasmBytecode from "./intu_crypto_bg.wasm";
let wasmModule = null;
async function initializeWasm() {
if (!wasmModule) {
try {
console.log("🔧 Initializing WASM module...");
wasmModule = await global.WebAssembly.instantiate(wasmBytecode);
console.log("✅ WASM module initialized successfully");
console.log("🔧 WASM exports:", Object.keys(wasmModule.instance?.exports || {}));
}
catch (error) {
console.error("❌ Failed to initialize WASM module:", error);
throw error;
}
}
return wasmModule;
}
async function getWasmFunction(functionName) {
const module = await initializeWasm();
const func = module.instance.exports[functionName];
if (!func) {
throw new Error(`WASM function ${functionName} not found`);
}
return func;
}
export async function _createSeed() {
const create_js_seed = await getWasmFunction("create_js_seed");
let seed_result = await create_js_seed();
return { seed: seed_result };
}
export async function _createMessage(m) {
const message = await getWasmFunction("message");
let convertedMessage = await message(m);
return convertedMessage;
}
export async function _createRandomMessage() {
const create_random_message = await getWasmFunction("create_random_message");
let randomMessage = await create_random_message();
return { message: randomMessage };
}
export async function _getPolybaseKey(signature) {
const get_polybase_key = await getWasmFunction("get_polybase_key");
let pbk = await get_polybase_key(signature);
return { key: pbk };
}
export async function _getUniqueHash(signature) {
const get_unique_hash = await getWasmFunction("get_unique_hash");
let did = await get_unique_hash(signature, 0);
return { key: did };
}
export async function _preRegister(signature) {
const pre_register = await getWasmFunction("pre_register");
let pre_reg = pre_register(signature);
return {
encryptionKey: pre_reg[0],
megaPublicKey: pre_reg[1],
encMegaSecretKey: pre_reg[2],
};
}
export async function _encryptData(encryptionKey, dataToEncrypt) {
const encrypt_data = await getWasmFunction("encrypt_data");
return await encrypt_data(encryptionKey, dataToEncrypt);
}
export async function _decryptData(encryptionSignature, dataToDecrypt) {
const decrypt_data = await getWasmFunction("decrypt_data");
return await decrypt_data(encryptionSignature, dataToDecrypt, 0);
}
export async function _formTransaction(to, value, chainId, nonce, data, gasPrice, gas, decimal) {
const form_transaction = await getWasmFunction("form_transaction");
return await form_transaction(to, value, chainId, nonce, data, gasPrice, gas, decimal);
}
export async function _parseTransaction(txdata) {
const parse_transaction = await getWasmFunction("parse_transaction");
let parsedTransaction = await parse_transaction(txdata);
return {
to: parsedTransaction[0],
value: parsedTransaction[1],
chainId: parsedTransaction[2],
nonce: parsedTransaction[3],
gas: parsedTransaction[4],
gasPrice: parsedTransaction[5],
data: parsedTransaction[6],
};
}
export async function _registerStepOne(seed, threshold, index, megaPkArray) {
const compute_pedersen_dealing = await getWasmFunction("compute_pedersen_dealing");
const dealingArray = new Array();
await dealingArray.push(compute_pedersen_dealing(seed, threshold, index, megaPkArray));
await dealingArray.push(compute_pedersen_dealing(seed, threshold, index, megaPkArray));
await dealingArray.push(compute_pedersen_dealing(seed, threshold, index, megaPkArray));
return { pedersenDealingArray: dealingArray };
}
export async function _registerStepTwo(seed, threshold, index, megaPkArray, encryptionSignature, encryptedMegaSecret, dealingsKeyArray, dealingsKappaArray, dealingsLambdaArray) {
const compute_pedersen_opening = await getWasmFunction("compute_pedersen_opening");
const compute_simple_dealing = await getWasmFunction("compute_simple_dealing");
const openingArray = new Array();
const dealingArray = new Array();
const transcriptArray = new Array();
let opening1Array = await compute_pedersen_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingsKeyArray);
let opening2Array = await compute_pedersen_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingsKappaArray);
let opening3Array = await compute_pedersen_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingsLambdaArray);
openingArray.push(opening1Array[0]);
openingArray.push(opening2Array[0]);
openingArray.push(opening3Array[0]);
await transcriptArray.push(opening1Array[1]);
await transcriptArray.push(opening2Array[1]);
await transcriptArray.push(opening3Array[1]);
await dealingArray.push(compute_simple_dealing(seed, threshold, index, encryptionSignature, megaPkArray, opening1Array[0]));
await dealingArray.push(compute_simple_dealing(seed, threshold, index, encryptionSignature, megaPkArray, opening2Array[0]));
return {
pedersenOpeningArray: openingArray,
simpleDealingArray: dealingArray,
pedersenTranscriptArray: transcriptArray,
};
}
export async function _registerStepThree(seed, threshold, index, megaPkArray, encryptionSignature, encryptedMegaSecret, simpleDealingKeyArray, simpleDealingKappaArray, pedersenTranscriptKey, pedersenTranscriptKappa, pedersenOpeningLambda) {
const compute_simple_opening = await getWasmFunction("compute_simple_opening");
const compute_multiply_dealing = await getWasmFunction("compute_multiply_dealing");
const openingArray = new Array();
const dealingArray = new Array();
const transcriptArray = new Array();
let opening1Array = await compute_simple_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, simpleDealingKeyArray, pedersenTranscriptKey);
let opening2Array = await compute_simple_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, simpleDealingKappaArray, pedersenTranscriptKappa);
openingArray.push(opening1Array[0]);
openingArray.push(opening2Array[0]);
transcriptArray.push(opening1Array[1]);
transcriptArray.push(opening2Array[1]);
await dealingArray.push(compute_multiply_dealing(seed, threshold, index, encryptionSignature, megaPkArray, opening1Array[0], pedersenOpeningLambda));
await dealingArray.push(compute_multiply_dealing(seed, threshold, index, encryptionSignature, megaPkArray, opening2Array[0], pedersenOpeningLambda));
return {
simpleOpeningArray: openingArray,
multiplyDealingArray: dealingArray,
simpleTranscriptArray: transcriptArray,
};
}
export async function _getMasterPublicKey(transcript_key) {
const generate_master_public_key_and_address = await getWasmFunction("generate_master_public_key_and_address");
let generatePublicKeys = await generate_master_public_key_and_address(transcript_key);
return generatePublicKeys[1];
}
export async function _signTransaction(seed, threshold, index, message, encryptionSignature, encryptedMegaSecret, dealingKeyXLambdaArray, dealingKappaXLambdaArray, pedersenOpeningLambda, simpleTranscriptKey, simpleTranscriptKappa, pedersenTranscriptLambda) {
const compute_multiply_opening = await getWasmFunction("compute_multiply_opening");
const user_sign_message = await getWasmFunction("user_sign_message");
let signedTransaction = "";
const openings_key_times_lambda = compute_multiply_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingKeyXLambdaArray, simpleTranscriptKey, pedersenTranscriptLambda);
const openings_kappa_times_lambda = compute_multiply_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingKappaXLambdaArray, simpleTranscriptKappa, pedersenTranscriptLambda);
const key_times_lambda = await _decryptData(encryptionSignature, openings_key_times_lambda[0]);
const kappa_times_lambda = await _decryptData(encryptionSignature, openings_kappa_times_lambda[0]);
const opening_lambda = await _decryptData(encryptionSignature, pedersenOpeningLambda);
signedTransaction = user_sign_message(kappa_times_lambda, key_times_lambda, opening_lambda, message, seed, simpleTranscriptKey, simpleTranscriptKappa);
return { signedTransaction: signedTransaction };
}
export async function _signTransactionWithoutLambda(seed, message, encryptionSignature, openingSimpleKey, openingSimpleKappa, simpleTranscriptKey, simpleTranscriptKappa) {
const user_sign_message_without_lambda = await getWasmFunction("user_sign_message_without_lambda");
let signedTransaction = "";
const simple_opening_key = await _decryptData(encryptionSignature, openingSimpleKey);
const simple_opening_kappa = await _decryptData(encryptionSignature, openingSimpleKappa);
signedTransaction = user_sign_message_without_lambda(simple_opening_kappa, simple_opening_key, message, seed, simpleTranscriptKey, simpleTranscriptKappa);
return { signedTransaction: signedTransaction };
}
export async function _combineSignedTransactions(seed, threshold, message, signatureArray, transcript_key, transcript_kappa) {
const combine_signed_shares = await getWasmFunction("combine_signed_shares");
let combinedTransactions;
try {
combinedTransactions = combine_signed_shares(threshold, seed, message, signatureArray, transcript_key, transcript_kappa);
}
catch (exceptionVar) {
console.log(exceptionVar);
}
return { finalSignedTransaction: combinedTransactions };
}
export async function _combineSignedTransactionsWithoutLambda(seed, threshold, message, signatureArray, transcript_key, transcript_kappa) {
const combine_signed_shares_without_lambda = await getWasmFunction("combine_signed_shares_without_lambda");
let combinedTransactions;
try {
combinedTransactions = combine_signed_shares_without_lambda(threshold, seed, message, signatureArray, transcript_key, transcript_kappa);
}
catch (exceptionVar) {
console.log(exceptionVar);
}
return { finalSignedTransaction: combinedTransactions };
}
export async function _reshareStepByOriginalGroup(seed, threshold, index, encryptionSignature, simpleOpeningKey, newMegaPkArray) {
const compute_simple_dealing_reshare = await getWasmFunction("compute_simple_dealing_reshare");
const compute_pedersen_dealing = await getWasmFunction("compute_pedersen_dealing");
const reshareDealings = new Array();
reshareDealings.push(compute_simple_dealing_reshare(seed, threshold, index, encryptionSignature, newMegaPkArray, simpleOpeningKey));
reshareDealings.push(compute_pedersen_dealing(seed, threshold, index, newMegaPkArray));
reshareDealings.push(compute_pedersen_dealing(seed, threshold, index, newMegaPkArray));
return { reshareDealings };
}
export async function _reshareStepOneByNewUser(seed, threshold, index, newMegaPkArray) {
const compute_pedersen_dealing = await getWasmFunction("compute_pedersen_dealing");
const reshareDealings = new Array();
reshareDealings.push(compute_pedersen_dealing(seed, threshold, index, newMegaPkArray));
reshareDealings.push(compute_pedersen_dealing(seed, threshold, index, newMegaPkArray));
return { reshareDealings };
}
export async function _reshareStepTwo(seed, threshold_reshare, index, megaPkArray, encryptionSignature, encryptedMegaSecret, simple_dealings_key_reshared_once_or_twice, simpleTranscriptKey, pedersenDealingsKappaReshare, pedersenDealingsLambdaReshare) {
const compute_simple_opening_reshare_once_or_twice = await getWasmFunction("compute_simple_opening_reshare_once_or_twice");
const compute_pedersen_opening = await getWasmFunction("compute_pedersen_opening");
const compute_simple_dealing_reshare = await getWasmFunction("compute_simple_dealing_reshare");
const compute_simple_dealing = await getWasmFunction("compute_simple_dealing");
const reshareOpenings = new Array();
const reshareDealings = new Array();
const reshareTranscripts = new Array();
let openingReshareAndTranscript = new Array();
openingReshareAndTranscript = compute_simple_opening_reshare_once_or_twice(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, simple_dealings_key_reshared_once_or_twice, simpleTranscriptKey);
let resharePedersenOpening1 = compute_pedersen_opening(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, pedersenDealingsKappaReshare);
let resharePedersenOpening2 = compute_pedersen_opening(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, pedersenDealingsLambdaReshare);
reshareOpenings.push(openingReshareAndTranscript[0]);
reshareOpenings.push(resharePedersenOpening1[0]);
reshareOpenings.push(resharePedersenOpening2[0]);
reshareTranscripts.push(openingReshareAndTranscript[1]);
reshareTranscripts.push(resharePedersenOpening1[1]);
reshareTranscripts.push(resharePedersenOpening2[1]);
let reshareSimpleDealing1 = compute_simple_dealing_reshare(seed, threshold_reshare, index, encryptionSignature, megaPkArray, reshareOpenings[0]);
let reshareSimpleDealing2 = compute_simple_dealing(seed, threshold_reshare, index, encryptionSignature, megaPkArray, reshareOpenings[1]);
reshareDealings.push(reshareSimpleDealing1);
reshareDealings.push(reshareSimpleDealing2);
return { reshareOpenings, reshareDealings, reshareTranscripts };
}
export async function _reshareStepThree(seed, threshold_reshare, index, megaPkArray, encryptionSignature, encryptedMegaSecret, simpleDealingsKappaReshare, pedersenOpeningLambdaReshareArray, simple_dealings_key_reshared_once_or_twice, transcript_key_simple_or_reshared_once, transcriptKappaReshare) {
const compute_simple_opening_reshare_once_or_twice = await getWasmFunction("compute_simple_opening_reshare_once_or_twice");
const compute_simple_opening = await getWasmFunction("compute_simple_opening");
const compute_multiply_dealing = await getWasmFunction("compute_multiply_dealing");
const reshareOpenings = new Array();
const reshareDealings = new Array();
const reshareTranscripts = new Array();
let openingReshareAndTranscript1 = compute_simple_opening_reshare_once_or_twice(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, simple_dealings_key_reshared_once_or_twice, transcript_key_simple_or_reshared_once);
let openingReshareAndTranscript2 = compute_simple_opening(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, simpleDealingsKappaReshare, transcriptKappaReshare);
reshareOpenings.push(openingReshareAndTranscript1[0]);
reshareOpenings.push(openingReshareAndTranscript2[0]);
reshareDealings.push(compute_multiply_dealing(seed, threshold_reshare, index, encryptionSignature, megaPkArray, reshareOpenings[0], pedersenOpeningLambdaReshareArray[index]));
reshareDealings.push(compute_multiply_dealing(seed, threshold_reshare, index, encryptionSignature, megaPkArray, reshareOpenings[1], pedersenOpeningLambdaReshareArray[index]));
reshareTranscripts.push(openingReshareAndTranscript1[1]);
reshareTranscripts.push(openingReshareAndTranscript2[1]);
return { reshareOpenings, reshareDealings, reshareTranscripts };
}
export async function _reshareSignTransaction(seed, threshold_reshare, index, message, encryptionSignature, encryptedMegaSecret, pedersenDealingsLambdaReshare, dealingsKeyXlambdaReshare, dealingsKappaXlambdaReshare, pedersenOpeningLambdaReshare, transcriptKeyResharedTwice, simpleTranscriptsKappaReshare) {
const compute_multiply_opening_reshare = await getWasmFunction("compute_multiply_opening_reshare");
const user_sign_message_reshare = await getWasmFunction("user_sign_message_reshare");
let signedTransaction = "";
const openings_key_times_lambda_reshare = compute_multiply_opening_reshare(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, dealingsKeyXlambdaReshare, pedersenDealingsLambdaReshare, transcriptKeyResharedTwice);
const openings_kappa_times_lambda_reshare = compute_multiply_opening_reshare(seed, threshold_reshare, index, encryptionSignature, encryptedMegaSecret, dealingsKappaXlambdaReshare, pedersenDealingsLambdaReshare, transcriptKeyResharedTwice);
const openings_kappa_times_lambda_reshare_decrypted = await _decryptData(encryptionSignature, openings_kappa_times_lambda_reshare);
const openings_key_times_lambda_reshare_decrypted = await _decryptData(encryptionSignature, openings_key_times_lambda_reshare);
const lambdaOpening = await _decryptData(encryptionSignature, pedersenOpeningLambdaReshare);
signedTransaction = user_sign_message_reshare(openings_kappa_times_lambda_reshare_decrypted, openings_key_times_lambda_reshare_decrypted, lambdaOpening, transcriptKeyResharedTwice, simpleTranscriptsKappaReshare, message, seed);
return { signedTransaction: signedTransaction };
}
export async function _reshareCombineSignedTransactions(simpleTranscriptKappaReshare, transcriptKeyResharedTwice, threshold, seed, message, signatureArray) {
const combine_signed_shares_reshare = await getWasmFunction("combine_signed_shares_reshare");
const combinedTransactions = await combine_signed_shares_reshare(simpleTranscriptKappaReshare, transcriptKeyResharedTwice, threshold, seed, message, signatureArray);
return { finalSignedTransaction: combinedTransactions };
}
export async function _signMessage(seed, threshold, index, message, encryptionSignature, encryptedMegaSecret, dealingKeyXLambdaArray, dealingKappaXLambdaArray, pedersenOpeningLambda, simpleTranscriptKey, simpleTranscriptKappa, pedersenTranscriptLambda) {
const compute_multiply_opening = await getWasmFunction("compute_multiply_opening");
const user_sign_msg = await getWasmFunction("user_sign_msg");
let signedMessage = "";
const openings_key_times_lambda = compute_multiply_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingKeyXLambdaArray, simpleTranscriptKey, pedersenTranscriptLambda);
const openings_kappa_times_lambda = compute_multiply_opening(seed, threshold, index, encryptionSignature, encryptedMegaSecret, dealingKappaXLambdaArray, simpleTranscriptKappa, pedersenTranscriptLambda);
const key_times_lambda = await _decryptData(encryptionSignature, openings_key_times_lambda[0]);
const kappa_times_lambda = await _decryptData(encryptionSignature, openings_kappa_times_lambda[0]);
const opening_lambda = await _decryptData(encryptionSignature, pedersenOpeningLambda);
signedMessage = user_sign_msg(kappa_times_lambda, key_times_lambda, opening_lambda, message, seed, simpleTranscriptKey, simpleTranscriptKappa);
return { signedTransaction: signedMessage };
}
export async function _combineSignedSharesMessage(seed, threshold, message, signatureArray, transcript_key, transcript_kappa) {
const combine_signed_shares_message = await getWasmFunction("combine_signed_shares_message");
let combinedMessage;
try {
combinedMessage = combine_signed_shares_message(threshold, seed, message, signatureArray, transcript_key, transcript_kappa);
}
catch (exceptionVar) {
console.log(exceptionVar);
}
return { finalSignedTransaction: combinedMessage };
}
//# sourceMappingURL=wasm_wrapper.web.js.map