Merge pull request #104 from TheBlueMatt/main

TheBlueMatt · web-flow · commit 47cbd099c1e1 · 2022-06-30T14:34:00.000-07:00
Fix TS u64 call semantics (and test it)
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -95,6 +95,7 @@ jobs:
           kill $SERVER_PID
       - name: Check latest TS files are in git
         run: |
+          git checkout ts/package.json
           git diff --exit-code
 
   java_bindings:
diff --git a/genbindings.sh b/genbindings.sh
@@ -189,6 +189,7 @@ else
 		./genbindings.py "./lightning.h" ts ts ts $DEBUG_ARG typescript browser
 	fi
 	rm -f ts/bindings.c
+	sed -i 's/^  "version": .*/  "version": "'${LDK_GARBAGECOLLECTED_GIT_OVERRIDE:1:100}'",/g' ts/package.json
 	if [ "$3" = "true" ]; then
 		echo "#define LDK_DEBUG_BUILD" > ts/bindings.c
 	elif [ "$3" = "leaks" ]; then
diff --git a/ts/bindings.c b/ts/bindings.c
diff --git a/ts/bindings.c.body b/ts/bindings.c.body
diff --git a/ts/bindings.mts b/ts/bindings.mts
@@ -71,7 +71,7 @@ async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
 	}
 
 	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");
