@intuweb3/sdk
Version:
INTU SDK - Modern blockchain interaction toolkit
382 lines • 24 kB
JavaScript
import "react-native-wasm";
import wasmBytecode from "./intu_crypto_bg.wasm";
let wasmModule = null;
let isWasmInitialized = false;
async function initializeWasm() {
if (wasmModule && isWasmInitialized) {
return wasmModule;
}
try {
console.log("🔧 Initializing WASM module with react-native-wasm...");
if (typeof global.WebAssembly === "undefined") {
throw new Error("WebAssembly is not available - react-native-wasm may not be properly loaded");
}
console.log("✅ WebAssembly is available");
if (!wasmBytecode || typeof wasmBytecode !== "object") {
throw new Error("WASM bytecode is not valid or not loaded");
}
console.log("🔧 WASM bytecode type:", typeof wasmBytecode);
console.log("🔧 WASM bytecode size:", wasmBytecode?.byteLength || "unknown");
const imports = {
env: {
memory: new global.WebAssembly.Memory({
initial: 256,
maximum: 65536,
}),
__memory_base: 0,
__table_base: 0,
console_log: (ptr, len) => {
console.log("WASM console.log called");
},
abort: (ptr, file, line, column) => {
console.error("WASM abort called");
},
},
};
if (typeof global.WebAssembly.Table === "function") {
imports.env.table = new global.WebAssembly.Table({
initial: 0,
maximum: 0,
element: "anyfunc",
});
}
wasmModule = await global.WebAssembly.instantiate(wasmBytecode, imports);
console.log("✅ WASM module instantiated successfully");
if (!wasmModule) {
throw new Error("WASM instantiation returned null/undefined");
}
if (!wasmModule.instance && !wasmModule.exports) {
throw new Error("WASM module missing both instance and exports");
}
const exports = wasmModule.instance?.exports || wasmModule.exports;
if (!exports) {
throw new Error("WASM module has no exports");
}
const exportNames = Object.keys(exports);
console.log("🔧 WASM exports available:", exportNames);
console.log("🔧 Total exports count:", exportNames.length);
const criticalFunctions = [
"create_js_seed",
"pre_register",
"get_polybase_key",
];
const missingFunctions = criticalFunctions.filter((fn) => !exports[fn]);
if (missingFunctions.length > 0) {
console.error("❌ Missing critical WASM functions:", missingFunctions);
console.error("❌ Available exports:", exportNames);
throw new Error(`Missing critical WASM functions: ${missingFunctions.join(", ")}`);
}
for (const fn of criticalFunctions) {
if (typeof exports[fn] !== "function") {
throw new Error(`Critical WASM function '${fn}' is not a function (type: ${typeof exports[fn]})`);
}
}
console.log("✅ All critical WASM functions available and valid");
isWasmInitialized = true;
return wasmModule;
}
catch (error) {
console.error("❌ Failed to initialize WASM module:", error);
isWasmInitialized = false;
wasmModule = null;
throw error;
}
}
async function getWasmFunction(functionName) {
try {
console.log(`🔧 Getting WASM function: ${functionName}`);
const module = await initializeWasm();
const exports = module.instance?.exports || module.exports;
if (!exports) {
throw new Error("WASM module has no exports");
}
const func = exports[functionName];
if (!func) {
throw new Error(`WASM function '${functionName}' not found in exports`);
}
if (typeof func !== "function") {
throw new Error(`WASM export '${functionName}' is not a function (type: ${typeof func})`);
}
console.log(`✅ WASM function ${functionName} retrieved successfully`);
return func;
}
catch (error) {
console.error(`❌ Error getting WASM function '${functionName}':`, error);
const errorMessage = error instanceof Error ? error.message : String(error);
throw new Error(`Failed to get WASM function '${functionName}': ${errorMessage}`);
}
}
export async function _createSeed() {
try {
console.log("🔧 Getting create_js_seed function...");
const create_js_seed = await getWasmFunction("create_js_seed");
console.log("✅ Got create_js_seed function, calling it...");
console.log("🔧 create_js_seed function type:", typeof create_js_seed);
const seed_result = await create_js_seed();
console.log("✅ create_js_seed executed successfully, result type:", typeof seed_result);
console.log("🔧 seed_result value:", seed_result);
if (!seed_result) {
throw new Error("create_js_seed returned null or undefined");
}
return { seed: seed_result };
}
catch (error) {
console.error("❌ WASM _createSeed failed:", error);
console.error("❌ Error details:", {
message: error.message,
stack: error.stack,
name: error.name,
});
throw error;
}
}
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.native.js.map