X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fdemo.cpp;h=ac82b739811ed9af4618e69140b5c274c5c5ff83;hb=6becb3248617a383229c4d310d68308411fa6ede;hp=ec7a0d104e2a2dcb6ac5fd2ca70a40fc12d4f81a;hpb=4995ea79aac663f4474048a4059700dc67115dbe;p=ldk-c-bindings

diff --git a/lightning-c-bindings/demo.cpp b/lightning-c-bindings/demo.cpp
index ec7a0d1..ac82b73 100644
--- a/lightning-c-bindings/demo.cpp
+++ b/lightning-c-bindings/demo.cpp
@@ -167,7 +167,7 @@ LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_monitor(const void *this_
 			LDKBroadcasterInterface broadcaster = {
 				.broadcast_transaction = broadcast_tx,
 			};
-			LDK::CResult_NoneNoneZ res = ChannelMonitor_update_monitor(&mon.second, &update, &broadcaster, &fee_est, arg->logger);
+			LDK::CResult_NoneNoneZ res = ChannelMonitor_update_monitor(&mon.second, &update, &broadcaster, fee_est, arg->logger);
 			assert(res->result_ok);
 		}
 	}
@@ -176,12 +176,12 @@ LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_monitor(const void *this_
 	mons_updated += 1;
 	return CResult_NoneChannelMonitorUpdateErrZ_ok();
 }
-LDKCVec_MonitorEventZ monitors_pending_monitor_events(const void *this_arg) {
+LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ monitors_pending_monitor_events(const void *this_arg) {
 	NodeMonitors* arg = (NodeMonitors*) this_arg;
 	std::unique_lock<std::mutex> l(arg->mut);
 
 	if (arg->mons.size() == 0) {
-		return LDKCVec_MonitorEventZ {
+		return LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
 			.data = NULL,
 			.datalen = 0,
 		};
@@ -189,7 +189,17 @@ LDKCVec_MonitorEventZ monitors_pending_monitor_events(const void *this_arg) {
 		// We only ever actually have one channel per node, plus concatenating two
 		// Rust Vecs to each other from C++ will require a bit of effort.
 		assert(arg->mons.size() == 1);
-		return ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
+		LDK::CVec_MonitorEventZ events = ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
+		LDK::C2Tuple_OutPointScriptZ funding_info = ChannelMonitor_get_funding_txo(&arg->mons[0].second);
+		LDK::OutPoint outpoint = std::move(funding_info->a);
+		LDKPublicKey counterparty_node_id = ChannelMonitor_get_counterparty_node_id(&arg->mons[0].second);
+		LDK::C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ tuple = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(std::move(outpoint), std::move(events), std::move(counterparty_node_id));
+		auto vec = LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
+			.data = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)malloc(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)),
+			.datalen = 1,
+		};
+		vec.data[0] = std::move(tuple);
+		return vec;
 	}
 }
 
@@ -331,12 +341,9 @@ public:
 		t2 = std::thread(&sock_read_data_thread, pipefds_1_to_2[0], &sock2, &net2);
 
 		// Note that we have to bind the result to a C++ class to make sure it gets free'd
-		LDKCOption_NetAddressZ remote_network_address = {
-			.tag = LDKCOption_NetAddressZ_None,
-		};
-		LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1, remote_network_address);
+		LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1, COption_NetAddressZ_none());
 		assert(con_res->result_ok);
-		LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2, remote_network_address);
+		LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2, COption_NetAddressZ_none());
 		assert(con_res2->result_ok);
 
 		auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen);
@@ -424,7 +431,8 @@ LDKCVec_C2Tuple_PublicKeyTypeZZ create_custom_msg(const void* this_arg) {
 	return ret;
 }
 
