+ self.bindings_header = """
+import * as version from './version.mjs';
+import { UInt5, WitnessVersion } 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, bytes_written_ptr: number) => {
+ // This should generally only be used to print panic messages
+ const ptr_len_view = new Uint32Array(wasm.memory.buffer, iovec_array_ptr, iovec_array_len * 2);
+ var bytes_written = 0;
+ 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("[fd " + fd + "]: " + String.fromCharCode(...bytes_view));
+ bytes_written += ptr_len_view[i*2+1]!;
+ }
+ const written_view = new Uint32Array(wasm.memory.buffer, bytes_written_ptr, 1);
+ written_view[0] = bytes_written;
+ 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
+ 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,
+ // but only if we have variables in environ_sizes_get, so shouldn't ever actually happen!
+ 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 files 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;
+}
+
+const fn_list = ["uuuuuu", "buuuuu", "bbuuuu", "bbbuuu", "bbbbuu", "bbbbbu",
+ "bbbbbb", "ubuubu", "ubuuuu", "ubbuuu", "uubuuu", "uububu", "ububuu"];
+
+/* @internal */
+export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
+ for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
+ const { instance: wasmInstance } = await WebAssembly.instantiate(wasmBinary, imports);
+ await finishInitializeWasm(wasmInstance);
+}
+
+/* @internal */
+export async function initializeWasmFetch(uri: string) {
+ for (const fn of fn_list) { imports.env["js_invoke_function_" + fn] = js_invoke; }
+ const stream = fetch(uri);
+ 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 WitnessVersionArrToBytes(inputArray: Array<WitnessVersion>): 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 encodeUint128 (inputVal: bigint): number {
+ if (inputVal >= 0x10000000000000000000000000000000n) throw "U128s cannot exceed 128 bits";
+ const cArrayPointer = wasm.TS_malloc(16 + 8);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(16);
+ const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, 16);
+ for (var i = 0; i < 16; i++) arrayMemoryView[i] = Number((inputVal >> BigInt(i)*8n) & 0xffn);
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint8Array (inputArray: Uint8Array|null): number {
+ if (inputArray == null) return 0;
+ const cArrayPointer = wasm.TS_malloc(inputArray.length + 8);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(inputArray.length);
+ const arrayMemoryView = new Uint8Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
+ arrayMemoryView.set(inputArray);
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint16Array (inputArray: Uint16Array|Array<number>|null): number {
+ if (inputArray == null) return 0;
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 4) * 2);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(inputArray.length);
+ const arrayMemoryView = new Uint16Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
+ arrayMemoryView.set(inputArray);
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint32Array (inputArray: Uint32Array|Array<number>|null): number {
+ if (inputArray == null) return 0;
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 2) * 4);
+ const arrayLengthView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, 1);
+ arrayLengthView[0] = BigInt(inputArray.length);
+ const arrayMemoryView = new Uint32Array(wasm.memory.buffer, cArrayPointer + 8, inputArray.length);
+ arrayMemoryView.set(inputArray);
+ return cArrayPointer;
+}
+/* @internal */
+export function encodeUint64Array (inputArray: BigUint64Array|Array<bigint>|null): number {
+ if (inputArray == null) return 0;
+ const cArrayPointer = wasm.TS_malloc((inputArray.length + 1) * 8);
+ const arrayMemoryView = new BigUint64Array(wasm.memory.buffer, cArrayPointer, inputArray.length + 1);
+ arrayMemoryView[0] = BigInt(inputArray.length);
+ arrayMemoryView.set(inputArray, 1);
+ return cArrayPointer;
+}
+
+/* @internal */
+export function check_arr_len(arr: Uint8Array|null, len: number): Uint8Array|null {
+ if (arr !== null && arr.length != len) { throw new Error("Expected array of length " + len + " got " + arr.length); }
+ return arr;
+}
+
+/* @internal */
+export function check_16_arr_len(arr: Uint16Array|null, len: number): Uint16Array|null {
+ if (arr !== null && 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 BigUint64Array(wasm.memory.buffer, arrayPointer, 1);
+ const len = arraySizeViewer[0]!;
+ if (len >= (2n ** 32n)) throw new Error("Bogus Array Size");
+ return Number(len % (2n ** 32n));
+}
+/* @internal */
+export function decodeUint128 (arrayPointer: number, free = true): bigint {
+ const arraySize = getArrayLength(arrayPointer);
+ if (arraySize != 16) throw "Need 16 bytes for a uint128";
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, arraySize);
+ var val = 0n;
+ for (var i = 0; i < 16; i++) {
+ val <<= 8n;
+ val |= BigInt(actualArrayViewer[i]!);
+ }
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return val;
+}
+/* @internal */
+export function decodeUint8Array (arrayPointer: number, free = true): Uint8Array {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, 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;
+}
+/* @internal */
+export function decodeUint16Array (arrayPointer: number, free = true): Uint16Array {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new Uint16Array(wasm.memory.buffer, arrayPointer + 8, 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;
+}
+/* @internal */
+export function decodeUint64Array (arrayPointer: number, free = true): bigint[] {
+ const arraySize = getArrayLength(arrayPointer);
+ const actualArrayViewer = new BigUint64Array(
+ wasm.memory.buffer, // value
+ arrayPointer + 8, // 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 = new Array(arraySize);
+ for (var i = 0; i < arraySize; i++) actualArray[i] = actualArrayViewer[i];
+ if (free) {
+ wasm.TS_free(arrayPointer);
+ }
+ return actualArray;
+}
+
+export function freeWasmMemory(pointer: number) { wasm.TS_free(pointer); }
+
+/* @internal */
+export function getU64ArrayElem(arrayPointer: number, idx: number): bigint {
+ const actualArrayViewer = new BigUint64Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
+ return actualArrayViewer[idx]!;
+}
+
+/* @internal */
+export function getU32ArrayElem(arrayPointer: number, idx: number): number {
+ const actualArrayViewer = new Uint32Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
+ return actualArrayViewer[idx]!;
+}
+
+/* @internal */
+export function getU8ArrayElem(arrayPointer: number, idx: number): number {
+ const actualArrayViewer = new Uint8Array(wasm.memory.buffer, arrayPointer + 8, idx + 1);
+ return actualArrayViewer[idx]!;