+		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();
@@ -88,15 +88,17 @@ async function finishInitializeWasm(wasmInstance: WebAssembly.Instance) {
 
 /* @internal */
 export async function initializeWasmFromUint8Array(wasmBinary: Uint8Array) {
-	imports.env["js_invoke_function"] = js_invoke;
+	imports.env["js_invoke_function_u"] = js_invoke;
+	imports.env["js_invoke_function_b"] = 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;
+	imports.env["js_invoke_function_u"] = js_invoke;
+	imports.env["js_invoke_function_b"] = js_invoke;
 	const { instance: wasmInstance } = await WebAssembly.instantiateStreaming(stream, imports);
 	await finishInitializeWasm(wasmInstance);
 }
@@ -32624,7 +32626,7 @@ export function SiPrefix_to_str(o: number): number {
 }
 
 
-js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number, arg3: number, arg4: number, arg5: number, arg6: number, arg7: number, arg8: number, arg9: number, arg10: number) {
+js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
 	const weak: WeakRef<object> = js_objs[obj_ptr];
 	if (weak == null || weak == undefined) {
 		console.error("Got function call on unknown/free'd JS object!");
@@ -32743,5 +32745,7 @@ js_invoke = function(obj_ptr: number, fn_id: number, arg1: number, arg2: number,
 		console.error("Got function call on incorrect JS object!");
 		throw new Error("Got function call on incorrect JS object!");
 	}
-	return fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+	const ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+	if (ret === undefined || ret === null) return BigInt(0);
+	return BigInt(ret);
 }
diff --git a/ts/js-wasm.h b/ts/js-wasm.h
@@ -4,40 +4,46 @@
 
 extern size_t strlen(const char *s);
 
+// We only support two call types - u32 and u64. u32 is mapped to a JavaScript
+// "number" whereas u64 is mapped to a JavaScript "bigint". Ultimately it all
+// calls through to the same function, but at the FFI boundary itself we have
+// to use proper types.
+
 typedef uint32_t JSValue;
-extern JSValue js_invoke_function(JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue) __attribute__((import_name("js_invoke_function")));
+extern uint64_t js_invoke_function_u(JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue,JSValue) __attribute__((import_name("js_invoke_function_u")));
+extern uint64_t js_invoke_function_b(JSValue,JSValue,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t) __attribute__((import_name("js_invoke_function_b")));
 
-static inline JSValue js_invoke_function_0(JSValue obj, JSValue fn){
-  return js_invoke_function(obj,fn,0,0,0,0,0,0,0,0,0,0);
-}
-static inline JSValue js_invoke_function_1(JSValue obj, JSValue fn, JSValue a){
-  return js_invoke_function(obj,fn,a,0,0,0,0,0,0,0,0,0);
+static inline JSValue js_invoke_function_u_(JSValue obj, JSValue fn){
+  return js_invoke_function_u(obj,fn,0,0,0,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_2(JSValue obj, JSValue fn, JSValue a, JSValue b){
-  return js_invoke_function(obj,fn,a,b,0,0,0,0,0,0,0,0);
+static inline JSValue js_invoke_function_u_u(JSValue obj, JSValue fn, JSValue a){
+  return js_invoke_function_u(obj,fn,a,0,0,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_3(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c){
-  return js_invoke_function(obj,fn,a,b,c,0,0,0,0,0,0,0);
+static inline JSValue js_invoke_function_u_uu(JSValue obj, JSValue fn, JSValue a, JSValue b){
+  return js_invoke_function_u(obj,fn,a,b,0,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_4(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d){
-  return js_invoke_function(obj,fn,a,b,c,d,0,0,0,0,0,0);
+static inline JSValue js_invoke_function_u_uuu(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c){
+  return js_invoke_function_u(obj,fn,a,b,c,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_5(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e){
-  return js_invoke_function(obj,fn,a,b,c,d,e,0,0,0,0,0);
+static inline JSValue js_invoke_function_u_uuuu(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d){
+  return js_invoke_function_u(obj,fn,a,b,c,d,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_6(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f){
-  return js_invoke_function(obj,fn,a,b,c,d,e,f,0,0,0,0);
+static inline JSValue js_invoke_function_u_uuuuu(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e){
+  return js_invoke_function_u(obj,fn,a,b,c,d,e,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_7(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g){
-  return js_invoke_function(obj,fn,a,b,c,d,e,f,g,0,0,0);
+
+static inline uint64_t js_invoke_function_b_(JSValue obj, JSValue fn){
+  return js_invoke_function_u(obj,fn,0,0,0,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_8(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h){
-  return js_invoke_function(obj,fn,a,b,c,d,e,f,g,h,0,0);
+
+static inline uint64_t js_invoke_function_b_uuuu(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d){
+  return js_invoke_function_u(obj,fn,a,b,c,d,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_9(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h, JSValue i){
-  return js_invoke_function(obj,fn,a,b,c,d,e,f,g,h,i,0);
+static inline JSValue js_invoke_function_u_b(JSValue obj, JSValue fn, uint64_t a){
+  return js_invoke_function_b(obj,fn,a,0,0,0,0,0,0,0,0,0);
 }
-static inline JSValue js_invoke_function_10(JSValue obj, JSValue fn, JSValue a, JSValue b, JSValue c, JSValue d, JSValue e, JSValue f, JSValue g, JSValue h, JSValue i, JSValue j){
-  return js_invoke_function(obj,fn,a,b,c,d,e,f,g,h,i,j);
+static inline JSValue js_invoke_function_u_bb(JSValue obj, JSValue fn, uint64_t a, uint64_t b){
+  return js_invoke_function_b(obj,fn,a,b,0,0,0,0,0,0,0,0);
 }
+
 #endif
diff --git a/ts/package.json b/ts/package.json
@@ -1,6 +1,6 @@
 {
   "name": "lightningdevkit",
-  "version": "0.0.106.0beta1",
+  "version": "Set in genbindings.sh automagically",
   "description": "Lightning Development Kit",
   "main": "index.mjs",
   "types": "index.d.mts",
@@ -15,6 +15,8 @@
     "enums/*.d.mts",
     "bindings.mjs",
     "bindings.d.mts",
+    "index.mjs",
+    "index.d.mts",
     "version.mjs",
     "liblightningjs.wasm",
     "tsconfig.json",
diff --git a/ts/test/tests.mts b/ts/test/tests.mts
@@ -55,7 +55,11 @@ tests.push(async () => {
 });
 
 var seed_counter = 0;
-function get_chanman() {
+class Node {
+	constructor(public chan_man: ldk.ChannelManager, public tx_broadcasted: Promise<Uint8Array>, public logger: ldk.Logger,
+		public node_id: Uint8Array, public node_secret: Uint8Array) {}
+}
+function get_chanman(): Node {
 	const fee_est = ldk.FeeEstimator.new_impl({
 		get_est_sat_per_1000_weight(confirmation_target: ldk.ConfirmationTarget): number {
 			return 253;
@@ -93,7 +97,11 @@ function get_chanman() {
 	const config = ldk.UserConfig.constructor_default();
 	const params = ldk.ChainParameters.constructor_new(ldk.Network.LDKNetwork_Testnet, ldk.BestBlock.constructor_from_genesis(ldk.Network.LDKNetwork_Testnet));
 
-	return [ldk.ChannelManager.constructor_new(fee_est, chain_watch, tx_broadcaster, logger, keys_interface, config, params), tx_broadcasted];
+	const chan_man = ldk.ChannelManager.constructor_new(fee_est, chain_watch, tx_broadcaster, logger, keys_interface, config, params);
+	return new Node(
+		chan_man, tx_broadcasted, logger, chan_man.get_our_node_id(),
+		(keys_interface.get_node_secret(ldk.Recipient.LDKRecipient_Node) as ldk.Result_SecretKeyNoneZ_OK).res
+	);
 }
 
 function exchange_messages(a: ldk.ChannelManager, b: ldk.ChannelManager) {
@@ -139,39 +147,41 @@ function assign_u64(arr: Uint8Array, offset: number, value: bigint) {
 	arr[offset + 7] = Number((value >> BigInt(8 * 7)) & BigInt(0xff));
 }
 
+function get_event(chan_man: ldk.ChannelManager): ldk.Event {
+	const events: Array<ldk.Event> = [];
+	const event_handler = ldk.EventHandler.new_impl({
+		handle_event(event: ldk.Event): void {
+			events.push(event);
+		}
+	} as ldk.EventHandlerInterface);
+
+	chan_man.as_EventsProvider().process_pending_events(event_handler);
+	console.assert(events.length == 1);
+	return events[0];
+}
+
 tests.push(async () => {
-	const peer_a = get_chanman();
-	const peer_b = get_chanman();
-	const chan_man_a: ldk.ChannelManager = peer_a[0] as ldk.ChannelManager;
-	const chan_man_b: ldk.ChannelManager = peer_b[0] as ldk.ChannelManager;
+	const a = get_chanman();
+	const b = get_chanman();
 
-	chan_man_a.as_ChannelMessageHandler().peer_connected(chan_man_b.get_our_node_id(), ldk.Init.constructor_new(ldk.InitFeatures.constructor_known(), ldk.Option_NetAddressZ.constructor_none()));
-	chan_man_b.as_ChannelMessageHandler().peer_connected(chan_man_a.get_our_node_id(), ldk.Init.constructor_new(ldk.InitFeatures.constructor_known(), ldk.Option_NetAddressZ.constructor_none()));
+	a.chan_man.as_ChannelMessageHandler().peer_connected(b.chan_man.get_our_node_id(), ldk.Init.constructor_new(ldk.InitFeatures.constructor_known(), ldk.Option_NetAddressZ.constructor_none()));
+	b.chan_man.as_ChannelMessageHandler().peer_connected(a.chan_man.get_our_node_id(), ldk.Init.constructor_new(ldk.InitFeatures.constructor_known(), ldk.Option_NetAddressZ.constructor_none()));
 
-	const chan_create_err = chan_man_a.create_channel(chan_man_b.get_our_node_id(), BigInt(0), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
+	const chan_create_err = a.chan_man.create_channel(b.chan_man.get_our_node_id(), BigInt(0), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
 	if (chan_create_err.is_ok()) return false;
 	if (!(chan_create_err instanceof ldk.Result__u832APIErrorZ_Err)) return false;
 	if (!(chan_create_err.err instanceof ldk.APIError_APIMisuseError)) return false;
 	if (chan_create_err.err.err != "Channel value must be at least 1000 satoshis. It was 0") return false;
 
-	const chan_create_res = chan_man_a.create_channel(chan_man_b.get_our_node_id(), BigInt(1000000), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
+	const chan_create_res = a.chan_man.create_channel(b.chan_man.get_our_node_id(), BigInt(1000000), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
 	if (!chan_create_res.is_ok()) return false;
 
-	if (!exchange_messages(chan_man_a, chan_man_b)) return false;
+	if (!exchange_messages(a.chan_man, b.chan_man)) return false;
 
-	const events: Array<ldk.Event> = [];
-	const event_handler = ldk.EventHandler.new_impl({
-		handle_event(event: ldk.Event): void {
-			events.push(event);
-		}
-	} as ldk.EventHandlerInterface);
-
-	chan_man_a.as_EventsProvider().process_pending_events(event_handler);
-	if (events.length != 1) return false;
-	if (!(events[0] instanceof ldk.Event_FundingGenerationReady)) return false;
+	const event = get_event(a.chan_man) as ldk.Event_FundingGenerationReady;
 
 	// (very) manually create a funding transaction
-	const witness_pos = events[0].output_script.length + 58;
+	const witness_pos = event.output_script.length + 58;
 	const funding_tx = new Uint8Array(witness_pos + 7);
 	funding_tx[0] = 2; // 4-byte tx version 2
 	funding_tx[4] = 0; funding_tx[5] = 1; // segwit magic bytes
@@ -180,23 +190,91 @@ tests.push(async () => {
 	funding_tx[43] = 0; // 1-byte input script length 0
 	funding_tx[44] = 0xff; funding_tx[45] = 0xff; funding_tx[46] = 0xff; funding_tx[47] = 0xff; // 4-byte nSequence
 	funding_tx[48] = 1; // one output
-	assign_u64(funding_tx, 49, events[0].channel_value_satoshis);
-	funding_tx[57] = events[0].output_script.length; // 1-byte output script length
-	funding_tx.set(events[0].output_script, 58);
+	assign_u64(funding_tx, 49, event.channel_value_satoshis);
+	funding_tx[57] = event.output_script.length; // 1-byte output script length
+	funding_tx.set(event.output_script, 58);
 	funding_tx[witness_pos] = 1; funding_tx[witness_pos + 1] = 1; funding_tx[witness_pos + 2] = 0xff; // one witness element of size 1 with contents 0xff
 	funding_tx[witness_pos + 3] = 0; funding_tx[witness_pos + 4] = 0; funding_tx[witness_pos + 5] = 0; funding_tx[witness_pos + 6] = 0; // lock time 0
 
-	const funding_res = chan_man_a.funding_transaction_generated(events[0].temporary_channel_id, events[0].counterparty_node_id, funding_tx);
+	const funding_res = a.chan_man.funding_transaction_generated(event.temporary_channel_id, event.counterparty_node_id, funding_tx);
 	if (!(funding_res instanceof ldk.Result_NoneAPIErrorZ_OK)) return false;
 
-	if (!exchange_messages(chan_man_a, chan_man_b)) return false;
+	if (!exchange_messages(a.chan_man, b.chan_man)) return false;
 
-	const tx_broadcasted: Uint8Array = (await peer_a[1]) as Uint8Array;
+	const tx_broadcasted: Uint8Array = (await a.tx_broadcasted);
 	if (!array_eq(tx_broadcasted, funding_tx)) return false;
 
 	return true;
 });
 
+tests.push(async () => {
+	const a = get_chanman();
+	const b = get_chanman();
+
+	const ignorer = ldk.IgnoringMessageHandler.constructor_new();
+	const pm_a = ldk.PeerManager.constructor_new(a.chan_man.as_ChannelMessageHandler(), ignorer.as_RoutingMessageHandler(), a.node_secret, a.node_secret, a.logger, ignorer.as_CustomMessageHandler());
+	const pm_b = ldk.PeerManager.constructor_new(b.chan_man.as_ChannelMessageHandler(), ignorer.as_RoutingMessageHandler(), b.node_secret, b.node_secret, b.logger, ignorer.as_CustomMessageHandler());
+
+	var sock_b: ldk.SocketDescriptor;
+	const sock_a = ldk.SocketDescriptor.new_impl({
+		send_data(data: Uint8Array, resume_read: boolean): number {
+			console.assert(pm_b.read_event(sock_b, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+			return data.length;
+		},
+		disconnect_socket(): void {
+			console.assert(false);
+		},
+		eq(other: ldk.SocketDescriptor): boolean {
+			return other.hash() == this.hash();
+		},
+		hash(): bigint {
+			return BigInt(1);
+		}
+	} as ldk.SocketDescriptorInterface);
+	sock_b = ldk.SocketDescriptor.new_impl({
+		send_data(data: Uint8Array, resume_read: boolean): number {
+			console.assert(pm_a.read_event(sock_a, data) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+			return data.length;
+		},
+		disconnect_socket(): void {
+			console.assert(false);
+		},
+		eq(other: ldk.SocketDescriptor): boolean {
+			return other.hash() == this.hash();
+		},
+		hash(): bigint {
+			return BigInt(2);
+		}
+	} as ldk.SocketDescriptorInterface);
+
+	const v4_netaddr = ldk.NetAddress.constructor_ipv4(Uint8Array.from([42,0,42,1]), 9735);
+	console.assert(pm_b.new_inbound_connection(sock_b, ldk.Option_NetAddressZ.constructor_some(v4_netaddr)) instanceof ldk.Result_NonePeerHandleErrorZ_OK);
+	const init_bytes = pm_a.new_outbound_connection(b.node_id, sock_a, ldk.Option_NetAddressZ.constructor_none());
+	if (!(init_bytes instanceof ldk.Result_CVec_u8ZPeerHandleErrorZ_OK)) return false;
+	console.assert(pm_b.read_event(sock_b, init_bytes.res) instanceof ldk.Result_boolPeerHandleErrorZ_OK);
+
+	console.assert(pm_a.get_peer_node_ids().length == 0);
+	console.assert(pm_b.get_peer_node_ids().length == 0);
+
+	pm_b.process_events();
+	pm_a.process_events();
+	pm_b.process_events();
+
+	console.assert(pm_a.get_peer_node_ids().length == 1);
+	console.assert(pm_b.get_peer_node_ids().length == 1);
+
+	const chan_create_res = a.chan_man.create_channel(b.node_id, BigInt(1000000), BigInt(400), BigInt(0), ldk.UserConfig.constructor_default());
+	if (!chan_create_res.is_ok()) return false;
+
+	pm_a.process_events();
+	pm_b.process_events();
+
+	const event = get_event(a.chan_man);
+	if (!(event instanceof ldk.Event_FundingGenerationReady)) return false;
+
+	return true;
+});
+
 async function run_tests(check_leaks: boolean) {
 	var test_runs = [];
 	for (const test of tests) {
diff --git a/typescript_strings.py b/typescript_strings.py