-uint64_t get_chan_score(const void *this_arg, uint64_t scid, uint64_t htlc_amt, uint64_t chan_capacity, const LDKNodeId *src, const LDKNodeId *dst) {
+uint64_t get_chan_score(const void *this_arg, uint64_t scid, const LDKNodeId *src, const LDKNodeId *dst, LDKChannelUsage usage_in) {
+	LDK::ChannelUsage usage(std::move(usage_in));
 	return 42;
 }
 
@@ -481,8 +489,8 @@ int main() {
 		.free = NULL,
 	};
 
-	LDK::NetworkGraph net_graph1 = NetworkGraph_new(genesis_hash);
-	LDK::NetGraphMsgHandler graph_msg_handler1 = NetGraphMsgHandler_new(&net_graph1, COption_AccessZ_none(), logger1);
+	LDK::NetworkGraph net_graph1 = NetworkGraph_new(genesis_hash, logger1);
+	LDK::P2PGossipSync graph_msg_handler1 = P2PGossipSync_new(&net_graph1, COption_AccessZ_none(), logger1);
 	LDKSecretKey node_secret1;
 
 	LDKLogger logger2 {
@@ -501,8 +509,8 @@ int main() {
 		.free = NULL,
 	};
 
-	LDK::NetworkGraph net_graph2 = NetworkGraph_new(genesis_hash);
-	LDK::NetGraphMsgHandler graph_msg_handler2 = NetGraphMsgHandler_new(&net_graph2, COption_AccessZ_none(), logger2);
+	LDK::NetworkGraph net_graph2 = NetworkGraph_new(genesis_hash, logger2);
+	LDK::P2PGossipSync graph_msg_handler2 = P2PGossipSync_new(&net_graph2, COption_AccessZ_none(), logger2);
 	LDKSecretKey node_secret2;
 
 	LDK::CVec_u8Z cm1_ser = LDKCVec_u8Z {}; // ChannelManager 1 serialization at the end of the ser-des scope
@@ -523,7 +531,7 @@ int main() {
 		LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
 		assert(channels->datalen == 0);
 
-		LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
+		LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1));
 
 		LDK::IgnoringMessageHandler ignoring_handler1 = IgnoringMessageHandler_new();
 		LDK::CustomMessageHandler custom_msg_handler1 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler1);
@@ -548,14 +556,14 @@ int main() {
 		LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
 		ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
 		LDK::UserConfig config2 = UserConfig_default();
-		UserConfig_set_own_channel_config(&config2, std::move(handshake_config2));
+		UserConfig_set_channel_handshake_config(&config2, std::move(handshake_config2));
 
 		LDK::ChannelManager cm2 = ChannelManager_new(fee_est, mon2, broadcast, logger2, KeysManager_as_KeysInterface(&keys2), std::move(config2), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 
 		LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
 		assert(channels2->datalen == 0);
 
-		LDK::RoutingMessageHandler net_msgs2 = NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler2);
+		LDK::RoutingMessageHandler net_msgs2 = P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2);
 		LDK::CResult_ChannelAnnouncementDecodeErrorZ chan_ann = ChannelAnnouncement_read(LDKu8slice { .data = valid_node_announcement, .datalen = sizeof(valid_node_announcement) });
 		assert(chan_ann->result_ok);
 		LDK::CResult_boolLightningErrorZ ann_res = net_msgs2->handle_channel_announcement(net_msgs2->this_arg, chan_ann->contents.result);
@@ -608,7 +616,7 @@ int main() {
 				assert(!memcmp(queue.events[0]->funding_generation_ready.output_script.data, channel_open_block + 58 + 81, 34));
 				LDKTransaction funding_transaction { .data = const_cast<uint8_t*>(channel_open_block + 81), .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false };
 
-				LDK::CResult_NoneAPIErrorZ fund_res = ChannelManager_funding_transaction_generated(&cm1, &queue.events[0]->funding_generation_ready.temporary_channel_id.data, funding_transaction);
+				LDK::CResult_NoneAPIErrorZ fund_res = ChannelManager_funding_transaction_generated(&cm1, &queue.events[0]->funding_generation_ready.temporary_channel_id.data, queue.events[0]->funding_generation_ready.counterparty_node_id, funding_transaction);
 				assert(fund_res->result_ok);
 				break;
 			}
@@ -691,7 +699,7 @@ int main() {
 				.chars = (const uint8_t *)"Invoice Description",
 				.len =             strlen("Invoice Description"),
 				.chars_is_owned = false
-			});
+			}, 3600);
 		assert(invoice->result_ok);
 		LDKThirtyTwoBytes payment_hash;
 		memcpy(payment_hash.data, Invoice_payment_hash(invoice->contents.result), 32);
@@ -704,10 +712,13 @@ int main() {
 			LDK::RouteParameters route_params = RouteParameters_new(PaymentParameters_new(
 					ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
 						.inner = NULL, .is_owned = false
-					}, Invoice_route_hints(invoice->contents.result), COption_u64Z_none(), 0xffffffff),
+					}, Invoice_route_hints(invoice->contents.result), COption_u64Z_none(), 0xffffffff,
+					1, 2, LDKCVec_u64Z { .data = NULL, .datalen = 0 }),
 				5000, Invoice_min_final_cltv_expiry(invoice->contents.result));
 			random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
+
 			LDK::CResult_RouteLightningErrorZ route = find_route(ChannelManager_get_our_node_id(&cm1), &route_params, &net_graph2, &outbound_channels, logger1, &chan_scorer, &random_bytes.data);
+
 			assert(route->result_ok);
 			LDK::CVec_CVec_RouteHopZZ paths = Route_get_paths(route->contents.result);
 			assert(paths->datalen == 1);
