X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-c-bindings%2Fdemo.cpp;h=196fd800ffa3a7c6e1283b02b40777fe7b0b040e;hb=e5e6dbe415f2a657ed6e6cf4d3167299b3a17d7f;hp=7c56dd769aae1eb4670bf66732c458e3e5bcab59;hpb=12da50613933d348dd5b924999af72708838190c;p=ldk-c-bindings diff --git a/lightning-c-bindings/demo.cpp b/lightning-c-bindings/demo.cpp index 7c56dd7..196fd80 100644 --- a/lightning-c-bindings/demo.cpp +++ b/lightning-c-bindings/demo.cpp @@ -20,6 +20,7 @@ extern "C" { #include #include #include +#include const uint8_t valid_node_announcement[] = { 0x94, 0xe4, 0xf5, 0x61, 0x41, 0x24, 0x7d, 0x90, 0x23, 0xa0, 0xc8, 0x34, 0x8c, 0xc4, 0xca, 0x51, @@ -226,6 +227,7 @@ public: assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr))); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting initial handshake completion..." << std::endl; while (true) { // Wait for the initial handshakes to complete... LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1); @@ -233,6 +235,7 @@ public: if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Initial handshake complete!" << std::endl; // Connect twice, which should auto-disconnect, and is a good test of our disconnect pipeline assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr))); @@ -242,6 +245,7 @@ public: PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2)); assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr))); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting new connection handshake..." << std::endl; while (true) { // Wait for the new connection handshake... LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1); @@ -249,8 +253,10 @@ public: if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "New connection handshake complete!" << std::endl; // Wait for all our sockets to disconnect (making sure we disconnect any new connections)... + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting peer disconnection..." << std::endl; while (true) { PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2)); // Wait for the peers to disconnect... @@ -259,6 +265,7 @@ public: if (peers_1->datalen == 0 && peers_2->datalen == 0) { break; } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Peers disconnected!" << std::endl; // Note that the above is somewhat race-y, as node 2 may still think its connected. // Thus, make sure any connections are disconnected on its end as well. PeerManager_disconnect_by_node_id(&net2, ChannelManager_get_our_node_id(&cm1)); @@ -266,6 +273,7 @@ public: // Finally make an actual connection and keep it this time assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr))); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting initial handshake completion..." << std::endl; while (true) { // Wait for the initial handshakes to complete... LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1); @@ -273,6 +281,7 @@ public: if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Initial handshake complete!" << std::endl; } void stop() { interrupt_socket_handling(node1_handler); @@ -354,6 +363,7 @@ public: auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen); assert(writelen > 0 && uint64_t(writelen) == con_res->contents.result->datalen); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting initial handshake completion..." << std::endl; while (true) { // Wait for the initial handshakes to complete... LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1); @@ -361,6 +371,7 @@ public: if (peers_1->datalen == 1 && peers_2->datalen ==1) { break; } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Initial handshake complete!" << std::endl; } void stop() { @@ -482,7 +493,7 @@ uint64_t get_chan_score(const void *this_arg, uint64_t scid, const LDKNodeId *sr return 42; } -struct LDKCResult_RouteLightningErrorZ custom_find_route(const void *this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *in_flights) { +struct LDKCResult_RouteLightningErrorZ custom_find_route(const void *this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *in_flights, LDKThirtyTwoBytes payment_id, LDKThirtyTwoBytes payment_hash) { const LDK::DefaultRouter *router = (LDK::DefaultRouter *)this_arg; assert(first_hops->datalen == 1); assert(ChannelDetails_get_is_usable(&first_hops->data[0])); @@ -553,6 +564,7 @@ int main() { LDKRouter panic_router = { .this_arg = NULL, .find_route = NULL, // Segfault if we ever try to find a route + .find_route_with_id = NULL, // Segfault if we ever try to find a route .free = NULL, }; @@ -643,6 +655,7 @@ int main() { LDKPublicKey chan_open_pk = ChannelCounterparty_get_node_id(&new_channels_counterparty); assert(!memcmp(chan_open_pk.compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33)); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting first channel..." << std::endl; while (true) { LDK::CVec_ChannelDetailsZ new_channels_2 = ChannelManager_list_channels(&cm2); if (new_channels_2->datalen == 1) { @@ -654,8 +667,10 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "First channel listed!" << std::endl; LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting FundingGenerationReady event..." << std::endl; while (true) { EventQueue queue; LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; @@ -676,14 +691,50 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received FundingGenerationReady event!" << std::endl; // We observe when the funding signed messages have been exchanged by // waiting for two monitors to be registered. assert(num_txs_broadcasted == 0); PeerManager_process_events(&net1); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting transaction broadcast..." << std::endl; while (num_txs_broadcasted != 1) { std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Transaction was broadcast!" << std::endl; + + // Note that the channel ID is the same as the channel txid reversed as the output index is 0 + uint8_t expected_chan_id[32]; + for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; } + + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting ChannelPending event..." << std::endl; + while (true) { + EventQueue queue; + LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; + ev1.process_pending_events(handler); + if (queue.events.size() == 1) { + assert(queue.events[0]->tag == LDKEvent_ChannelPending); + assert(!memcmp(queue.events[0]->channel_pending.channel_id.data, expected_chan_id, 32)); + break; + } + std::this_thread::yield(); + } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received ChannelPending event!" << std::endl; + + LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting ChannelPending event..." << std::endl; + while (true) { + EventQueue queue; + LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; + ev2.process_pending_events(handler); + if (queue.events.size() == 1) { + assert(queue.events[0]->tag == LDKEvent_ChannelPending); + assert(!memcmp(queue.events[0]->channel_pending.channel_id.data, expected_chan_id, 32)); + break; + } + std::this_thread::yield(); + } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received ChannelPending event!" << std::endl; LDK::Listen listener1 = ChannelManager_as_Listen(&cm1); listener1->block_connected(listener1->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1); @@ -712,11 +763,7 @@ int main() { PeerManager_process_events(&net1); PeerManager_process_events(&net2); - // Note that the channel ID is the same as the channel txid reversed as the output index is 0 - uint8_t expected_chan_id[32]; - for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; } - - LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting ChannelReady event..." << std::endl; while (true) { EventQueue queue; LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; @@ -728,7 +775,9 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received ChannelReady event!" << std::endl; + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting ChannelReady event..." << std::endl; while (true) { EventQueue queue; LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; @@ -740,9 +789,11 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received ChannelReady event!" << std::endl; // Now send funds from 1 to 2! uint64_t channel_scid; + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting usable channel..." << std::endl; while (true) { LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1); if (outbound_channels->datalen == 1) { @@ -768,6 +819,7 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Listed usable channel!" << std::endl; LDKCOption_u64Z min_value = { .tag = LDKCOption_u64Z_Some, @@ -793,8 +845,8 @@ 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, - 1, 2, LDKCVec_u64Z { .data = NULL, .datalen = 0 }, + }, Hints_clear(Invoice_route_hints(invoice->contents.result)), COption_u64Z_none(), + 0xffffffff, 1, 2, LDKCVec_u64Z { .data = NULL, .datalen = 0 }, Invoice_min_final_cltv_expiry_delta(invoice->contents.result)), 5000); random_bytes = entropy_source1.get_secure_random_bytes(); @@ -802,25 +854,30 @@ int main() { 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); + LDK::CVec_PathZ paths = Route_get_paths(route->contents.result); assert(paths->datalen == 1); - assert(paths->data[0].datalen == 1); - assert(!memcmp(RouteHop_get_pubkey(&paths->data[0].data[0]).compressed_form, + LDK::CVec_RouteHopZ hops = Path_get_hops(&paths->data[0]); + assert(hops->datalen == 1); + assert(!memcmp(RouteHop_get_pubkey(&hops->data[0]).compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33)); - assert(RouteHop_get_short_channel_id(&paths->data[0].data[0]) == channel_scid); + assert(RouteHop_get_short_channel_id(&hops->data[0]) == channel_scid); LDKThirtyTwoBytes payment_secret; memcpy(payment_secret.data, Invoice_payment_secret(invoice->contents.result), 32); - LDK::CResult_NonePaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, payment_secret, payment_hash); + LDK::CResult_NonePaymentSendFailureZ send_res = ChannelManager_send_payment_with_route(&cm1, + route->contents.result, payment_hash, RecipientOnionFields_secret_only(payment_secret), payment_hash); assert(send_res->result_ok); } mons_updated = 0; PeerManager_process_events(&net1); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting 4 updated monitors..." << std::endl; while (mons_updated != 4) { std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "4 monitors updated!" << std::endl; // Check that we received the payment! + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting PendingHTLCsForwardable event..." << std::endl; while (true) { EventQueue queue; LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; @@ -831,6 +888,7 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received PendingHTLCsForwardable event!" << std::endl; ChannelManager_process_pending_htlc_forwards(&cm2); PeerManager_process_events(&net2); @@ -859,14 +917,20 @@ int main() { } PeerManager_process_events(&net2); // Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages) + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting 5 updated monitors..." << std::endl; while (mons_updated != 5) { std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "5 monitors updated!" << std::endl; { EventQueue queue; LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL }; - while (queue.events.size() < 2) + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting PaymentSent and PaymentPathSuccessful events..." << std::endl; + while (queue.events.size() < 2) { ev1.process_pending_events(handler); + std::this_thread::yield(); + } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received PaymentSent and PaymentPathSuccessful events (presumably)!" << std::endl; assert(queue.events.size() == 2); assert(queue.events[0]->tag == LDKEvent_PaymentSent); assert(!memcmp(queue.events[0]->payment_sent.payment_preimage.data, payment_preimage.data, 32)); @@ -898,7 +962,8 @@ int main() { const LDK::DefaultRouter default_router_1 = DefaultRouter_new(&net_graph1, logger1, entropy_source1.get_secure_random_bytes(), std::move(scorer_mtx_trait1)); LDKRouter router1 = { .this_arg = (void*)&default_router_1, - .find_route = custom_find_route, + .find_route = NULL, // LDK currently doesn't use this, its just a default-impl + .find_route_with_id = custom_find_route, .free = NULL, }; @@ -983,13 +1048,16 @@ int main() { PeersConnection conn(cm1, cm2, net1, net2); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting usable channel..." << std::endl; while (true) { // Wait for the channels to be considered up once the reestablish messages are processed LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1); if (outbound_channels->datalen == 1) { break; } + std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Listed usable channel!" << std::endl; // Send another payment, this time via the retires path LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2, @@ -1007,6 +1075,7 @@ int main() { PeerManager_process_events(&net1); // Check that we received the payment! + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting PendingHTLCsForwardable event..." << std::endl; while (true) { EventQueue queue2; LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL }; @@ -1018,9 +1087,11 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received PendingHTLCsForwardable event!" << std::endl; ChannelManager_process_pending_htlc_forwards(&cm2); PeerManager_process_events(&net2); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting PaymentClaimable/PaymentClaimed event..." << std::endl; while (true) { EventQueue queue2; LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL }; @@ -1047,16 +1118,20 @@ int main() { } std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received PaymentClaimable/PaymentClaimed event!" << std::endl; EventQueue queue1; LDKEventHandler handler1 = { .this_arg = &queue1, .handle_event = handle_event, .free = NULL }; + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting PaymentSent and PaymentPathSuccessful events..." << std::endl; while (queue1.events.size() < 2) { PeerManager_process_events(&net2); PeerManager_process_events(&net1); LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1); ev1.process_pending_events(handler1); + std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received PaymentSent and PaymentPathSuccessful events (presumably)!" << std::endl; assert(queue1.events.size() == 2); assert(queue1.events[0]->tag == LDKEvent_PaymentSent); assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful); @@ -1066,9 +1141,11 @@ int main() { close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2)); assert(close_res->result_ok); PeerManager_process_events(&net1); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting 2 transaction broadcasts..." << std::endl; while (num_txs_broadcasted != 2) { std::this_thread::yield(); } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Broadcast 2 transactions!" << std::endl; LDK::CVec_ChannelDetailsZ chans_after_close1 = ChannelManager_list_channels(&cm1); assert(chans_after_close1->datalen == 0); LDK::CVec_ChannelDetailsZ chans_after_close2 = ChannelManager_list_channels(&cm2); @@ -1083,11 +1160,13 @@ int main() { }, LDKBlindedPath { .inner = NULL, .is_owned = true }) .result_ok); PeerManager_process_events(&net1); + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Awaiting onion message..." << std::endl; while (true) { std::this_thread::yield(); std::unique_lock lck(peer_2_custom_onion_messages.mtx); if (peer_2_custom_onion_messages.msgs.size() != 0) break; } + std::cout << __FILE__ << ":" << __LINE__ << " - " << "Received onion message!" << std::endl; conn.stop(); @@ -1101,5 +1180,5 @@ int main() { memset(&sk, 42, 32); LDKThirtyTwoBytes kdiv_params; memset(&kdiv_params, 43, 32); - LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params); + LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params, kdiv_params); }