.data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1 }
};
-void print_log(const void *this_arg, const char *record) {
- printf("%p - %s\n", this_arg, record);
+void print_log(const void *this_arg, const LDKRecord *record) {
+ LDK::Str mod = Record_get_module_path(record);
+ LDK::Str str = Record_get_args(record);
+ printf("%p - %.*s:%d - %.*s\n", this_arg, (int)mod->len, mod->chars, Record_get_line(record), (int)str->len, str->chars);
}
uint32_t get_fee(const void *this_arg, LDKConfirmationTarget target) {
LDKBroadcasterInterface broadcaster = {
.broadcast_transaction = broadcast_tx,
};
- LDK::CResult_NoneMonitorUpdateErrorZ 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);
}
}
struct EventQueue {
std::vector<LDK::Event> events;
};
-void handle_event(const void *this_arg, LDKEvent event) {
+void handle_event(const void *this_arg, const LDKEvent *event) {
EventQueue* arg = (EventQueue*) this_arg;
- arg->events.push_back(std::move(event));
+ arg->events.push_back(Event_clone(event));
}
#ifdef REAL_NET
if (peers_1->datalen == 0 && peers_2->datalen == 0) { break; }
std::this_thread::yield();
}
+ // 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), false);
// 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)));
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
- LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1);
+ 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);
+ 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);
};
#endif // !REAL_NET
+struct CustomMsgQueue {
+ std::vector<LDK::Type> msgs;
+};
+
+uint16_t custom_msg_type_id(const void *this_arg) {
+ return 8888;
+}
+LDKCVec_u8Z custom_msg_bytes(const void *this_arg) {
+ uint8_t *bytes = (uint8_t *) malloc(1024);
+ memset(bytes, 42, 1024);
+ return LDKCVec_u8Z {
+ .data = bytes, .datalen = 1024
+ };
+}
+LDKStr custom_msg_debug(const void *this_arg) {
+ return LDKStr {
+ .chars = NULL, .len = 0, .chars_is_owned = false
+ };
+}
+
+LDKCResult_COption_TypeZDecodeErrorZ read_custom_message(const void* this_arg, uint16_t type_id, LDKu8slice buf) {
+ assert(type_id == 8888);
+ assert(buf.datalen == 1024);
+ uint8_t cmp[1024];
+ memset(cmp, 42, 1024);
+ assert(!memcmp(cmp, buf.data, 1024));
+ return CResult_COption_TypeZDecodeErrorZ_ok(COption_TypeZ_some(LDKType {
+ .this_arg = NULL,
+ .type_id = custom_msg_type_id,
+ .debug_str = custom_msg_debug,
+ .free = NULL,
+ }));
+}
+
+LDKCResult_NoneLightningErrorZ handle_custom_message(const void* this_arg, struct LDKType msg, struct LDKPublicKey _sender_node_id) {
+ CustomMsgQueue* arg = (CustomMsgQueue*) this_arg;
+ arg->msgs.push_back(std::move(msg));
+ return CResult_NoneLightningErrorZ_ok();
+}
+LDKCVec_C2Tuple_PublicKeyTypeZZ never_send_custom_msgs(const void* this_arg) {
+ return LDKCVec_C2Tuple_PublicKeyTypeZZ {
+ .data = NULL, .datalen = 0
+ };
+}
+
+LDKCVec_C2Tuple_PublicKeyTypeZZ create_custom_msg(const void* this_arg) {
+ const LDKPublicKey *counterparty_node_id = (const LDKPublicKey *)this_arg;
+ LDKCVec_C2Tuple_PublicKeyTypeZZ ret = {
+ .data = ((LDKC2Tuple_PublicKeyTypeZ*)malloc(sizeof(LDKC2Tuple_PublicKeyTypeZ))),
+ .datalen = 1
+ };
+ ret.data[0].a = *counterparty_node_id;
+ ret.data[0].b = LDKType {
+ .this_arg = NULL,
+ .type_id = custom_msg_type_id,
+ .debug_str = custom_msg_debug,
+ .write = custom_msg_bytes,
+ .free = NULL,
+ };
+ 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) {
+ return 42;
+}
+
+struct CustomRouteFinderParams {
+ LDKLogger *logger;
+ LDKNetworkGraph *graph_ref;
+ LDKThirtyTwoBytes random_seed_bytes;
+};
+struct LDKCResult_RouteLightningErrorZ custom_find_route(const void *this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, const uint8_t (*payment_hash)[32], struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKScore *NONNULL_PTR scorer) {
+ const struct CustomRouteFinderParams *params = (struct CustomRouteFinderParams *)this_arg;
+ assert(first_hops->datalen == 1);
+ assert(ChannelDetails_get_is_usable(&first_hops->data[0]));
+ return find_route(payer, route_params, params->graph_ref, first_hops, *params->logger, scorer, ¶ms->random_seed_bytes.data);
+}
+
int main() {
uint8_t channel_open_header[80];
uint8_t header_1[80];
.free = NULL,
};
- LDK::NetGraphMsgHandler net_graph1 = NetGraphMsgHandler_new(genesis_hash, NULL, logger1);
+ LDK::NetworkGraph net_graph1 = NetworkGraph_new(genesis_hash);
+ LDK::NetGraphMsgHandler graph_msg_handler1 = NetGraphMsgHandler_new(&net_graph1, COption_AccessZ_none(), logger1);
LDKSecretKey node_secret1;
LDKLogger logger2 {
.free = NULL,
};
- LDK::NetGraphMsgHandler net_graph2 = NetGraphMsgHandler_new(genesis_hash, NULL, logger2);
+ LDK::NetworkGraph net_graph2 = NetworkGraph_new(genesis_hash);
+ LDK::NetGraphMsgHandler graph_msg_handler2 = NetGraphMsgHandler_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
memset(&node_seed, 0, 32);
LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
- node_secret1 = keys_source1->get_node_secret(keys_source1->this_arg);
+ LDK::CResult_SecretKeyNoneZ node_secret1_res = keys_source1->get_node_secret(keys_source1->this_arg, LDKRecipient_Node);
+ assert(node_secret1_res->result_ok);
+ node_secret1 = *node_secret1_res->contents.result;
LDK::ChannelManager cm1 = ChannelManager_new(fee_est, mon1, broadcast, logger1, KeysManager_as_KeysInterface(&keys1), UserConfig_default(), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
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(&net_graph1));
+ LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
+
+ LDK::IgnoringMessageHandler ignoring_handler1 = IgnoringMessageHandler_new();
+ LDK::CustomMessageHandler custom_msg_handler1 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler1);
random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
- LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1);
+ LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
// Demo getting a channel key and check that its returning real pubkeys:
LDK::Sign chan_signer1 = keys_source1->get_channel_signer(keys_source1->this_arg, false, 42);
memset(&node_seed, 1, 32);
LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
LDK::KeysInterface keys_source2 = KeysManager_as_KeysInterface(&keys2);
- node_secret2 = keys_source2->get_node_secret(keys_source2->this_arg);
+ LDK::CResult_SecretKeyNoneZ node_secret2_res = keys_source2->get_node_secret(keys_source2->this_arg, LDKRecipient_Node);
+ assert(node_secret2_res->result_ok);
+ node_secret2 = *node_secret2_res->contents.result;
LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
assert(channels2->datalen == 0);
- LDK::RoutingMessageHandler net_msgs2 = NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph2);
+ LDK::RoutingMessageHandler net_msgs2 = NetGraphMsgHandler_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);
LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2));
+ LDK::IgnoringMessageHandler ignoring_handler2 = IgnoringMessageHandler_new();
+ LDK::CustomMessageHandler custom_msg_handler2 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler2);
+
random_bytes = keys_source2->get_secure_random_bytes(keys_source2->this_arg);
- LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2);
+ LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
// Open a connection!
PeersConnection conn(cm1, cm2, net1, net2);
// Note that we have to bind the result to a C++ class to make sure it gets free'd
- LDK::CResult_NoneAPIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, 42, UserConfig_default());
+ LDK::CResult__u832APIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, 42, UserConfig_default());
assert(res->result_ok);
PeerManager_process_events(&net1);
{
LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
- LDK::LockedNetworkGraph graph_2_locked = NetGraphMsgHandler_read_locked_graph(&net_graph2);
- LDK::NetworkGraph graph_2_ref = LockedNetworkGraph_graph(&graph_2_locked);
- LDK::CResult_RouteLightningErrorZ route = get_route(ChannelManager_get_our_node_id(&cm1), &graph_2_ref, ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
- .inner = NULL, .is_owned = false
- }, &outbound_channels, Invoice_route_hints(invoice->contents.result),
- 5000, Invoice_min_final_cltv_expiry(invoice->contents.result), logger1);
+ LDK::Score chan_scorer = LDKScore {
+ .this_arg = NULL, .channel_penalty_msat = get_chan_score, .free = NULL
+ };
+ 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),
+ 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);
assert(!memcmp(RouteHop_get_pubkey(&paths->data[0].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);
- LDK::CResult_NonePaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, Invoice_payment_secret(invoice->contents.result));
+ LDKThirtyTwoBytes payment_secret;
+ memcpy(payment_secret.data, Invoice_payment_secret(invoice->contents.result), 32);
+ LDK::CResult_PaymentIdPaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, payment_secret);
assert(send_res->result_ok);
}
}
// Check that we received the payment!
- LDKEventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
+ LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
while (true) {
EventQueue queue;
LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
- ev2.process_pending_events(ev2.this_arg, handler);
+ ev2.process_pending_events(handler);
if (queue.events.size() == 1) {
assert(queue.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
break;
{
EventQueue queue;
LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
- ev2.process_pending_events(ev2.this_arg, handler);
+ ev2.process_pending_events(handler);
assert(queue.events.size() == 1);
assert(queue.events[0]->tag == LDKEvent_PaymentReceived);
assert(!memcmp(queue.events[0]->payment_received.payment_hash.data, payment_hash.data, 32));
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).data, 32));
+ Invoice_payment_secret(invoice->contents.result), 32));
assert(queue.events[0]->payment_received.amt == 5000);
memcpy(payment_preimage.data, queue.events[0]->payment_received.purpose.invoice_payment.payment_preimage.data, 32);
assert(ChannelManager_claim_funds(&cm2, payment_preimage));
{
EventQueue queue;
LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
- ev1.process_pending_events(ev1.this_arg, handler);
- assert(queue.events.size() == 1);
+ while (queue.events.size() < 2)
+ ev1.process_pending_events(ev1.this_arg, handler);
+ 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));
+ assert(queue.events[1]->tag == LDKEvent_PaymentPathSuccessful);
+ assert(!memcmp(queue.events[1]->payment_path_successful.payment_hash.data, payment_hash.data, 32));
}
conn.stop();
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(&net_graph1));
+ LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
- LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1);
- LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph2));
+ LDKPublicKey chan_2_node_id = ChannelManager_get_our_node_id(&cm2);
+ LDKCustomMessageHandler custom_msg_handler1 = {
+ .this_arg = &chan_2_node_id,
+ .handle_custom_message = NULL, // We only create custom messages, not handle them
+ .get_and_clear_pending_msg = create_custom_msg,
+ .CustomMessageReader = LDKCustomMessageReader {
+ .this_arg = NULL,
+ .read = read_custom_message,
+ .free = NULL,
+ },
+ .free = NULL,
+ };
+ 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));
+ CustomMsgQueue peer_2_custom_messages;
+ LDKCustomMessageHandler custom_msg_handler2 = {
+ .this_arg = &peer_2_custom_messages,
+ .handle_custom_message = handle_custom_message,
+ .get_and_clear_pending_msg = never_send_custom_msgs,
+ .CustomMessageReader = LDKCustomMessageReader {
+ .this_arg = NULL,
+ .read = read_custom_message,
+ .free = NULL,
+ },
+ .free = NULL,
+ };
random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
- LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2);
+ LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
PeersConnection conn(cm1, cm2, net1, net2);
}
}
+ // Send another payment, this time via the InvoicePayer
+ struct CustomRouteFinderParams router_params = {
+ .logger = &logger1,
+ .graph_ref = &net_graph1,
+ .random_seed_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg),
+ };
+ LDKRouter sending_router = {
+ .this_arg = &router_params,
+ .find_route = custom_find_route,
+ .free = NULL,
+ };
+ LDK::ProbabilisticScorer scorer = ProbabilisticScorer_new(ProbabilisticScoringParameters_default(), &net_graph1);
+ 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::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
+ KeysManager_as_KeysInterface(&keys2),
+ LDKCurrency_Bitcoin, COption_u64Z_some(10000),
+ LDKStr {
+ .chars = (const uint8_t *)"Invoice 2 Description",
+ .len = strlen("Invoice 2 Description"),
+ .chars_is_owned = false
+ });
+ assert(invoice_res2->result_ok);
+ const LDKInvoice *invoice2 = invoice_res2->contents.result;
+ LDK::CResult_PaymentIdPaymentErrorZ invoice_pay_res = InvoicePayer_pay_invoice(&payer, invoice2);
+ assert(invoice_pay_res->result_ok);
+ PeerManager_process_events(&net1);
+
+ // Check that we received the payment!
+ while (true) {
+ EventQueue queue2;
+ LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
+ LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
+ ev2.process_pending_events(handler2);
+ if (queue2.events.size() == 1) {
+ assert(queue2.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
+ break;
+ }
+ std::this_thread::yield();
+ }
+ ChannelManager_process_pending_htlc_forwards(&cm2);
+ PeerManager_process_events(&net2);
+
+ while (true) {
+ EventQueue queue2;
+ LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
+ LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
+ ev2.process_pending_events(handler2);
+ if (queue2.events.size() == 1) {
+ assert(queue2.events[0]->tag == LDKEvent_PaymentReceived);
+ const struct LDKEvent_LDKPaymentReceived_Body *event_data = &queue2.events[0]->payment_received;
+ assert(!memcmp(event_data->payment_hash.data, Invoice_payment_hash(invoice2), 32));
+ 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));
+ break;
+ }
+ std::this_thread::yield();
+ }
+
+ while (queue1.events.size() < 2) {
+ PeerManager_process_events(&net2);
+ PeerManager_process_events(&net1);
+
+ LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
+ LDK::EventHandler evh1 = InvoicePayer_as_EventHandler(&payer);
+ ev1.process_pending_events(std::move(evh1));
+ }
+ assert(queue1.events.size() == 2);
+ assert(queue1.events[0]->tag == LDKEvent_PaymentSent);
+ assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful);
+
// Actually close the channel
num_txs_broadcasted = 0;
close_res = ChannelManager_close_channel(&cm1, &chan_id);
conn.stop();
+ assert(peer_2_custom_messages.msgs.size() != 0);
+
// Few extra random tests:
LDKSecretKey sk;
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, sk, random_bytes, 42, kdiv_params);
}