@@ -754,9 +765,16 @@ int main() {
 			assert(queue.events[0]->payment_received.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 			assert(!memcmp(queue.events[0]->payment_received.purpose.invoice_payment.payment_secret.data,
 					Invoice_payment_secret(invoice->contents.result), 32));
-			assert(queue.events[0]->payment_received.amt == 5000);
+			assert(queue.events[0]->payment_received.amount_msat == 5000);
 			memcpy(payment_preimage.data, queue.events[0]->payment_received.purpose.invoice_payment.payment_preimage.data, 32);
-			assert(ChannelManager_claim_funds(&cm2, payment_preimage));
+			ChannelManager_claim_funds(&cm2, payment_preimage);
+
+			queue.events.clear();
+			ev2.process_pending_events(handler);
+			assert(queue.events.size() == 1);
+			assert(queue.events[0]->tag == LDKEvent_PaymentClaimed);
+			assert(!memcmp(queue.events[0]->payment_claimed.payment_hash.data, payment_hash.data, 32));
+			assert(queue.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 		}
 		PeerManager_process_events(&net2);
 		// Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages)
@@ -812,11 +830,11 @@ int main() {
 	// Attempt to close the channel...
 	uint8_t chan_id[32];
 	for (int i = 0; i < 32; i++) { chan_id[i] = channel_open_txid[31-i]; }
-	LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id);
+	LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
 	assert(!close_res->result_ok); // Note that we can't close while disconnected!
 
 	// Open a connection!
-	LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
+	LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1));
 	random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 
 	LDKPublicKey chan_2_node_id = ChannelManager_get_our_node_id(&cm2);
@@ -833,7 +851,7 @@ int main() {
 	};
 	LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
 
-	LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler2));
+	LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2));
 	CustomMsgQueue peer_2_custom_messages;
 	LDKCustomMessageHandler custom_msg_handler2 = {
 		.this_arg = &peer_2_custom_messages,
@@ -870,11 +888,11 @@ int main() {
 		.find_route = custom_find_route,
 		.free = NULL,
 	};
-	LDK::ProbabilisticScorer scorer = ProbabilisticScorer_new(ProbabilisticScoringParameters_default(), &net_graph1);
+	LDK::ProbabilisticScorer scorer = ProbabilisticScorer_new(ProbabilisticScoringParameters_default(), &net_graph1, logger1);
 	LDK::MultiThreadedLockableScore scorer_mtx = MultiThreadedLockableScore_new(ProbabilisticScorer_as_Score(&scorer));
 	EventQueue queue1;
 	LDKEventHandler handler1 = { .this_arg = &queue1, .handle_event = handle_event, .free = NULL };
-	LDK::InvoicePayer payer = InvoicePayer_new(ChannelManager_as_Payer(&cm1), sending_router, &scorer_mtx, logger1, handler1, RetryAttempts_new(0));
+	LDK::InvoicePayer payer = InvoicePayer_new(ChannelManager_as_Payer(&cm1), sending_router, &scorer_mtx, logger1, handler1, Retry_attempts(0));
 
 	LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
 		KeysManager_as_KeysInterface(&keys2),
@@ -883,7 +901,7 @@ int main() {
 			.chars = (const uint8_t *)"Invoice 2 Description",
 			.len =             strlen("Invoice 2 Description"),
 			.chars_is_owned = false
-		});
+		}, 3600);
 	assert(invoice_res2->result_ok);
 	const LDKInvoice *invoice2 = invoice_res2->contents.result;
 	LDK::CResult_PaymentIdPaymentErrorZ invoice_pay_res = InvoicePayer_pay_invoice(&payer, invoice2);
@@ -917,8 +935,16 @@ int main() {
 			assert(event_data->purpose.tag == LDKPaymentPurpose_InvoicePayment);
 			assert(!memcmp(event_data->purpose.invoice_payment.payment_secret.data,
 					Invoice_payment_secret(invoice2), 32));
-			assert(event_data->amt == 10000);
-			assert(ChannelManager_claim_funds(&cm2, event_data->purpose.invoice_payment.payment_preimage));
+			assert(event_data->amount_msat == 10000);
+			ChannelManager_claim_funds(&cm2, event_data->purpose.invoice_payment.payment_preimage);
+
+			queue2.events.clear();
+			ev2.process_pending_events(handler2);
+			assert(queue2.events.size() == 1);
+			assert(queue2.events[0]->tag == LDKEvent_PaymentClaimed);
+			assert(!memcmp(queue2.events[0]->payment_claimed.payment_hash.data, Invoice_payment_hash(invoice2), 32));
+			assert(queue2.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
+
 			break;
 		}
 		std::this_thread::yield();
@@ -938,7 +964,7 @@ int main() {
 
 	// Actually close the channel
 	num_txs_broadcasted = 0;
-	close_res = ChannelManager_close_channel(&cm1, &chan_id);
+	close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
 	assert(close_res->result_ok);
 	PeerManager_process_events(&net1);
 	while (num_txs_broadcasted != 2) {