+ self.bindings_header = """
+import * as version from './version.mjs';
+import { UInt5 } from './structs/CommonBase.mjs';
+
+const imports: any = {};
+imports.env = {};
+
+var js_objs: Array<WeakRef<object>> = [];
+var js_invoke: Function;
+var getRandomValues: Function;
+
+imports.wasi_snapshot_preview1 = {
+ "fd_write": (fd: number, iovec_array_ptr: number, iovec_array_len: number) => {
+ // This should generally only be used to print panic messages
+ console.log("FD_WRITE to " + fd + " in " + iovec_array_len + " chunks.");
+ const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
+ for (var i = 0; i < iovec_array_len; i++) {
+ const bytes_view = new Uint8Array(wasm.memory.buffer, ptr_len_view[i*2], ptr_len_view[i*2+1]);
+ console.log(String.fromCharCode(...bytes_view));
+ }
+ return 0;
+ },
+ "fd_close": (_fd: number) => {
+ // This is not generally called, but may be referenced in debug builds
+ console.log("wasi_snapshot_preview1:fd_close");
+ return 58; // Not Supported
+ },
+ "fd_seek": (_fd: number, _offset: bigint, _whence: number, _new_offset: number) => {
+ // This is not generally called, but may be referenced in debug builds
+ console.log("wasi_snapshot_preview1:fd_seek");
+ return 58; // Not Supported
+ },
+ "random_get": (buf_ptr: number, buf_len: number) => {
+ const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
+ getRandomValues(buf);
+ return 0;
+ },
+ "environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
+ // This is called before fd_write to format + print panic messages
+ console.log("wasi_snapshot_preview1:environ_sizes_get");
+ const out_count_view = new Uint32Array(wasm.memory.buffer, environ_var_count_ptr, 1);
+ out_count_view[0] = 0;
+ const out_len_view = new Uint32Array(wasm.memory.buffer, environ_len_ptr, 1);
+ out_len_view[0] = 0;
+ return 0;
+ },
+ "environ_get": (environ_ptr: number, environ_buf_ptr: number) => {
+ // This is called before fd_write to format + print panic messages
+ console.log("wasi_snapshot_preview1:environ_get");
+ return 58; // Note supported - we said there were 0 environment entries!
+ },
+ "proc_exit" : () => {
+ console.log("wasi_snapshot_preview1:proc_exit");
+ },
+};
+
+var wasm: any = null;
+let isWasmInitialized: boolean = false;
+
+async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
+ if (typeof crypto === "undefined") {
+ var crypto_import = (await import('crypto')).webcrypto;
+ getRandomValues = crypto_import.getRandomValues.bind(crypto_import);
+ } else {
+ getRandomValues = crypto.getRandomValues.bind(crypto);
+ }
+
+ wasm = wasmInstance.exports;
+ if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
+ throw new Error(\"Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
+ }
+
+ if (decodeString(wasm.TS_get_lib_version_string()) !== version.get_ldk_java_bindings_version())
+ throw new Error(\"Compiled LDK library and LDK class failes do not match\");
+ // Fetching the LDK versions from C also checks that the header and binaries match
+ const c_bindings_ver: number = wasm.TS_get_ldk_c_bindings_version();
+ const ldk_ver: number = wasm.TS_get_ldk_version();
+ if (c_bindings_ver == 0)
+ throw new Error(\"LDK version did not match the header we built against\");
+ if (ldk_ver == 0)
+ throw new Error(\"LDK C bindings version did not match the header we built against\");
+ const c_bindings_version: string = decodeString(c_bindings_ver)
+ const ldk_version: string = decodeString(ldk_ver);
+ console.log(\"Loaded LDK-Java Bindings with LDK \" + ldk_version + \" and LDK-C-Bindings \" + c_bindings_version);
+
+ isWasmInitialized = true;
+}
+
+/* @internal */
+export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
+ imports.env["js_invoke_function"] = js_invoke;
+ const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
+ await finishInitializeWasm(wasmInstance);
+}
+
+/* @internal */
+export async function initializeWasmFetch(uri: string) {
+ const stream = fetch(uri);
+ imports.env["js_invoke_function"] = js_invoke;
+ const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
+ await finishInitializeWasm(wasmInstance);
+}"""
+
+ self.bindings_header += """
+// WASM CODEC
+
+/* @internal */
+export function uint5ArrToBytes(inputArray: Array<UInt5>): Uint8Array {
+ const arr = new Uint8Array(inputArray.length);
+ for (var i = 0; i < inputArray.length; i++) {
+ arr[i] = inputArray[i].getVal();
+ }
+ return arr;
+}
+
+/* @internal */
+export function encodeUint8Array (inputArray: Uint8Array): number {
+ const cArrayPointer = wasm.TS_malloc(inputArray.length + 4);
+ const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = inputArray.length;
+ const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
+ arrayMemoryView.set(inputArray);
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint32Array (inputArray: Uint32Array|Array<number>): number {
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 4);
+ const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer, inputArray.length);
+ arrayMemoryView.set(inputArray, 1);
+ arrayMemoryView[0] = inputArray.length;
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>): number {
+ const cArrayPointer = wasm.TS_malloc(inputArray.length * 8 + 1);
+ const arrayLengthView = new Uint32Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = inputArray.length;
+ const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer + 4, inputArray.length);
+ arrayMemoryView.set(inputArray);
+ return cArrayPointer;
+}
+
+/* @internal */
+export function check_arr_len(arr: Uint8Array, len: number): Uint8Array {
+ if (arr.length != len) { throw new Error("Expected array of length " + len + "got " + arr.length); }
+ return arr;
+}
+
+/* @internal */
+export function getArrayLength(arrayPointer: number): number {
+ const arraySizeViewer = new Uint32Array(wasm.memory.buffer, arrayPointer, 1);
+ return arraySizeViewer[0];
+}
+/* @internal */
+export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, arraySize);
+ // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
+ // will free the underlying memory when it becomes unreachable instead of copying here.
+ // Note that doing so may have edge-case interactions with memory resizing (invalidating the buffer).
+ const actualArray = actualArrayViewer.slice(0, arraySize);
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return actualArray;
+}
+const decodeUint32Array = (arrayPointer: number, free = true) => {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new Uint32Array(
+ wasm.memory.buffer, // value
+ arrayPointer + 4, // offset (ignoring length bytes)
+ arraySize // uint32 count
+ );
+ // Clone the contents, TODO: In the future we should wrap the Viewer in a class that
+ // will free the underlying memory when it becomes unreachable instead of copying here.
+ const actualArray = actualArrayViewer.slice(0, arraySize);
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return actualArray;
+}
+
+
+export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
+
+/* @internal */
+export function getU32ArrayElem(arrayPointer: number, idx: number): number {
+ const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
+ return actualArrayViewer[idx];
+}
+
+/* @internal */
+export function getU8ArrayElem(arrayPointer: number, idx: number): number {
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 4, idx + 1);
+ return actualArrayViewer[idx];
+}
+
+
+/* @internal */
+export function encodeString(str: string): number {
+ const charArray = new TextEncoder().encode(str);
+ return encodeUint8Array(charArray);
+}
+
+/* @internal */
+export function decodeString(stringPointer: number, free = true): string {
+ const arraySize = getArrayLength(stringPointer);
+ const memoryView = new Uint8Array(wasm.memory.buffer, stringPointer + 4, arraySize);
+ const result = new TextDecoder("utf-8").decode(memoryView);
+
+ if (free) {
+ wasm.TS_free(stringPointer);
+ }
+
+ return result;
+}
+"""
+ if DEBUG:
+ self.bindings_header += """
+/* @internal */
+export function getRemainingAllocationCount(): number {
+ return wasm.TS_allocs_remaining();
+}
+/* @internal */
+export function debugPrintRemainingAllocs() {
+ wasm.TS_print_leaks();
+}
+"""
+ else:
+ self.bindings_header += "\n/* @internal */ export function getRemainingAllocationCount(): number { return 0; }\n"
+ self.bindings_header += "/* @internal */ export function debugPrintRemainingAllocs() { }\n"
+
+ with open(outdir + "/index.mts", 'a') as index:
+ index.write("""import { initializeWasmFetch, initializeWasmFromUint8Array } from './bindings.mjs';
+/** Initializes the WASM backend by calling `fetch()` on the given URI - Browser only */
+export async function initializeWasmWebFetch(uri: string) {
+ await initializeWasmFetch(uri);
+}
+/** Initializes the WASM backend given a Uint8Array of the .wasm binary file - Browser or Node.JS */
+export async function initializeWasmFromBinary(bin: Uint8Array) {
+ await initializeWasmFromUint8Array(bin);
+}
+
+""")