_ Git - ldk-c-bindings/blob - lightning-c-bindings/demo.cpp

   1 extern "C" {
   2 #include <lightning.h>
   3
   4 #ifdef REAL_NET
   5 #include <ldk_net.h>
   6 #endif
   7 }
   8 #include "include/lightningpp.hpp"
   9
  10 #include <assert.h>
  11 #include <stdio.h>
  12 #include <sys/socket.h>
  13 #include <netinet/in.h>
  14 #include <arpa/inet.h>
  15 #include <unistd.h>
  16
  17 #include <atomic>
  18 #include <chrono>
  19 #include <functional>
  20 #include <thread>
  21 #include <mutex>
  22 #include <vector>
  23
  24 const uint8_t valid_node_announcement[] = {
  25         0x94, 0xe4, 0xf5, 0x61, 0x41, 0x24, 0x7d, 0x90, 0x23, 0xa0, 0xc8, 0x34, 0x8c, 0xc4, 0xca, 0x51,
  26         0xd8, 0x17, 0x59, 0xff, 0x7d, 0xac, 0x8c, 0x9b, 0x63, 0x29, 0x1c, 0xe6, 0x12, 0x12, 0x93, 0xbd,
  27         0x66, 0x4d, 0x6b, 0x9c, 0xfb, 0x35, 0xda, 0x16, 0x06, 0x3d, 0xf0, 0x8f, 0x8a, 0x39, 0x99, 0xa2,
  28         0xf2, 0x5d, 0x12, 0x0f, 0x2b, 0x42, 0x1b, 0x8b, 0x9a, 0xfe, 0x33, 0x0c, 0xeb, 0x33, 0x5e, 0x52,
  29         0xee, 0x99, 0xa1, 0x07, 0x06, 0xed, 0xf8, 0x48, 0x7a, 0xc6, 0xe5, 0xf5, 0x5e, 0x01, 0x3a, 0x41,
  30         0x2f, 0x18, 0x94, 0x8a, 0x3b, 0x0a, 0x52, 0x3f, 0xbf, 0x61, 0xa9, 0xc5, 0x4f, 0x70, 0xee, 0xb8,
  31         0x79, 0x23, 0xbb, 0x1a, 0x44, 0x7d, 0x91, 0xe6, 0x2a, 0xbc, 0xa1, 0x07, 0xbc, 0x65, 0x3b, 0x02,
  32         0xd9, 0x1d, 0xb2, 0xf2, 0x3a, 0xcb, 0x75, 0x79, 0xc6, 0x66, 0xd8, 0xc1, 0x71, 0x29, 0xdf, 0x04,
  33         0x60, 0xf4, 0xbf, 0x07, 0x7b, 0xb9, 0xc2, 0x11, 0x94, 0x6a, 0x28, 0xc2, 0xdd, 0xd8, 0x7b, 0x44,
  34         0x8f, 0x08, 0xe3, 0xc8, 0xd8, 0xf4, 0x81, 0xb0, 0x9f, 0x94, 0xcb, 0xc8, 0xc1, 0x3c, 0xc2, 0x6e,
  35         0x31, 0x26, 0xfc, 0x33, 0x16, 0x3b, 0xe0, 0xde, 0xa1, 0x16, 0x21, 0x9f, 0x89, 0xdd, 0x97, 0xa4,
  36         0x41, 0xf2, 0x9f, 0x19, 0xb1, 0xae, 0x82, 0xf7, 0x85, 0x9a, 0xb7, 0x8f, 0xb7, 0x52, 0x7a, 0x72,
  37         0xf1, 0x5e, 0x89, 0xe1, 0x8a, 0xcd, 0x40, 0xb5, 0x8e, 0xc3, 0xca, 0x42, 0x76, 0xa3, 0x6e, 0x1b,
  38         0xf4, 0x87, 0x35, 0x30, 0x58, 0x43, 0x04, 0xd9, 0x2c, 0x50, 0x54, 0x55, 0x47, 0x6f, 0x70, 0x9b,
  39         0x42, 0x1f, 0x91, 0xfc, 0xa1, 0xdb, 0x72, 0x53, 0x96, 0xc8, 0xe5, 0xcd, 0x0e, 0xcb, 0xa0, 0xfe,
  40         0x6b, 0x08, 0x77, 0x48, 0xb7, 0xad, 0x4a, 0x69, 0x7c, 0xdc, 0xd8, 0x04, 0x28, 0x35, 0x9b, 0x73,
  41         0x00, 0x00, 0x43, 0x49, 0x7f, 0xd7, 0xf8, 0x26, 0x95, 0x71, 0x08, 0xf4, 0xa3, 0x0f, 0xd9, 0xce,
  42         0xc3, 0xae, 0xba, 0x79, 0x97, 0x20, 0x84, 0xe9, 0x0e, 0xad, 0x01, 0xea, 0x33, 0x09, 0x00, 0x00,
  43         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x5b, 0xe5, 0xe9, 0x47, 0x82,
  44         0x09, 0x67, 0x4a, 0x96, 0xe6, 0x0f, 0x1f, 0x03, 0x7f, 0x61, 0x76, 0x54, 0x0f, 0xd0, 0x01, 0xfa,
  45         0x1d, 0x64, 0x69, 0x47, 0x70, 0xc5, 0x6a, 0x77, 0x09, 0xc4, 0x2c, 0x03, 0x5c, 0x4e, 0x0d, 0xec,
  46         0x72, 0x15, 0xe2, 0x68, 0x33, 0x93, 0x87, 0x30, 0xe5, 0xe5, 0x05, 0xaa, 0x62, 0x50, 0x4d, 0xa8,
  47         0x5b, 0xa5, 0x71, 0x06, 0xa4, 0x6b, 0x5a, 0x24, 0x04, 0xfc, 0x9d, 0x8e, 0x02, 0xba, 0x72, 0xa6,
  48         0xe8, 0xba, 0x53, 0xe8, 0xb9, 0x71, 0xad, 0x0c, 0x98, 0x23, 0x96, 0x8a, 0xef, 0x4d, 0x78, 0xce,
  49         0x8a, 0xf2, 0x55, 0xab, 0x43, 0xdf, 0xf8, 0x30, 0x03, 0xc9, 0x02, 0xfb, 0x8d, 0x02, 0x16, 0x34,
  50         0x5b, 0xf8, 0x31, 0x16, 0x4a, 0x03, 0x75, 0x8e, 0xae, 0xa5, 0xe8, 0xb6, 0x6f, 0xee, 0x2b, 0xe7,
  51         0x71, 0x0b, 0x8f, 0x19, 0x0e, 0xe8, 0x80, 0x24, 0x90, 0x32, 0xa2, 0x9e, 0xd6, 0x6e
  52 };
  53
  54 // A simple block containing only one transaction (which is the channel-open transaction for the
  55 // channel we'll create). This was originally created by printing additional data in a simple
  56 // rust-lightning unit test.
  57 const uint8_t channel_open_block[] = {
  58         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  59         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  60         0x00, 0x00, 0x00, 0x00, 0xa2, 0x47, 0xd2, 0xf8, 0xd4, 0xe0, 0x6a, 0x3f, 0xf9, 0x7a, 0x9a, 0x34,
  61         0xbb, 0xa9, 0x96, 0xde, 0x63, 0x84, 0x5a, 0xce, 0xcf, 0x98, 0xb8, 0xbb, 0x75, 0x4c, 0x4f, 0x7d,
  62         0xee, 0x4c, 0xa9, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  63         0x01, // transaction count
  64         0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  65         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  66         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  67         0x01, 0x40, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0xd1, 0xd9, 0x13, 0xa9,
  68         0x76, 0x09, 0x05, 0xa3, 0x4d, 0x13, 0x5b, 0x69, 0xaa, 0xe7, 0x79, 0x71, 0xb9, 0x75, 0xa1, 0xd0,
  69         0x77, 0xcb, 0xa2, 0xf6, 0x6a, 0x25, 0x37, 0x3a, 0xaf, 0xdc, 0x11, 0x09, 0x01, 0x00, 0x00, 0x00,
  70         0x00, 0x00
  71 };
  72
  73 // The first transaction in the block is header (80 bytes) + transaction count (1 byte) into the block data.
  74 const uint8_t channel_open_txid[] = {
  75         0x02, 0xe0, 0x50, 0x05, 0x33, 0xd3, 0x29, 0x66, 0x0c, 0xb2, 0xcb, 0x1e, 0x7a, 0x4a, 0xc7, 0xc7,
  76         0x8b, 0x02, 0x46, 0x7e, 0x30, 0x2c, 0xe6, 0x19, 0xce, 0x43, 0x3e, 0xdf, 0x43, 0x65, 0xae, 0xf9,
  77 };
  78
  79 // Two blocks built on top of channel_open_block:
  80 const uint8_t block_1[81] = {
  81         0x01, 0x00, 0x00, 0x00, 0x0c, 0x7a, 0xc2, 0xdc, 0x08, 0xaf, 0x40, 0x7d, 0x58, 0x81, 0x9b, 0x44,
  82         0xc7, 0xe0, 0x0f, 0x78, 0xc0, 0xd1, 0x01, 0xa2, 0x03, 0x16, 0x4a, 0x8d, 0x92, 0x66, 0x4e, 0xaf,
  83         0x7f, 0xfc, 0x6e, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  84         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  85         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  86         0x00, // transaction count
  87 };
  88 const uint8_t block_2[81] = {
  89         0x01, 0x00, 0x00, 0x00, 0x36, 0x0b, 0xf5, 0x46, 0x4a, 0xc7, 0x26, 0x4c, 0x4b, 0x36, 0xa6, 0x9d,
  90         0x0e, 0xf0, 0x14, 0xfb, 0x8a, 0xcb, 0x20, 0x84, 0x18, 0xf3, 0xaa, 0x77, 0x32, 0x2d, 0xf7, 0x48,
  91         0x62, 0x92, 0xb1, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  92         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  93         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  94         0x00, // transaction count
  95 };
  96
  97 const LDKThirtyTwoBytes genesis_hash = { // We don't care particularly if this is "right"
  98         .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 }
  99 };
 100
 101 void print_log(const void *this_arg, const LDKRecord *record) {
 102         LDK::Str mod = Record_get_module_path(record);
 103         LDK::Str str = Record_get_args(record);
 104         printf("%p - %.*s:%d - %.*s\n", this_arg, (int)mod->len, mod->chars, Record_get_line(record), (int)str->len, str->chars);
 105 }
 106
 107 uint32_t get_fee(const void *this_arg, LDKConfirmationTarget target) {
 108         if (target == LDKConfirmationTarget_Background) {
 109                 return 253;
 110         } else {
 111                 return 507;
 112         }
 113         // Note that we don't call _free() on target, but that's OK, its unitary
 114 }
 115 // We use the same fee estimator globally:
 116 const LDKFeeEstimator fee_est {
 117         .this_arg = NULL,
 118         .get_est_sat_per_1000_weight = get_fee,
 119         .free = NULL,
 120 };
 121
 122 static std::atomic_int num_txs_broadcasted(0);
 123 void broadcast_tx(const void *this_arg, LDKTransaction tx) {
 124         num_txs_broadcasted += 1;
 125         //TODO
 126         Transaction_free(tx);
 127 }
 128
 129 struct NodeMonitors {
 130         std::mutex mut;
 131         std::vector<std::pair<LDK::OutPoint, LDK::ChannelMonitor>> mons;
 132         LDKLogger* logger;
 133
 134         void ConnectBlock(const uint8_t (*header)[80], uint32_t height, LDKCVec_C2Tuple_usizeTransactionZZ tx_data, LDKBroadcasterInterface broadcast, LDKFeeEstimator fee_est) {
 135                 std::unique_lock<std::mutex> l(mut);
 136                 for (auto& mon : mons) {
 137                         LDK::CVec_TransactionOutputsZ res = ChannelMonitor_block_connected(&mon.second, header, tx_data, height, broadcast, fee_est, *logger);
 138                 }
 139         }
 140 };
 141
 142 LDKCResult_NoneChannelMonitorUpdateErrZ add_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, LDKChannelMonitor monitor_arg) {
 143         // First bind the args to C++ objects so they auto-free
 144         LDK::ChannelMonitor mon(std::move(monitor_arg));
 145         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 146
 147         NodeMonitors* arg = (NodeMonitors*) this_arg;
 148         std::unique_lock<std::mutex> l(arg->mut);
 149
 150         arg->mons.push_back(std::make_pair(std::move(funding_txo), std::move(mon)));
 151         return CResult_NoneChannelMonitorUpdateErrZ_ok();
 152 }
 153 static std::atomic_int mons_updated(0);
 154 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, LDKChannelMonitorUpdate monitor_arg) {
 155         // First bind the args to C++ objects so they auto-free
 156         LDK::ChannelMonitorUpdate update(std::move(monitor_arg));
 157         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 158
 159         NodeMonitors* arg = (NodeMonitors*) this_arg;
 160         std::unique_lock<std::mutex> l(arg->mut);
 161
 162         bool updated = false;
 163         for (auto& mon : arg->mons) {
 164                 if (OutPoint_get_index(&mon.first) == OutPoint_get_index(&funding_txo) &&
 165                                 !memcmp(OutPoint_get_txid(&mon.first), OutPoint_get_txid(&funding_txo), 32)) {
 166                         updated = true;
 167                         LDKBroadcasterInterface broadcaster = {
 168                                 .broadcast_transaction = broadcast_tx,
 169                         };
 170                         LDK::CResult_NoneNoneZ res = ChannelMonitor_update_monitor(&mon.second, &update, &broadcaster, &fee_est, arg->logger);
 171                         assert(res->result_ok);
 172                 }
 173         }
 174         assert(updated);
 175
 176         mons_updated += 1;
 177         return CResult_NoneChannelMonitorUpdateErrZ_ok();
 178 }
 179 LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ monitors_pending_monitor_events(const void *this_arg) {
 180         NodeMonitors* arg = (NodeMonitors*) this_arg;
 181         std::unique_lock<std::mutex> l(arg->mut);
 182
 183         if (arg->mons.size() == 0) {
 184                 return LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ {
 185                         .data = NULL,
 186                         .datalen = 0,
 187                 };
 188         } else {
 189                 // We only ever actually have one channel per node, plus concatenating two
 190                 // Rust Vecs to each other from C++ will require a bit of effort.
 191                 assert(arg->mons.size() == 1);
 192                 LDK::CVec_MonitorEventZ events = ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
 193                 LDK::C2Tuple_OutPointScriptZ funding_info = ChannelMonitor_get_funding_txo(&arg->mons[0].second);
 194                 LDK::OutPoint outpoint = std::move(funding_info->a);
 195                 LDK::C2Tuple_OutPointCVec_MonitorEventZZ pair = C2Tuple_OutPointCVec_MonitorEventZZ_new(std::move(outpoint), std::move(events));
 196                 auto vec = LDKCVec_C2Tuple_OutPointCVec_MonitorEventZZZ {
 197                         .data = (LDKC2Tuple_OutPointCVec_MonitorEventZZ*)malloc(sizeof(LDKC2Tuple_OutPointCVec_MonitorEventZZ)),
 198                         .datalen = 1,
 199                 };
 200                 vec.data[0] = std::move(pair);
 201                 return vec;
 202         }
 203 }
 204
 205 struct EventQueue {
 206         std::vector<LDK::Event> events;
 207 };
 208 void handle_event(const void *this_arg, const LDKEvent *event) {
 209         EventQueue* arg = (EventQueue*) this_arg;
 210         arg->events.push_back(Event_clone(event));
 211 }
 212
 213 #ifdef REAL_NET
 214 class PeersConnection {
 215         void* node1_handler;
 216         void* node2_handler;
 217
 218 public:
 219         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 220                 node1_handler = init_socket_handling(&net1);
 221                 node2_handler = init_socket_handling(&net2);
 222
 223                 struct sockaddr_in listen_addr;
 224                 listen_addr.sin_family = AF_INET;
 225                 listen_addr.sin_addr.s_addr = htonl((127 << 8*3) | 1);
 226                 listen_addr.sin_port = htons(10042);
 227                 assert(!socket_bind(node2_handler, (sockaddr*)&listen_addr, sizeof(listen_addr)));
 228
 229                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 230
 231                 while (true) {
 232                         // Wait for the initial handshakes to complete...
 233                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 234                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 235                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 236                         std::this_thread::yield();
 237                 }
 238
 239                 // Connect twice, which should auto-disconnect, and is a good test of our disconnect pipeline
 240                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 241                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 242
 243                 // Then disconnect the "main" connection, while another connection is being made.
 244                 PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2), false);
 245                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 246
 247                 // Wait for all our sockets to disconnect (making sure we disconnect any new connections)...
 248                 while (true) {
 249                         PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2), false);
 250                         // Wait for the peers to disconnect...
 251                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 252                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 253                         if (peers_1->datalen == 0 && peers_2->datalen == 0) { break; }
 254                         std::this_thread::yield();
 255                 }
 256                 // Note that the above is somewhat race-y, as node 2 may still think its connected.
 257                 // Thus, make sure any connections are disconnected on its end as well.
 258                 PeerManager_disconnect_by_node_id(&net2, ChannelManager_get_our_node_id(&cm1), false);
 259
 260                 // Finally make an actual connection and keep it this time
 261                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 262
 263                 while (true) {
 264                         // Wait for the initial handshakes to complete...
 265                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 266                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 267                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 268                         std::this_thread::yield();
 269                 }
 270         }
 271         void stop() {
 272                 interrupt_socket_handling(node1_handler);
 273                 interrupt_socket_handling(node2_handler);
 274         }
 275 };
 276
 277 #else // REAL_NET
 278
 279 uintptr_t sock_send_data(void *this_arg, LDKu8slice data, bool resume_read) {
 280         return write((int)((long)this_arg), data.data, data.datalen);
 281 }
 282 void sock_disconnect_socket(void *this_arg) {
 283         close((int)((long)this_arg));
 284 }
 285 bool sock_eq(const void *this_arg, const LDKSocketDescriptor *other_arg) {
 286         return this_arg == other_arg->this_arg;
 287 }
 288 uint64_t sock_hash(const void *this_arg) {
 289         return (uint64_t)this_arg;
 290 }
 291 void sock_read_data_thread(int rdfd, LDKSocketDescriptor *peer_descriptor, LDKPeerManager *pm) {
 292         unsigned char buf[1024];
 293         LDKu8slice data;
 294         data.data = buf;
 295         ssize_t readlen = 0;
 296         while ((readlen = read(rdfd, buf, 1024)) > 0) {
 297                 data.datalen = readlen;
 298                 LDK::CResult_boolPeerHandleErrorZ res = PeerManager_read_event(&*pm, peer_descriptor, data);
 299                 if (!res->result_ok) {
 300                         peer_descriptor->disconnect_socket(peer_descriptor->this_arg);
 301                         return;
 302                 }
 303                 PeerManager_process_events(pm);
 304         }
 305         PeerManager_socket_disconnected(&*pm, peer_descriptor);
 306 }
 307
 308 class PeersConnection {
 309         int pipefds_1_to_2[2];
 310         int pipefds_2_to_1[2];
 311         std::thread t1, t2;
 312         LDKSocketDescriptor sock1, sock2;
 313
 314 public:
 315         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 316                 assert(!pipe(pipefds_1_to_2));
 317                 assert(!pipe(pipefds_2_to_1));
 318
 319                 sock1 = LDKSocketDescriptor {
 320                         .this_arg = (void*)(long)pipefds_1_to_2[1],
 321                         .send_data = sock_send_data,
 322                         .disconnect_socket = sock_disconnect_socket,
 323                         .eq = sock_eq,
 324                         .hash = sock_hash,
 325                         .cloned = NULL,
 326                         .free = NULL,
 327                 };
 328
 329                 sock2 = LDKSocketDescriptor {
 330                         .this_arg = (void*)(long)pipefds_2_to_1[1],
 331                         .send_data = sock_send_data,
 332                         .disconnect_socket = sock_disconnect_socket,
 333                         .eq = sock_eq,
 334                         .hash = sock_hash,
 335                         .cloned = NULL,
 336                         .free = NULL,
 337                 };
 338
 339                 t1 = std::thread(&sock_read_data_thread, pipefds_2_to_1[0], &sock1, &net1);
 340                 t2 = std::thread(&sock_read_data_thread, pipefds_1_to_2[0], &sock2, &net2);
 341
 342                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 343                 LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1, COption_NetAddressZ_none());
 344                 assert(con_res->result_ok);
 345                 LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2, COption_NetAddressZ_none());
 346                 assert(con_res2->result_ok);
 347
 348                 auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen);
 349                 assert(writelen > 0 && uint64_t(writelen) == con_res->contents.result->datalen);
 350
 351                 while (true) {
 352                         // Wait for the initial handshakes to complete...
 353                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 354                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 355                         if (peers_1->datalen == 1 && peers_2->datalen ==1) { break; }
 356                         std::this_thread::yield();
 357                 }
 358         }
 359
 360         void stop() {
 361                 close(pipefds_1_to_2[0]);
 362                 close(pipefds_2_to_1[0]);
 363                 close(pipefds_1_to_2[1]);
 364                 close(pipefds_2_to_1[1]);
 365                 t1.join();
 366                 t2.join();
 367         }
 368 };
 369 #endif // !REAL_NET
 370
 371 struct CustomMsgQueue {
 372         std::vector<LDK::Type> msgs;
 373 };
 374
 375 uint16_t custom_msg_type_id(const void *this_arg) {
 376         return 8888;
 377 }
 378 LDKCVec_u8Z custom_msg_bytes(const void *this_arg) {
 379         uint8_t *bytes = (uint8_t *) malloc(1024);
 380         memset(bytes, 42, 1024);
 381         return LDKCVec_u8Z {
 382                 .data = bytes, .datalen = 1024
 383         };
 384 }
 385 LDKStr custom_msg_debug(const void *this_arg) {
 386         return LDKStr {
 387                 .chars = NULL, .len = 0, .chars_is_owned = false
 388         };
 389 }
 390
 391 LDKCResult_COption_TypeZDecodeErrorZ read_custom_message(const void* this_arg, uint16_t type_id, LDKu8slice buf) {
 392         assert(type_id == 8888);
 393         assert(buf.datalen == 1024);
 394         uint8_t cmp[1024];
 395         memset(cmp, 42, 1024);
 396         assert(!memcmp(cmp, buf.data, 1024));
 397         return CResult_COption_TypeZDecodeErrorZ_ok(COption_TypeZ_some(LDKType {
 398                 .this_arg = NULL,
 399                 .type_id = custom_msg_type_id,
 400                 .debug_str = custom_msg_debug,
 401                 .free = NULL,
 402         }));
 403 }
 404
 405 LDKCResult_NoneLightningErrorZ handle_custom_message(const void* this_arg, struct LDKType msg, struct LDKPublicKey _sender_node_id) {
 406         CustomMsgQueue* arg = (CustomMsgQueue*) this_arg;
 407         arg->msgs.push_back(std::move(msg));
 408         return CResult_NoneLightningErrorZ_ok();
 409 }
 410 LDKCVec_C2Tuple_PublicKeyTypeZZ never_send_custom_msgs(const void* this_arg) {
 411         return LDKCVec_C2Tuple_PublicKeyTypeZZ {
 412                 .data = NULL, .datalen = 0
 413         };
 414 }
 415
 416 LDKCVec_C2Tuple_PublicKeyTypeZZ create_custom_msg(const void* this_arg) {
 417         const LDKPublicKey *counterparty_node_id = (const LDKPublicKey *)this_arg;
 418         LDKCVec_C2Tuple_PublicKeyTypeZZ ret = {
 419                 .data = ((LDKC2Tuple_PublicKeyTypeZ*)malloc(sizeof(LDKC2Tuple_PublicKeyTypeZ))),
 420                 .datalen = 1
 421         };
 422         ret.data[0].a = *counterparty_node_id;
 423         ret.data[0].b = LDKType {
 424                 .this_arg = NULL,
 425                 .type_id = custom_msg_type_id,
 426                 .debug_str = custom_msg_debug,
 427                 .write = custom_msg_bytes,
 428                 .free = NULL,
 429         };
 430         return ret;
 431 }
 432
 433 uint64_t get_chan_score(const void *this_arg, uint64_t scid, const LDKNodeId *src, const LDKNodeId *dst, LDKChannelUsage usage_in) {
 434         LDK::ChannelUsage usage(std::move(usage_in));
 435         return 42;
 436 }
 437
 438 struct CustomRouteFinderParams {
 439         LDKLogger *logger;
 440         LDKNetworkGraph *graph_ref;
 441         LDKThirtyTwoBytes random_seed_bytes;
 442 };
 443 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) {
 444         const struct CustomRouteFinderParams *params = (struct CustomRouteFinderParams *)this_arg;
 445         assert(first_hops->datalen == 1);
 446         assert(ChannelDetails_get_is_usable(&first_hops->data[0]));
 447         LDK::ReadOnlyNetworkGraph graph_lock = NetworkGraph_read_only(params->graph_ref);
 448         return find_route(payer, route_params, &graph_lock, first_hops, *params->logger, scorer, &params->random_seed_bytes.data);
 449 }
 450
 451 int main() {
 452         uint8_t channel_open_header[80];
 453         uint8_t header_1[80];
 454         uint8_t header_2[80];
 455         memcpy(channel_open_header, channel_open_block, 80);
 456         memcpy(header_1, block_1, 80);
 457         memcpy(header_2, block_2, 80);
 458
 459         LDKPublicKey null_pk;
 460         memset(&null_pk, 0, sizeof(null_pk));
 461
 462         LDKThirtyTwoBytes random_bytes;
 463         LDKThirtyTwoBytes chain_tip;
 464         memset(&chain_tip, 0, sizeof(chain_tip)); // channel_open_header's prev_blockhash is all-0s
 465
 466         LDKNetwork network = LDKNetwork_Testnet;
 467
 468         // Trait implementations:
 469         LDKBroadcasterInterface broadcast {
 470                 .this_arg = NULL,
 471                 .broadcast_transaction = broadcast_tx,
 472                 .free = NULL,
 473         };
 474
 475         // Instantiate classes for the nodes that don't get reloaded on a ser-des reload
 476         LDKLogger logger1 {
 477                 .this_arg = (void*)1,
 478                 .log = print_log,
 479                 .free = NULL,
 480         };
 481
 482         NodeMonitors mons1;
 483         mons1.logger = &logger1;
 484         LDKWatch mon1 {
 485                 .this_arg = &mons1,
 486                 .watch_channel = add_channel_monitor,
 487                 .update_channel = update_channel_monitor,
 488                 .release_pending_monitor_events = monitors_pending_monitor_events,
 489                 .free = NULL,
 490         };
 491
 492         LDK::NetworkGraph net_graph1 = NetworkGraph_new(genesis_hash, logger1);
 493         LDK::P2PGossipSync graph_msg_handler1 = P2PGossipSync_new(&net_graph1, COption_AccessZ_none(), logger1);
 494         LDKSecretKey node_secret1;
 495
 496         LDKLogger logger2 {
 497                 .this_arg = (void*)2,
 498                 .log = print_log,
 499                 .free = NULL,
 500         };
 501
 502         NodeMonitors mons2;
 503         mons2.logger = &logger2;
 504         LDKWatch mon2 {
 505                 .this_arg = &mons2,
 506                 .watch_channel = add_channel_monitor,
 507                 .update_channel = update_channel_monitor,
 508                 .release_pending_monitor_events = monitors_pending_monitor_events,
 509                 .free = NULL,
 510         };
 511
 512         LDK::NetworkGraph net_graph2 = NetworkGraph_new(genesis_hash, logger2);
 513         LDK::P2PGossipSync graph_msg_handler2 = P2PGossipSync_new(&net_graph2, COption_AccessZ_none(), logger2);
 514         LDKSecretKey node_secret2;
 515
 516         LDK::CVec_u8Z cm1_ser = LDKCVec_u8Z {}; // ChannelManager 1 serialization at the end of the ser-des scope
 517         LDK::CVec_u8Z cm2_ser = LDKCVec_u8Z {}; // ChannelManager 2 serialization at the end of the ser-des scope
 518
 519         { // Scope for the ser-des reload
 520                 // Instantiate classes for node 1:
 521                 uint8_t node_seed[32];
 522                 memset(&node_seed, 0, 32);
 523                 LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
 524                 LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 525                 LDK::CResult_SecretKeyNoneZ node_secret1_res = keys_source1->get_node_secret(keys_source1->this_arg, LDKRecipient_Node);
 526                 assert(node_secret1_res->result_ok);
 527                 node_secret1 = *node_secret1_res->contents.result;
 528
 529                 LDK::ChannelManager cm1 = ChannelManager_new(fee_est, mon1, broadcast, logger1, KeysManager_as_KeysInterface(&keys1), UserConfig_default(), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 530
 531                 LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
 532                 assert(channels->datalen == 0);
 533
 534                 LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1));
 535
 536                 LDK::IgnoringMessageHandler ignoring_handler1 = IgnoringMessageHandler_new();
 537                 LDK::CustomMessageHandler custom_msg_handler1 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler1);
 538
 539                 random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 540                 LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
 541
 542                 // Demo getting a channel key and check that its returning real pubkeys:
 543                 LDK::Sign chan_signer1 = keys_source1->get_channel_signer(keys_source1->this_arg, false, 42);
 544                 chan_signer1->BaseSign.set_pubkeys(&chan_signer1->BaseSign); // Make sure pubkeys is defined
 545                 LDKPublicKey payment_point = ChannelPublicKeys_get_payment_point(&chan_signer1->BaseSign.pubkeys);
 546                 assert(memcmp(&payment_point, &null_pk, sizeof(null_pk)));
 547
 548                 // Instantiate classes for node 2:
 549                 memset(&node_seed, 1, 32);
 550                 LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
 551                 LDK::KeysInterface keys_source2 = KeysManager_as_KeysInterface(&keys2);
 552                 LDK::CResult_SecretKeyNoneZ node_secret2_res = keys_source2->get_node_secret(keys_source2->this_arg, LDKRecipient_Node);
 553                 assert(node_secret2_res->result_ok);
 554                 node_secret2 = *node_secret2_res->contents.result;
 555
 556                 LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
 557                 ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
 558                 LDK::UserConfig config2 = UserConfig_default();
 559                 UserConfig_set_own_channel_config(&config2, std::move(handshake_config2));
 560
 561                 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)));
 562
 563                 LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
 564                 assert(channels2->datalen == 0);
 565
 566                 LDK::RoutingMessageHandler net_msgs2 = P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2);
 567                 LDK::CResult_ChannelAnnouncementDecodeErrorZ chan_ann = ChannelAnnouncement_read(LDKu8slice { .data = valid_node_announcement, .datalen = sizeof(valid_node_announcement) });
 568                 assert(chan_ann->result_ok);
 569                 LDK::CResult_boolLightningErrorZ ann_res = net_msgs2->handle_channel_announcement(net_msgs2->this_arg, chan_ann->contents.result);
 570                 assert(ann_res->result_ok);
 571
 572                 LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2));
 573
 574                 LDK::IgnoringMessageHandler ignoring_handler2 = IgnoringMessageHandler_new();
 575                 LDK::CustomMessageHandler custom_msg_handler2 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler2);
 576
 577                 random_bytes = keys_source2->get_secure_random_bytes(keys_source2->this_arg);
 578                 LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
 579
 580                 // Open a connection!
 581                 PeersConnection conn(cm1, cm2, net1, net2);
 582
 583                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 584                 LDK::CResult__u832APIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, 42, UserConfig_default());
 585                 assert(res->result_ok);
 586                 PeerManager_process_events(&net1);
 587
 588                 LDK::CVec_ChannelDetailsZ new_channels = ChannelManager_list_channels(&cm1);
 589                 assert(new_channels->datalen == 1);
 590                 LDK::ChannelCounterparty new_channels_counterparty = ChannelDetails_get_counterparty(&new_channels->data[0]);
 591                 LDKPublicKey chan_open_pk = ChannelCounterparty_get_node_id(&new_channels_counterparty);
 592                 assert(!memcmp(chan_open_pk.compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 593
 594                 while (true) {
 595                         LDK::CVec_ChannelDetailsZ new_channels_2 = ChannelManager_list_channels(&cm2);
 596                         if (new_channels_2->datalen == 1) {
 597                                 // Sample getting our counterparty's init features (which used to be hard to do without a memory leak):
 598                                 LDK::ChannelCounterparty new_channels_2_counterparty = ChannelDetails_get_counterparty(&new_channels_2->data[0]);
 599                                 const LDK::InitFeatures init_feats = ChannelCounterparty_get_features(&new_channels_2_counterparty);
 600                                 assert(init_feats->inner != NULL);
 601                                 break;
 602                         }
 603                         std::this_thread::yield();
 604                 }
 605
 606                 LDKEventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 607                 while (true) {
 608                         EventQueue queue;
 609                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 610                         ev1.process_pending_events(ev1.this_arg, handler);
 611                         if (queue.events.size() == 1) {
 612                                 assert(queue.events[0]->tag == LDKEvent_FundingGenerationReady);
 613                                 assert(queue.events[0]->funding_generation_ready.user_channel_id == 42);
 614                                 assert(queue.events[0]->funding_generation_ready.channel_value_satoshis == 40000);
 615                                 assert(queue.events[0]->funding_generation_ready.output_script.datalen == 34);
 616                                 assert(!memcmp(queue.events[0]->funding_generation_ready.output_script.data, channel_open_block + 58 + 81, 34));
 617                                 LDKTransaction funding_transaction { .data = const_cast<uint8_t*>(channel_open_block + 81), .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false };
 618
 619                                 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);
 620                                 assert(fund_res->result_ok);
 621                                 break;
 622                         }
 623                         std::this_thread::yield();
 624                 }
 625
 626                 // We observe when the funding signed messages have been exchanged by
 627                 // waiting for two monitors to be registered.
 628                 assert(num_txs_broadcasted == 0);
 629                 PeerManager_process_events(&net1);
 630                 while (num_txs_broadcasted != 1) {
 631                         std::this_thread::yield();
 632                 }
 633
 634                 LDK::Listen listener1 = ChannelManager_as_Listen(&cm1);
 635                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 636
 637                 LDK::Listen listener2 = ChannelManager_as_Listen(&cm2);
 638                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 639
 640                 LDKCVec_C2Tuple_usizeTransactionZZ txdata { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 641                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 642                 mons1.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 643
 644                 txdata = LDKCVec_C2Tuple_usizeTransactionZZ { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 645                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 646                 mons2.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 647
 648                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 649                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 650                 mons1.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 651                 mons2.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 652
 653                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 654                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 655                 mons1.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 656                 mons2.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 657
 658                 PeerManager_process_events(&net1);
 659                 PeerManager_process_events(&net2);
 660
 661                 // Now send funds from 1 to 2!
 662                 uint64_t channel_scid;
 663                 while (true) {
 664                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 665                         if (outbound_channels->datalen == 1) {
 666                                 const LDKChannelDetails *channel = &outbound_channels->data[0];
 667                                 LDK::ChannelCounterparty counterparty = ChannelDetails_get_counterparty(channel);
 668                                 // Note that the channel ID is the same as the channel txid reversed as the output index is 0
 669                                 uint8_t expected_chan_id[32];
 670                                 for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; }
 671                                 assert(!memcmp(ChannelDetails_get_channel_id(channel), expected_chan_id, 32));
 672                                 assert(!memcmp(
 673                                         ChannelCounterparty_get_node_id(&counterparty).compressed_form,
 674                                         ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 675                                 assert(ChannelDetails_get_channel_value_satoshis(channel) == 40000);
 676                                 // We opened the channel with 1000 push_msat:
 677                                 assert(ChannelDetails_get_outbound_capacity_msat(channel) ==
 678                                         40000*1000 - 1000 - 1000 * ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty));
 679                                 int64_t inbound_capacity = ((int64_t)1000) - ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty);
 680                                 if (inbound_capacity < 0) inbound_capacity = 0;
 681                                 assert(ChannelDetails_get_inbound_capacity_msat(channel) == (uint64_t)inbound_capacity);
 682                                 assert(ChannelDetails_get_is_usable(channel));
 683                                 LDK::COption_u64Z scid_opt = ChannelDetails_get_short_channel_id(channel);
 684                                 assert(scid_opt->some);
 685                                 channel_scid = scid_opt->some;
 686                                 break;
 687                         }
 688                         std::this_thread::yield();
 689                 }
 690
 691                 LDKCOption_u64Z min_value = {
 692                         .tag = LDKCOption_u64Z_Some,
 693                         .some = 5000,
 694                 };
 695                 LDK::CResult_InvoiceSignOrCreationErrorZ invoice = create_invoice_from_channelmanager(&cm2,
 696                         KeysManager_as_KeysInterface(&keys2),
 697                         LDKCurrency_Bitcoin, min_value,
 698                         LDKStr {
 699                                 .chars = (const uint8_t *)"Invoice Description",
 700                                 .len =             strlen("Invoice Description"),
 701                                 .chars_is_owned = false
 702                         }, 3600);
 703                 assert(invoice->result_ok);
 704                 LDKThirtyTwoBytes payment_hash;
 705                 memcpy(payment_hash.data, Invoice_payment_hash(invoice->contents.result), 32);
 706
 707                 {
 708                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 709                         LDK::Score chan_scorer = LDKScore {
 710                                 .this_arg = NULL, .channel_penalty_msat = get_chan_score, .free = NULL
 711                         };
 712                         LDK::RouteParameters route_params = RouteParameters_new(PaymentParameters_new(
 713                                         ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
 714                                                 .inner = NULL, .is_owned = false
 715                                         }, Invoice_route_hints(invoice->contents.result), COption_u64Z_none(), 0xffffffff),
 716                                 5000, Invoice_min_final_cltv_expiry(invoice->contents.result));
 717                         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 718                         LDK::ReadOnlyNetworkGraph graph_lock = NetworkGraph_read_only(&net_graph2);
 719
 720                         LDK::CResult_RouteLightningErrorZ route = find_route(ChannelManager_get_our_node_id(&cm1), &route_params, &graph_lock, &outbound_channels, logger1, &chan_scorer, &random_bytes.data);
 721
 722                         assert(route->result_ok);
 723                         LDK::CVec_CVec_RouteHopZZ paths = Route_get_paths(route->contents.result);
 724                         assert(paths->datalen == 1);
 725                         assert(paths->data[0].datalen == 1);
 726                         assert(!memcmp(RouteHop_get_pubkey(&paths->data[0].data[0]).compressed_form,
 727                                 ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 728                         assert(RouteHop_get_short_channel_id(&paths->data[0].data[0]) == channel_scid);
 729                         LDKThirtyTwoBytes payment_secret;
 730                         memcpy(payment_secret.data, Invoice_payment_secret(invoice->contents.result), 32);
 731                         LDK::CResult_PaymentIdPaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, payment_secret);
 732                         assert(send_res->result_ok);
 733                 }
 734
 735                 mons_updated = 0;
 736                 PeerManager_process_events(&net1);
 737                 while (mons_updated != 4) {
 738                         std::this_thread::yield();
 739                 }
 740
 741                 // Check that we received the payment!
 742                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 743                 while (true) {
 744                         EventQueue queue;
 745                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 746                         ev2.process_pending_events(handler);
 747                         if (queue.events.size() == 1) {
 748                                 assert(queue.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
 749                                 break;
 750                         }
 751                         std::this_thread::yield();
 752                 }
 753                 ChannelManager_process_pending_htlc_forwards(&cm2);
 754                 PeerManager_process_events(&net2);
 755
 756                 mons_updated = 0;
 757                 LDKThirtyTwoBytes payment_preimage;
 758                 {
 759                         EventQueue queue;
 760                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 761                         ev2.process_pending_events(handler);
 762                         assert(queue.events.size() == 1);
 763                         assert(queue.events[0]->tag == LDKEvent_PaymentReceived);
 764                         assert(!memcmp(queue.events[0]->payment_received.payment_hash.data, payment_hash.data, 32));
 765                         assert(queue.events[0]->payment_received.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 766                         assert(!memcmp(queue.events[0]->payment_received.purpose.invoice_payment.payment_secret.data,
 767                                         Invoice_payment_secret(invoice->contents.result), 32));
 768                         assert(queue.events[0]->payment_received.amount_msat == 5000);
 769                         memcpy(payment_preimage.data, queue.events[0]->payment_received.purpose.invoice_payment.payment_preimage.data, 32);
 770                         ChannelManager_claim_funds(&cm2, payment_preimage);
 771
 772                         queue.events.clear();
 773                         ev2.process_pending_events(handler);
 774                         assert(queue.events.size() == 1);
 775                         assert(queue.events[0]->tag == LDKEvent_PaymentClaimed);
 776                         assert(!memcmp(queue.events[0]->payment_claimed.payment_hash.data, payment_hash.data, 32));
 777                         assert(queue.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 778                 }
 779                 PeerManager_process_events(&net2);
 780                 // Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages)
 781                 while (mons_updated != 5) {
 782                         std::this_thread::yield();
 783                 }
 784                 {
 785                         EventQueue queue;
 786                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 787                         while (queue.events.size() < 2)
 788                                 ev1.process_pending_events(ev1.this_arg, handler);
 789                         assert(queue.events.size() == 2);
 790                         assert(queue.events[0]->tag == LDKEvent_PaymentSent);
 791                         assert(!memcmp(queue.events[0]->payment_sent.payment_preimage.data, payment_preimage.data, 32));
 792                         assert(queue.events[1]->tag == LDKEvent_PaymentPathSuccessful);
 793                         assert(!memcmp(queue.events[1]->payment_path_successful.payment_hash.data, payment_hash.data, 32));
 794                 }
 795
 796                 conn.stop();
 797
 798                 cm1_ser = ChannelManager_write(&cm1);
 799                 cm2_ser = ChannelManager_write(&cm2);
 800         }
 801
 802         LDK::CVec_ChannelMonitorZ mons_list1 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 803         assert(mons1.mons.size() == 1);
 804         mons_list1->data[0] = *& std::get<1>(mons1.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 805         mons_list1->data[0].is_owned = false; // XXX: God this sucks
 806         uint8_t node_seed[32];
 807         memset(&node_seed, 0, 32);
 808         LDK::KeysManager keys1 = KeysManager_new(&node_seed, 1, 0);
 809         LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 810
 811         LDK::ChannelManagerReadArgs cm1_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys1), fee_est, mon1, broadcast, logger1, UserConfig_default(), std::move(mons_list1));
 812         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm1_read =
 813                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm1_ser->data, .datalen = cm1_ser -> datalen}, std::move(cm1_args));
 814         assert(cm1_read->result_ok);
 815         LDK::ChannelManager cm1(std::move(cm1_read->contents.result->b));
 816
 817         LDK::CVec_ChannelMonitorZ mons_list2 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 818         assert(mons2.mons.size() == 1);
 819         mons_list2->data[0] = *& std::get<1>(mons2.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 820         mons_list2->data[0].is_owned = false; // XXX: God this sucks
 821         memset(&node_seed, 1, 32);
 822         LDK::KeysManager keys2 = KeysManager_new(&node_seed, 1, 0);
 823
 824         LDK::ChannelManagerReadArgs cm2_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys2), fee_est, mon2, broadcast, logger2, UserConfig_default(), std::move(mons_list2));
 825         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm2_read =
 826                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm2_ser->data, .datalen = cm2_ser -> datalen}, std::move(cm2_args));
 827         assert(cm2_read->result_ok);
 828         LDK::ChannelManager cm2(std::move(cm2_read->contents.result->b));
 829
 830         // Attempt to close the channel...
 831         uint8_t chan_id[32];
 832         for (int i = 0; i < 32; i++) { chan_id[i] = channel_open_txid[31-i]; }
 833         LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
 834         assert(!close_res->result_ok); // Note that we can't close while disconnected!
 835
 836         // Open a connection!
 837         LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1));
 838         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 839
 840         LDKPublicKey chan_2_node_id = ChannelManager_get_our_node_id(&cm2);
 841         LDKCustomMessageHandler custom_msg_handler1 = {
 842                 .this_arg = &chan_2_node_id,
 843                 .handle_custom_message = NULL, // We only create custom messages, not handle them
 844                 .get_and_clear_pending_msg = create_custom_msg,
 845                 .CustomMessageReader = LDKCustomMessageReader {
 846                         .this_arg = NULL,
 847                         .read = read_custom_message,
 848                         .free = NULL,
 849                 },
 850                 .free = NULL,
 851         };
 852         LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
 853
 854         LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2));
 855         CustomMsgQueue peer_2_custom_messages;
 856         LDKCustomMessageHandler custom_msg_handler2 = {
 857                 .this_arg = &peer_2_custom_messages,
 858                 .handle_custom_message = handle_custom_message,
 859                 .get_and_clear_pending_msg = never_send_custom_msgs,
 860                 .CustomMessageReader = LDKCustomMessageReader {
 861                         .this_arg = NULL,
 862                         .read = read_custom_message,
 863                         .free = NULL,
 864                 },
 865                 .free = NULL,
 866         };
 867         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 868         LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
 869
 870         PeersConnection conn(cm1, cm2, net1, net2);
 871
 872         while (true) {
 873                 // Wait for the channels to be considered up once the reestablish messages are processed
 874                 LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 875                 if (outbound_channels->datalen == 1) {
 876                         break;
 877                 }
 878         }
 879
 880         // Send another payment, this time via the InvoicePayer
 881         struct CustomRouteFinderParams router_params = {
 882                 .logger = &logger1,
 883                 .graph_ref = &net_graph1,
 884                 .random_seed_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg),
 885         };
 886         LDKRouter sending_router = {
 887                 .this_arg = &router_params,
 888                 .find_route = custom_find_route,
 889                 .free = NULL,
 890         };
 891         LDK::ProbabilisticScorer scorer = ProbabilisticScorer_new(ProbabilisticScoringParameters_default(), &net_graph1, logger1);
 892         LDK::MultiThreadedLockableScore scorer_mtx = MultiThreadedLockableScore_new(ProbabilisticScorer_as_Score(&scorer));
 893         EventQueue queue1;
 894         LDKEventHandler handler1 = { .this_arg = &queue1, .handle_event = handle_event, .free = NULL };
 895         LDK::InvoicePayer payer = InvoicePayer_new(ChannelManager_as_Payer(&cm1), sending_router, &scorer_mtx, logger1, handler1, Retry_attempts(0));
 896
 897         LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
 898                 KeysManager_as_KeysInterface(&keys2),
 899                 LDKCurrency_Bitcoin, COption_u64Z_some(10000),
 900                 LDKStr {
 901                         .chars = (const uint8_t *)"Invoice 2 Description",
 902                         .len =             strlen("Invoice 2 Description"),
 903                         .chars_is_owned = false
 904                 }, 3600);
 905         assert(invoice_res2->result_ok);
 906         const LDKInvoice *invoice2 = invoice_res2->contents.result;
 907         LDK::CResult_PaymentIdPaymentErrorZ invoice_pay_res = InvoicePayer_pay_invoice(&payer, invoice2);
 908         assert(invoice_pay_res->result_ok);
 909         PeerManager_process_events(&net1);
 910
 911         // Check that we received the payment!
 912         while (true) {
 913                 EventQueue queue2;
 914                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
 915                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 916                 ev2.process_pending_events(handler2);
 917                 if (queue2.events.size() == 1) {
 918                         assert(queue2.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
 919                         break;
 920                 }
 921                 std::this_thread::yield();
 922         }
 923         ChannelManager_process_pending_htlc_forwards(&cm2);
 924         PeerManager_process_events(&net2);
 925
 926         while (true) {
 927                 EventQueue queue2;
 928                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
 929                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 930                 ev2.process_pending_events(handler2);
 931                 if (queue2.events.size() == 1) {
 932                         assert(queue2.events[0]->tag == LDKEvent_PaymentReceived);
 933                         const struct LDKEvent_LDKPaymentReceived_Body *event_data = &queue2.events[0]->payment_received;
 934                         assert(!memcmp(event_data->payment_hash.data, Invoice_payment_hash(invoice2), 32));
 935                         assert(event_data->purpose.tag == LDKPaymentPurpose_InvoicePayment);
 936                         assert(!memcmp(event_data->purpose.invoice_payment.payment_secret.data,
 937                                         Invoice_payment_secret(invoice2), 32));
 938                         assert(event_data->amount_msat == 10000);
 939                         ChannelManager_claim_funds(&cm2, event_data->purpose.invoice_payment.payment_preimage);
 940
 941                         queue2.events.clear();
 942                         ev2.process_pending_events(handler2);
 943                         assert(queue2.events.size() == 1);
 944                         assert(queue2.events[0]->tag == LDKEvent_PaymentClaimed);
 945                         assert(!memcmp(queue2.events[0]->payment_claimed.payment_hash.data, Invoice_payment_hash(invoice2), 32));
 946                         assert(queue2.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 947
 948                         break;
 949                 }
 950                 std::this_thread::yield();
 951         }
 952
 953         while (queue1.events.size() < 2) {
 954                 PeerManager_process_events(&net2);
 955                 PeerManager_process_events(&net1);
 956
 957                 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 958                 LDK::EventHandler evh1 = InvoicePayer_as_EventHandler(&payer);
 959                 ev1.process_pending_events(std::move(evh1));
 960         }
 961         assert(queue1.events.size() == 2);
 962         assert(queue1.events[0]->tag == LDKEvent_PaymentSent);
 963         assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful);
 964
 965         // Actually close the channel
 966         num_txs_broadcasted = 0;
 967         close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
 968         assert(close_res->result_ok);
 969         PeerManager_process_events(&net1);
 970         while (num_txs_broadcasted != 2) {
 971                 std::this_thread::yield();
 972         }
 973         LDK::CVec_ChannelDetailsZ chans_after_close1 = ChannelManager_list_channels(&cm1);
 974         assert(chans_after_close1->datalen == 0);
 975         LDK::CVec_ChannelDetailsZ chans_after_close2 = ChannelManager_list_channels(&cm2);
 976         assert(chans_after_close2->datalen == 0);
 977
 978         conn.stop();
 979
 980         assert(peer_2_custom_messages.msgs.size() != 0);
 981
 982         // Few extra random tests:
 983         LDKSecretKey sk;
 984         memset(&sk, 42, 32);
 985         LDKThirtyTwoBytes kdiv_params;
 986         memset(&kdiv_params, 43, 32);
 987         LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params);
 988 }