From 4f8eade3592d704fd0d9f968aeca4810dc710a5c Mon Sep 17 00:00:00 2001
From: Matt Corallo <git@bluematt.me>
Date: Mon, 17 Jan 2022 22:27:50 +0000
Subject: [PATCH] [TS] Unify Web and Node.JS output so it can be universal

---
 genbindings.sh        | 19 ++++++---------
 ts/test/index.html    |  6 ++---
 ts/test/node.mjs      |  7 ++++--
 ts/test/tests.mts     | 14 ++++++++---
 typescript_strings.py | 57 ++++++++++++++++++++++++++-----------------
 5 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/genbindings.sh b/genbindings.sh
index 128a3afb..7fc10bc9 100755
--- a/genbindings.sh
+++ b/genbindings.sh
@@ -6,6 +6,7 @@ usage() {
 	echo "debug should either be true, false, or leaks"
 	echo "debug of leaks turns on leak tracking on an optimized release bianry"
 	echo "android_web should either be true or false and indicates if we build for android (Java) or web (WASM)"
+	echo "Note that web currently generates the same results as !web (ie Node.JS)"
 	exit 1
 }
 [ "$1" = "" ] && usage
@@ -219,17 +220,13 @@ else
 			mv $F.tmp $F
 		done
 		rm imports.mts.part
-		if [ "$4" = "true" ]; then
-			tsc
-		else
-			tsc --types node --typeRoots .
-			cp ../$WASM_FILE liblightningjs.wasm
-			echo Ready to publish!
-			if [ -x "$(which node)" ]; then
-				NODE_V="$(node --version)"
-				if [ "${NODE_V:1:2}" -gt 14 ]; then
-					node test/node.mjs
-				fi
+		tsc --types node --typeRoots .
+		cp ../$WASM_FILE liblightningjs.wasm
+		echo Ready to publish!
+		if [ -x "$(which node)" ]; then
+			NODE_V="$(node --version)"
+			if [ "${NODE_V:1:2}" -gt 14 ]; then
+				node test/node.mjs
 			fi
 		fi
 	fi
diff --git a/ts/test/index.html b/ts/test/index.html
index 3fc55a6d..60fd523c 100644
--- a/ts/test/index.html
+++ b/ts/test/index.html
@@ -7,10 +7,10 @@
 	var test_runner;
 </script>
 <script type="module">
-	import { run_tests } from './tests.mjs';
-	test_runner = run_tests;
+	import { run_tests_web } from './tests.mjs';
+	test_runner = run_tests_web;
 	try {
-		const result = await run_tests('../liblightningjs.wasm');
+		const result = await run_tests_web('../liblightningjs.wasm');
 		if (result === true) {
 			document.getElementById("results").innerHTML = "All Tests Passed (note free-time errors may still occurr)!";
 		} else {
diff --git a/ts/test/node.mjs b/ts/test/node.mjs
index dfabe66e..d1442814 100644
--- a/ts/test/node.mjs
+++ b/ts/test/node.mjs
@@ -1,4 +1,7 @@
-import { run_tests } from "./tests.mjs";
+import { run_tests_node } from "./tests.mjs";
 import { strict as assert } from 'assert';
-const res = await run_tests('./liblightningjs.wasm');
+import * as fs from 'fs';
+
+const bin = fs.readFileSync('./liblightningjs.wasm');
+const res = await run_tests_node(bin);
 assert(res);
diff --git a/ts/test/tests.mts b/ts/test/tests.mts
index 4299f3b8..35631d25 100644
--- a/ts/test/tests.mts
+++ b/ts/test/tests.mts
@@ -197,9 +197,7 @@ tests.push(async () => {
 	return true;
 });
 
-export async function run_tests(wasm_path: string, check_leaks: boolean = true) {
-	await rawldk.initializeWasm(wasm_path);
-
+async function run_tests(check_leaks: boolean) {
 	var test_runs = [];
 	for (const test of tests) {
 		test_runs.push(test());
@@ -229,3 +227,13 @@ export async function run_tests(wasm_path: string, check_leaks: boolean = true)
 	});
 	return allocs_finished;
 }
+
+export async function run_tests_web(wasm_path: string, check_leaks: boolean = true) {
+	await ldk.initializeWasmWebFetch(wasm_path);
+	return await run_tests(check_leaks);
+}
+
+export async function run_tests_node(wasm_file: Uint8Array, check_leaks: boolean = true) {
+	await ldk.initializeWasmFromBinary(wasm_file);
+	return await run_tests(check_leaks);
+}
diff --git a/typescript_strings.py b/typescript_strings.py
index c0a0cccb..2b0ab1c9 100644
--- a/typescript_strings.py
+++ b/typescript_strings.py
@@ -42,6 +42,7 @@ 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) => {
@@ -66,7 +67,7 @@ imports.wasi_snapshot_preview1 = {
 	},
 	"random_get": (buf_ptr: number, buf_len: number) => {
 		const buf = new Uint8Array(wasm.memory.buffer, buf_ptr, buf_len);
-		crypto.getRandomValues(buf);
+		getRandomValues(buf);
 		return 0;
 	},
 	"environ_sizes_get": (environ_var_count_ptr: number, environ_len_ptr: number) => {
@@ -90,25 +91,15 @@ imports.wasi_snapshot_preview1 = {
 
 var wasm: any = null;
 let isWasmInitialized: boolean = false;
-"""
 
-        if target == Target.NODEJS:
-            self.bindings_header += """import * as fs from 'fs';
-import { webcrypto as crypto } from 'crypto';
-/* @internal */
-export async function initializeWasm(path: string) {
-	const source = fs.readFileSync(path);
-	imports.env["js_invoke_function"] = js_invoke;
-	const { instance: wasmInstance } = await WebAssembly.instantiate(source, imports);"""
-        else:
-            self.bindings_header += """
-/* @internal */
-export async function initializeWasm(uri: string) {
-	const stream = fetch(uri);
-	imports.env["js_invoke_function"] = js_invoke;
-	const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);"""
+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);
+	}
 
-        self.bindings_header += """
 	wasm = wasmInstance.exports;
 	if (!wasm.test_bigint_pass_deadbeef0badf00d(BigInt("0xdeadbeef0badf00d"))) {
 		throw new Error(\"Currently need BigInt-as-u64 support, try ----experimental-wasm-bigint");
@@ -128,8 +119,24 @@ export async function initializeWasm(uri: string) {
 	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
 
 const nextMultipleOfFour = (value: number) => {
@@ -247,10 +254,16 @@ export function debugPrintRemainingAllocs() {
             self.bindings_header += "/* @internal */ export function debugPrintRemainingAllocs() { }\n"
 
         with open(outdir + "/index.mts", 'a') as index:
-            index.write("""import { initializeWasm as bindingsInit } from './bindings.mjs';
-export function initializeWasm(path: string) {
-	bindingsInit(path);
+            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);
 }
+
 """)
 
         self.bindings_version_file = """export function get_ldk_java_bindings_version(): String {
-- 
2.39.5