@intuweb3/sdk
Version:
INTU SDK - Modern blockchain interaction toolkit
1,031 lines • 58.4 kB
JavaScript
let wasmModule = null;
let registeredWasmAsset = null;
export function registerWasmAsset(wasmAsset) {
registeredWasmAsset = wasmAsset;
console.log("✅ [WASM Registry] WASM asset registered, type:", typeof wasmAsset);
}
async function getWasmAsset() {
if (registeredWasmAsset !== null) {
return registeredWasmAsset;
}
return { _useAssetPath: true, _assetName: "intu_crypto_bg.wasm" };
}
async function loadWasmBinary(assetModule) {
console.log("🔧 [WASM Loader] Loading WASM module...");
console.log("🔧 [WASM Loader] Asset type:", typeof assetModule);
try {
const { Asset } = await import("expo-asset");
const FileSystem = await import("expo-file-system");
let asset;
if (assetModule && assetModule._useAssetPath) {
console.log("🔧 [WASM Loader] Loading WASM from asset path (avoiding Metro require() issues)...");
const assetName = assetModule._assetName || "intu_crypto_bg.wasm";
let assetLoaded = false;
try {
const path1 = ["..", "..", "assets", "wasm", assetName].join("/");
const path2 = ["..", "..", "..", "assets", "wasm", assetName].join("/");
const dynamicRequire = new Function("path", "return require(path)");
let appAsset = null;
try {
appAsset = dynamicRequire(path1);
}
catch (e1) {
try {
appAsset = dynamicRequire(path2);
}
catch (e2) {
throw e2;
}
}
if (appAsset !== null && appAsset !== undefined) {
if (typeof appAsset === "number") {
console.log("🔧 [WASM Loader] Found WASM in app assets (numeric ID):", appAsset);
asset = Asset.fromModule(appAsset);
assetLoaded = true;
}
else {
console.log("🔧 [WASM Loader] Found WASM in app assets (non-numeric):", typeof appAsset);
asset = Asset.fromModule(appAsset);
assetLoaded = true;
}
}
}
catch (appAssetError) {
console.warn("⚠️ [WASM Loader] App assets not available, trying SDK path:", appAssetError?.message);
}
if (!assetLoaded) {
console.warn("⚠️ [WASM Loader] Could not load WASM from app assets. Please either:", "1. Call registerWasmAsset() with the WASM asset, or", "2. Place intu_crypto_bg.wasm in assets/wasm/ directory");
throw new Error("WASM file not found. Please register it using registerWasmAsset() or place it in assets/wasm/");
}
}
else if (typeof assetModule === "number") {
console.log("🔧 [WASM Loader] Asset is numeric ID:", assetModule);
try {
asset = Asset.fromModule(assetModule);
}
catch (e) {
console.error("❌ [WASM Loader] Asset.fromModule failed:", e?.message);
throw new Error(`Failed to load asset from module ID ${assetModule}: ${e?.message || String(e)}`);
}
}
else if (typeof assetModule === "string") {
console.log("🔧 [WASM Loader] Asset is string path:", assetModule);
asset = Asset.fromURI(assetModule);
}
else if (assetModule && typeof assetModule === "object") {
if (assetModule.constructor?.name === "Asset") {
asset = assetModule;
}
else if (assetModule.default !== undefined) {
return loadWasmBinary(assetModule.default);
}
else if (assetModule.uri) {
asset = Asset.fromURI(assetModule.uri);
}
else {
throw new Error(`Unsupported asset format: ${JSON.stringify(assetModule)}`);
}
}
else {
throw new Error(`Unsupported asset type: ${typeof assetModule}`);
}
console.log("🔧 [WASM Loader] Downloading asset...");
await asset.downloadAsync();
console.log("✅ [WASM Loader] Asset downloaded");
const localUri = asset.localUri || asset.uri;
if (!localUri) {
throw new Error("Asset has no localUri or uri");
}
console.log("🔧 [WASM Loader] Local URI:", localUri);
console.log("🔧 [WASM Loader] Reading file as base64...");
const base64Data = await FileSystem.readAsStringAsync(localUri, {
encoding: FileSystem.EncodingType.Base64,
});
console.log("✅ [WASM Loader] File read, base64 length:", base64Data.length);
console.log("🔧 [WASM Loader] Converting base64 to ArrayBuffer...");
const binaryString = atob(base64Data);
const bytes = new Uint8Array(binaryString.length);
for (let i = 0; i < binaryString.length; i++) {
bytes[i] = binaryString.charCodeAt(i);
}
const arrayBuffer = bytes.buffer;
console.log("✅ [WASM Loader] ArrayBuffer created, size:", arrayBuffer.byteLength, "bytes");
const magicBytes = new Uint8Array(arrayBuffer, 0, 4);
const isValidWasm = magicBytes[0] === 0x00 &&
magicBytes[1] === 0x61 &&
magicBytes[2] === 0x73 &&
magicBytes[3] === 0x6d;
if (!isValidWasm) {
const magicHex = Array.from(magicBytes)
.map((b) => `0x${b.toString(16).padStart(2, "0")}`)
.join(" ");
throw new Error(`Invalid WASM file: missing magic bytes. Got: ${magicHex}, expected: 0x00 0x61 0x73 0x6d`);
}
console.log("✅ [WASM Loader] WASM magic bytes verified");
console.log("✅ [WASM Loader] WASM module loaded successfully");
return arrayBuffer;
}
catch (error) {
console.error("❌ [WASM Loader] Failed to load WASM module:", error);
console.error("❌ [WASM Loader] Error details:", {
message: error instanceof Error ? error.message : String(error),
stack: error instanceof Error ? error.stack : undefined,
});
throw error;
}
}
const objectRegistry = new Map();
let nextRegistryId = 132;
let lastCreatedUint8Array = null;
function getObjectFromRegistry(idx) {
if (idx === 0)
return null;
if (idx === 128)
return undefined;
if (idx === 129)
return null;
if (idx === 130)
return true;
if (idx === 131)
return false;
const obj = objectRegistry.get(idx);
if (obj === undefined && idx > 131) {
console.warn(`⚠️ [SDK Wrapper] Registry index ${idx} not found in registry. Registry size: ${objectRegistry.size}, highest index: ${Math.max(...Array.from(objectRegistry.keys()), 0)}`);
}
return obj;
}
function addToRegistry(obj) {
const idx = nextRegistryId++;
objectRegistry.set(idx, obj);
return idx;
}
function removeFromRegistry(idx) {
if (idx < 132)
return;
objectRegistry.delete(idx);
}
function createRNImports() {
const imports = {
__wbindgen_placeholder__: {},
};
imports.__wbindgen_placeholder__ = imports;
if (typeof global.crypto === "undefined") {
global.crypto = {};
}
if (typeof global.crypto.getRandomValues === "undefined") {
global.crypto.getRandomValues = function (array) {
const view = array;
for (let i = 0; i < view.length; i++) {
view[i] = Math.floor(Math.random() * 256);
}
return array;
};
}
const allBindings = {};
function isLikeNone(x) {
return x === undefined || x === null;
}
allBindings.__wbindgen_object_clone_ref = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return addToRegistry(obj);
};
allBindings.__wbindgen_object_drop_ref = function (arg0) {
removeFromRegistry(arg0);
};
allBindings.__wbindgen_is_undefined = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj === undefined ? 1 : 0;
};
allBindings.__wbindgen_is_object = function (arg0) {
const val = getObjectFromRegistry(arg0);
return typeof val === "object" && val !== null ? 1 : 0;
};
allBindings.__wbindgen_is_string = function (arg0) {
const val = getObjectFromRegistry(arg0);
return typeof val === "string" ? 1 : 0;
};
allBindings.__wbindgen_is_function = function (arg0) {
const val = getObjectFromRegistry(arg0);
return typeof val === "function" ? 1 : 0;
};
allBindings.__wbindgen_is_bigint = function (arg0) {
const val = getObjectFromRegistry(arg0);
return typeof val === "bigint" ? 1 : 0;
};
allBindings.__wbg_static_accessor_SELF_37c5d418e4bf5819 =
function () {
const ret = typeof globalThis !== "undefined"
? globalThis
: typeof self !== "undefined"
? self
: null;
return isLikeNone(ret) ? 0 : addToRegistry(ret);
};
allBindings.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 =
function () {
const ret = typeof globalThis !== "undefined" ? globalThis : null;
return isLikeNone(ret) ? 0 : addToRegistry(ret);
};
allBindings.__wbg_static_accessor_GLOBAL_88a902d13a557d07 =
function () {
const ret = typeof global !== "undefined" ? global : null;
return isLikeNone(ret) ? 0 : addToRegistry(ret);
};
allBindings.__wbg_static_accessor_WINDOW_5de37043a91a9c40 =
function () {
const ret = typeof window !== "undefined" ? window : null;
return isLikeNone(ret) ? 0 : addToRegistry(ret);
};
allBindings.__wbg_crypto_dd1b8f71596b161a = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const crypto = obj?.crypto || global.crypto;
return addToRegistry(crypto);
};
allBindings.__wbg_getRandomValues_760c8e927227643e = function (arg0, arg1) {
const cryptoObj = getObjectFromRegistry(arg0);
let array = getObjectFromRegistry(arg1);
if (arg1 === 0 || array === null) {
console.warn("⚠️ [SDK Wrapper] Array registry index is 0 (null), attempting workaround...");
let foundArray = null;
let highestIndex = 0;
for (const idx of objectRegistry.keys()) {
if (idx > highestIndex) {
highestIndex = idx;
}
}
for (let i = highestIndex; i >= 132; i--) {
const obj = objectRegistry.get(i);
if (obj instanceof Uint8Array && obj.length === 256) {
console.log(`🔧 [SDK Wrapper] Found Uint8Array(256) at registry index ${i}, using it as workaround`);
foundArray = obj;
break;
}
}
if (foundArray) {
array = foundArray;
}
else {
throw new Error(`Invalid array for getRandomValues: registry index ${arg1} returned ${array}. Could not find Uint8Array(256) in registry. This suggests react-native-webassembly is losing the registry index.`);
}
}
if (!array || typeof array.length !== "number") {
throw new Error(`Invalid array for getRandomValues: registry index ${arg1} returned ${array}`);
}
if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
cryptoObj.getRandomValues(array);
}
else if (global.crypto &&
typeof global.crypto.getRandomValues === "function") {
global.crypto.getRandomValues(array);
}
else {
for (let i = 0; i < array.length; i++) {
array[i] = Math.floor(Math.random() * 256);
}
}
console.log("✅ [SDK Wrapper] getRandomValues completed, array filled");
};
allBindings.__wbg_msCrypto_60a4979188f6b80b = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const msCrypto = obj?.msCrypto;
return msCrypto ? addToRegistry(msCrypto) : 0;
};
allBindings.__wbg_process_0caa4f154b97e834 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const process = obj?.process;
return process ? addToRegistry(process) : 0;
};
allBindings.__wbg_versions_134d8f3c6de79566 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const versions = obj?.versions;
return versions ? addToRegistry(versions) : 0;
};
allBindings.__wbg_node_0deadde112ce24bb = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const node = obj?.node;
return node ? addToRegistry(node) : 0;
};
allBindings.__wbg_newwithlength_a381634e90c276d4 = function (arg0) {
const length = arg0 >>> 0;
const array = new Uint8Array(length);
const index = addToRegistry(array);
lastCreatedUint8Array = { array, index, size: length };
console.log(`🔧 [SDK Wrapper] __wbg_newwithlength: created Uint8Array(${length}) at registry index ${index}`);
return index;
};
allBindings.__wbg_subarray_aa9065fa9dc5df96 = function (arg0, arg1, arg2) {
const array = getObjectFromRegistry(arg0);
if (!array || typeof array.subarray !== "function") {
console.error(`❌ [SDK Wrapper] __wbg_subarray: invalid array at registry index ${arg0}:`, array);
throw new Error(`Invalid array for subarray: registry index ${arg0} returned ${array}`);
}
const start = arg1 >>> 0;
const end = arg2 >>> 0;
const subarray = array.subarray(start, end);
return addToRegistry(subarray);
};
allBindings.__wbg_buffer_609cc3eee51ed158 = function (arg0) {
const array = getObjectFromRegistry(arg0);
if (!array) {
console.error(`❌ [SDK Wrapper] __wbg_buffer: invalid array at registry index ${arg0}:`, array);
throw new Error(`Invalid array for buffer: registry index ${arg0} returned ${array}`);
}
if (array instanceof ArrayBuffer) {
return addToRegistry(array);
}
if (array.buffer && array.buffer instanceof ArrayBuffer) {
return addToRegistry(array.buffer);
}
console.error(`❌ [SDK Wrapper] __wbg_buffer: object at registry index ${arg0} is not an ArrayBuffer or TypedArray:`, array, typeof array);
throw new Error(`Invalid object for buffer: registry index ${arg0} returned ${array} (type: ${typeof array})`);
};
allBindings.__wbg_length_a446193dc22c12f8 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj?.length ?? 0;
};
allBindings.__wbg_length_e2d2a49132c1b256 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj?.length ?? 0;
};
allBindings.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj instanceof ArrayBuffer ? 1 : 0;
};
allBindings.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj instanceof Uint8Array ? 1 : 0;
};
allBindings.__wbindgen_string_new = function (arg0, arg1) {
console.log(`🔧 [SDK Wrapper] __wbindgen_string_new called with ptr=${arg0}, len=${arg1}`);
try {
const str = getStringFromWasmMemory(arg0, arg1);
const idx = addToRegistry(str);
console.log(`🔧 [SDK Wrapper] __wbindgen_string_new: created string at registry index ${idx}, length: ${str.length}`);
if (str.length === 0) {
console.warn(`⚠️ [SDK Wrapper] __wbindgen_string_new: String is empty! ptr=${arg0}, len=${arg1}`);
if (wasmMemory) {
try {
const memory = getUint8ArrayMemory();
const bytes = memory.subarray(arg0, arg0 + Math.min(arg1, 100));
console.log(`🔧 [SDK Wrapper] First ${bytes.length} bytes at ptr ${arg0}:`, Array.from(bytes)
.map((b) => `0x${b.toString(16).padStart(2, "0")}`)
.join(" "));
}
catch (e) {
console.error(`❌ [SDK Wrapper] Failed to read raw memory:`, e);
}
}
}
return idx;
}
catch (e) {
console.error(`❌ [SDK Wrapper] __wbindgen_string_new failed:`, e);
return addToRegistry("");
}
};
allBindings.__wbindgen_string_get = function (arg0, arg1) {
try {
const str = getStringFromWasmMemory(arg0, arg1);
console.log(`🔧 [SDK Wrapper] __wbindgen_string_get: read string of length ${str.length}`);
}
catch (e) {
console.error(`❌ [SDK Wrapper] __wbindgen_string_get failed:`, e);
}
};
allBindings.__wbindgen_number_get = function (arg0, arg1) {
console.warn("⚠️ __wbindgen_number_get called but not fully implemented");
};
allBindings.__wbindgen_boolean_get = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj === true ? 1 : 0;
};
let wasmMemory = null;
let cachedUint8ArrayMemory = null;
let cachedTextDecoder = null;
function getUint8ArrayMemory() {
if (!wasmMemory) {
throw new Error("WASM memory not initialized");
}
if (cachedUint8ArrayMemory === null ||
cachedUint8ArrayMemory.buffer !== wasmMemory.buffer) {
cachedUint8ArrayMemory = new Uint8Array(wasmMemory.buffer);
}
return cachedUint8ArrayMemory;
}
function getStringFromWasmMemory(ptr, len) {
ptr = ptr >>> 0;
len = len >>> 0;
if (ptr === 0 && len === 0) {
console.warn("⚠️ [SDK Wrapper] getStringFromWasmMemory called with ptr=0, len=0");
return "";
}
if (!wasmMemory) {
console.error("❌ [SDK Wrapper] getStringFromWasmMemory: WASM memory not initialized");
return "";
}
if (!cachedTextDecoder) {
cachedTextDecoder = new TextDecoder("utf-8", {
ignoreBOM: true,
fatal: true,
});
}
try {
const memory = getUint8ArrayMemory();
if (ptr >= memory.length) {
console.error(`❌ [SDK Wrapper] getStringFromWasmMemory: pointer ${ptr} out of bounds (memory length: ${memory.length})`);
return "";
}
if (ptr + len > memory.length) {
console.warn(`⚠️ [SDK Wrapper] getStringFromWasmMemory: length ${len} exceeds memory bounds, ` +
`clamping to ${memory.length - ptr}`);
len = memory.length - ptr;
}
const subarray = memory.subarray(ptr, ptr + len);
const str = cachedTextDecoder.decode(subarray);
console.log(`🔧 [SDK Wrapper] getStringFromWasmMemory: read ${len} bytes from ptr ${ptr}, ` +
`result length: ${str.length}`);
return str;
}
catch (e) {
console.error(`❌ [SDK Wrapper] getStringFromWasmMemory failed:`, e);
return "";
}
}
allBindings.__wbindgen_memory = function () {
if (wasmMemory) {
return addToRegistry(wasmMemory);
}
return 0;
};
allBindings.__setWasmMemory = function (memory) {
wasmMemory = memory;
cachedUint8ArrayMemory = null;
};
allBindings.__wbindgen_error_new = function (arg0, arg1) {
return 0;
};
allBindings.__wbindgen_throw = function (arg0, arg1) {
const message = getObjectFromRegistry(arg0);
throw new Error(String(message));
};
allBindings.__wbg_value_cd1ffa7b1ab794f1 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const value = obj?.value;
return value !== undefined ? addToRegistry(value) : 0;
};
allBindings.__wbg_done_769e5ede4b31c67b = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return obj?.done === true ? 1 : 0;
};
allBindings.__wbg_next_25feadfc0913fea9 = function (arg0) {
const obj = getObjectFromRegistry(arg0);
const next = obj?.next;
return next !== undefined ? addToRegistry(next) : 0;
};
allBindings.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function (arg0, arg1, arg2) {
const buffer = getObjectFromRegistry(arg0);
if (!buffer || !(buffer instanceof ArrayBuffer)) {
console.error(`❌ [SDK Wrapper] __wbg_newwithbyteoffsetandlength: invalid buffer at registry index ${arg0}:`, buffer);
return 0;
}
const byteOffset = arg1 >>> 0;
const length = arg2 >>> 0;
const array = new Uint8Array(buffer, byteOffset, length);
return addToRegistry(array);
};
allBindings.__wbg_set_37837023f3d740e8 = function (arg0, arg1, arg2) {
const obj = getObjectFromRegistry(arg0);
if (obj === undefined || obj === null) {
console.error(`❌ [SDK Wrapper] __wbg_set: invalid object at registry index ${arg0}:`, obj);
return;
}
const key = arg1 >>> 0;
const value = getObjectFromRegistry(arg2);
if (Array.isArray(obj)) {
obj[key] = value;
}
else if (obj && typeof obj === "object") {
obj[key] = value;
}
};
allBindings.__wbg_set_65595bdd868b3009 = function (arg0, arg1, arg2) {
const target = getObjectFromRegistry(arg0);
let source = getObjectFromRegistry(arg1);
if (source === undefined && arg1 > 10000) {
console.warn(`⚠️ [SDK Wrapper] __wbg_set (65595bdd): Invalid/corrupted registry index ${arg1}, attempting workaround...`);
if (lastCreatedUint8Array && lastCreatedUint8Array.array) {
console.log(`🔧 [SDK Wrapper] Using last created Uint8Array(${lastCreatedUint8Array.size}) ` +
`at registry index ${lastCreatedUint8Array.index} as workaround`);
source = lastCreatedUint8Array.array;
}
else {
let highestIndex = 0;
for (const idx of objectRegistry.keys()) {
if (idx > highestIndex) {
highestIndex = idx;
}
}
for (let i = highestIndex; i >= 132; i--) {
const obj = objectRegistry.get(i);
if (obj instanceof Uint8Array || obj instanceof ArrayBuffer) {
console.log(`🔧 [SDK Wrapper] Found ${obj.constructor.name} at registry index ${i}, using as workaround`);
source = obj;
break;
}
}
}
if (source === undefined) {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): Could not find source object for corrupted index ${arg1}`);
return;
}
}
if (target === undefined || target === null) {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): invalid target at registry index ${arg0}:`, target);
return;
}
if (source === undefined || source === null) {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): invalid source at registry index ${arg1}:`, source);
return;
}
const isTargetTypedArray = target instanceof Uint8Array ||
target instanceof Int8Array ||
target instanceof Uint16Array ||
target instanceof Int16Array ||
target instanceof Uint32Array ||
target instanceof Int32Array ||
target instanceof Float32Array ||
target instanceof Float64Array;
const isSourceTypedArray = source instanceof Uint8Array ||
source instanceof Int8Array ||
source instanceof Uint16Array ||
source instanceof Int16Array ||
source instanceof Uint32Array ||
source instanceof Int32Array ||
source instanceof Float32Array ||
source instanceof Float64Array;
if (!isTargetTypedArray || !isSourceTypedArray) {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): target or source is not a TypedArray. ` +
`Target type: ${target?.constructor?.name}, Source type: ${source?.constructor?.name}`);
return;
}
const targetArray = target instanceof ArrayBuffer ? new Uint8Array(target) : target;
const sourceArray = source instanceof ArrayBuffer ? new Uint8Array(source) : source;
const offset = arg2 >>> 0;
const sourceLength = sourceArray.length;
const targetLength = targetArray.length;
if (offset + sourceLength > targetLength) {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): RangeError - cannot copy ${sourceLength} bytes ` +
`at offset ${offset} into array of length ${targetLength}`);
console.error(` Target: ${targetArray.constructor.name}(${targetLength}) at index ${arg0}, ` +
`Source: ${sourceArray.constructor.name}(${sourceLength}) at index ${arg1}`);
return;
}
if (targetArray && typeof targetArray.set === "function") {
try {
console.log(`🔧 [SDK Wrapper] __wbg_set: copying ${sourceArray.length} bytes ` +
`from ${sourceArray.constructor.name} to ${targetArray.constructor.name} ` +
`at offset ${offset} (target length: ${targetArray.length})`);
targetArray.set(sourceArray, offset);
console.log(`✅ [SDK Wrapper] __wbg_set: copy successful`);
}
catch (e) {
const errorMsg = e?.message || String(e);
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): Error calling target.set: ${errorMsg}`);
console.error(` Target: ${targetArray.constructor.name}(${targetArray.length}) at index ${arg0}, ` +
`Source: ${sourceArray.constructor.name}(${sourceArray.length}) at index ${arg1}, ` +
`Offset: ${offset}, ` +
`Required space: ${offset + sourceArray.length}, ` +
`Available space: ${targetArray.length}`);
}
}
else {
console.error(`❌ [SDK Wrapper] __wbg_set (65595bdd): targetArray.set is not a function`);
}
};
allBindings.__wbg_isArray_a1eab7e0d067391b = function (arg0) {
const obj = getObjectFromRegistry(arg0);
return Array.isArray(obj) ? 1 : 0;
};
allBindings.__wbg_new_a12002a7f91c75be = function (arg0) {
const source = getObjectFromRegistry(arg0);
if (source === undefined || source === null) {
console.error(`❌ [SDK Wrapper] __wbg_new: invalid source at registry index ${arg0}:`, source);
return 0;
}
try {
const array = new Uint8Array(source);
return addToRegistry(array);
}
catch (e) {
console.error("❌ [SDK Wrapper] Error creating Uint8Array:", e);
return 0;
}
};
allBindings.__wbg_get_b9b93047fe3cf45b = function (arg0, arg1) {
const obj = getObjectFromRegistry(arg0);
if (obj === undefined || obj === null) {
console.error(`❌ [SDK Wrapper] __wbg_get: invalid object at registry index ${arg0}:`, obj);
return 0;
}
const index = arg1 >>> 0;
const value = obj?.[index];
return value !== undefined ? addToRegistry(value) : 0;
};
allBindings.__wbg_push_737cfc8c1432c2c6 = function (arg0, arg1) {
const array = getObjectFromRegistry(arg0);
if (array === undefined || array === null) {
console.error(`❌ [SDK Wrapper] __wbg_push: invalid array at registry index ${arg0}:`, array);
return 0;
}
const value = getObjectFromRegistry(arg1);
if (Array.isArray(array)) {
return array.push(value);
}
return 0;
};
const remainingFunctions = [
"__wbg_call_672a4d21634d4a24",
"__wbg_call_7cccdd69e0791ae2",
"__wbg_entries_3265d4158b33e5dc",
"__wbg_get_67b2ba62fc30de12",
"__wbg_isSafeInteger_343e2beeeece1bb0",
"__wbg_iterator_9a24c88df860dc65",
"__wbg_log_c222819a41e063d3",
"__wbg_new_78feb108b6472713",
"__wbg_newnoargs_105ed471475aaf50",
"__wbg_next_6574e1a8a62d1055",
"__wbg_randomFillSync_82e8b56b81896e30",
"__wbg_require_1a22b236558b5786",
"__wbindgen_bigint_from_i64",
"__wbindgen_bigint_from_u64",
"__wbindgen_bigint_get_as_i64",
"__wbindgen_debug_string",
"__wbindgen_in",
"__wbindgen_jsval_eq",
"__wbindgen_jsval_loose_eq",
];
remainingFunctions.forEach((name) => {
if (!allBindings[name]) {
allBindings[name] = function (...args) {
console.warn(`⚠️ Stub function ${name} called with args:`, args);
if (name.includes("get") ||
name.includes("new") ||
name.includes("from") ||
name.includes("value") ||
name.includes("next") ||
name.includes("iterator") ||
name.includes("entries") ||
name.includes("call")) {
return 0;
}
return undefined;
};
}
});
const voidFunctions = [
"__wbg_getRandomValues_760c8e927227643e",
"__wbindgen_object_drop_ref",
"__wbindgen_string_get",
"__wbindgen_number_get",
"__wbg_set_37837023f3d740e8",
"__wbg_set_65595bdd868b3009",
"__wbindgen_throw",
];
const wrappedBindings = {};
for (const [name, fn] of Object.entries(allBindings)) {
if (typeof fn === "function") {
const isVoid = voidFunctions.includes(name);
wrappedBindings[name] = function (...args) {
try {
const result = fn.apply(this, args);
if (isVoid) {
return result;
}
if (result === undefined &&
(name.includes("get") ||
name.includes("new") ||
name.includes("from") ||
name.includes("value") ||
name.includes("accessor") ||
name.includes("clone") ||
name.includes("add"))) {
console.warn(`⚠️ [SDK Wrapper] Function ${name} returned undefined, returning 0 instead`);
return 0;
}
return result;
}
catch (e) {
console.error(`❌ [SDK Wrapper] Error in binding function ${name}:`, e);
console.error(` Args:`, args);
if (!isVoid &&
(name.includes("get") ||
name.includes("new") ||
name.includes("from") ||
name.includes("value") ||
name.includes("accessor") ||
name.includes("clone") ||
name.includes("add"))) {
return 0;
}
return undefined;
}
};
}
else {
wrappedBindings[name] = fn;
}
}
Object.assign(imports.__wbindgen_placeholder__, wrappedBindings);
console.log(`✅ Created ${Object.keys(wrappedBindings).length} React Native-specific wasm-bindgen functions (with error handling)`);
return imports;
}
async function initializeWasm() {
if (!wasmModule) {
try {
console.log("🔧 Initializing WASM module for React Native...");
const wasmAssetValue = await getWasmAsset();
console.log("🔧 [WASM Loader] WASM asset type:", typeof wasmAssetValue);
if (typeof wasmAssetValue === "number") {
console.log("🔧 [WASM Loader] Asset is numeric ID (expected for Metro assets):", wasmAssetValue);
}
const wasmBytecode = await loadWasmBinary(wasmAssetValue);
console.log("🔧 WASM bytecode loaded, attempting instantiation...");
console.log("🔧 WASM size:", wasmBytecode.byteLength, "bytes");
if (typeof global.WebAssembly === "undefined") {
throw new Error("WebAssembly is not available in this environment");
}
if (typeof global.WebAssembly.instantiate !== "function") {
throw new Error("WebAssembly.instantiate is not available");
}
const imports = createRNImports();
console.log("✅ Created React Native-specific imports with registry-based heap");
if (wasmBytecode.byteLength > 1000000) {
console.log("🔧 Large WASM file detected (>1MB), using compile+instantiate with timeout...");
const timeoutPromise = new Promise((_, reject) => {
setTimeout(() => reject(new Error("WASM instantiation timeout after 30 seconds")), 30000);
});
const instantiatePromise = (async () => {
try {
console.log("🔧 Step 1: Compiling WASM module...");
const compiledModule = await global.WebAssembly.compile(wasmBytecode);
console.log("✅ WASM module compiled successfully");
console.log("🔧 Step 2: Instantiating compiled module with RN imports...");
wasmModule = await global.WebAssembly.instantiate(compiledModule, imports);
console.log("✅ WASM module instantiated successfully");
}
catch (error) {
console.warn("⚠️ Compile+instantiate failed, trying direct instantiate:", error);
wasmModule = await global.WebAssembly.instantiate(wasmBytecode, imports);
}
})();
await Promise.race([instantiatePromise, timeoutPromise]);
}
else {
console.log("🔧 Small WASM file, using direct instantiate with RN imports...");
wasmModule = await global.WebAssembly.instantiate(wasmBytecode, imports);
}
console.log("✅ WASM module initialized successfully");
const exports = wasmModule.instance?.exports || {};
const exportNames = Object.keys(exports);
console.log("🔧 WASM exports:", exportNames);
console.log("🔧 WASM exports count:", exportNames.length);
if (exports.create_js_seed) {
console.log("🔧 create_js_seed type:", typeof exports.create_js_seed);
console.log("🔧 create_js_seed:", exports.create_js_seed);
}
if (exports.memory) {
console.log("🔧 WASM memory available:", exports.memory);
console.log("🔧 WASM memory buffer length:", exports.memory.buffer?.byteLength || "N/A");
}
const wasmMemory = wasmModule.instance?.exports?.memory;
if (wasmMemory) {
const placeholder = imports.__wbindgen_placeholder__;
if (placeholder && typeof placeholder.__setWasmMemory === "function") {
placeholder.__setWasmMemory(wasmMemory);
console.log("✅ WASM memory set in React Native bindings");
}
}
}
catch (error) {
console.error("❌ Failed to initialize WASM module:", error);
console.error("❌ Error details:", {
message: error instanceof Error ? error.message : String(error),
stack: error instanceof Error ? error.stack : undefined,
name: error instanceof Error ? error.name : undefined,
});
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();
console.log("🧪 [SDK Wrapper] create_js_seed returned:", seed_result, "type:", typeof seed_result);
if (typeof seed_result === "number") {
const seedString = getObjectFromRegistry(seed_result);
console.log("🧪 [SDK Wrapper] Retrieved from registry index", seed_result, ":", typeof seedString === "string"
? `"${seedString.substring(0, 20)}..." (length: ${seedString.length})`
: seedString, "type:", typeof seedString);
if (typeof seedString === "string") {
if (seedString.length >= 32 && /^[0-9a-fA-F]+$/.test(seedString)) {
removeFromRegistry(seed_result);
console.log("✅ [SDK Wrapper] Seed extracted successfully, length:", seedString.length);
return { seed: seedString };
}
else {
console.warn("⚠️ [SDK Wrapper] Registry index", seed_result, "contains a string but it doesn't look like a valid hex seed:", seedString.substring(0, 50), "...");
removeFromRegistry(seed_result);
return { seed: seedString };
}
}
else if (seedString === undefined || seedString === null) {
console.error("❌ [SDK Wrapper] Registry index", seed_result, "does not exist. This suggests __wbindgen_string_new failed or the string wasn't stored.");
console.error("❌ [SDK Wrapper] Registry size:", objectRegistry.size, "highest index:", Math.max(...Array.from(objectRegistry.keys()), 0));
throw new Error(`Registry index ${seed_result} not found - string creation may have failed. Check if __wbindgen_string_new was called correctly.`);
}
else {
console.warn("⚠️ [SDK Wrapper] Registry index", seed_result, "does not contain a string:", seedString, "type:", typeof seedString);
return { seed: seed_result.toString(16).padStart(64, "0") };
}
}
if (typeof seed_result === "string") {
return { seed: seed_result };
}
console.warn("⚠️ [SDK Wrapper] Unexpected seed_result type:", typeof seed_result, seed_result);
return { seed: String(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