_ 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_MonitorEventZ 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_MonitorEventZ {
 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                 return ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
 193         }
 194 }
 195
 196 struct EventQueue {
 197         std::vector<LDK::Event> events;
 198 };
 199 void handle_event(const void *this_arg, const LDKEvent *event) {
 200         EventQueue* arg = (EventQueue*) this_arg;
 201         arg->events.push_back(Event_clone(event));
 202 }
 203
 204 #ifdef REAL_NET
 205 class PeersConnection {
 206         void* node1_handler;
 207         void* node2_handler;
 208
 209 public:
 210         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 211                 node1_handler = init_socket_handling(&net1);
 212                 node2_handler = init_socket_handling(&net2);
 213
 214                 struct sockaddr_in listen_addr;
 215                 listen_addr.sin_family = AF_INET;
 216                 listen_addr.sin_addr.s_addr = htonl((127 << 8*3) | 1);
 217                 listen_addr.sin_port = htons(10042);
 218                 assert(!socket_bind(node2_handler, (sockaddr*)&listen_addr, sizeof(listen_addr)));
 219
 220                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 221
 222                 while (true) {
 223                         // Wait for the initial handshakes to complete...
 224                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 225                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 226                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 227                         std::this_thread::yield();
 228                 }
 229
 230                 // Connect twice, which should auto-disconnect, and is a good test of our disconnect pipeline
 231                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 232                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 233
 234                 // Then disconnect the "main" connection, while another connection is being made.
 235                 PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2), false);
 236                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 237
 238                 // Wait for all our sockets to disconnect (making sure we disconnect any new connections)...
 239                 while (true) {
 240                         PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2), false);
 241                         // Wait for the peers to disconnect...
 242                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 243                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 244                         if (peers_1->datalen == 0 && peers_2->datalen == 0) { break; }
 245                         std::this_thread::yield();
 246                 }
 247                 // Note that the above is somewhat race-y, as node 2 may still think its connected.
 248                 // Thus, make sure any connections are disconnected on its end as well.
 249                 PeerManager_disconnect_by_node_id(&net2, ChannelManager_get_our_node_id(&cm1), false);
 250
 251                 // Finally make an actual connection and keep it this time
 252                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 253
 254                 while (true) {
 255                         // Wait for the initial handshakes to complete...
 256                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 257                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 258                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 259                         std::this_thread::yield();
 260                 }
 261         }
 262         void stop() {
 263                 interrupt_socket_handling(node1_handler);
 264                 interrupt_socket_handling(node2_handler);
 265         }
 266 };
 267
 268 #else // REAL_NET
 269
 270 uintptr_t sock_send_data(void *this_arg, LDKu8slice data, bool resume_read) {
 271         return write((int)((long)this_arg), data.data, data.datalen);
 272 }
 273 void sock_disconnect_socket(void *this_arg) {
 274         close((int)((long)this_arg));
 275 }
 276 bool sock_eq(const void *this_arg, const LDKSocketDescriptor *other_arg) {
 277         return this_arg == other_arg->this_arg;
 278 }
 279 uint64_t sock_hash(const void *this_arg) {
 280         return (uint64_t)this_arg;
 281 }
 282 void sock_read_data_thread(int rdfd, LDKSocketDescriptor *peer_descriptor, LDKPeerManager *pm) {
 283         unsigned char buf[1024];
 284         LDKu8slice data;
 285         data.data = buf;
 286         ssize_t readlen = 0;
 287         while ((readlen = read(rdfd, buf, 1024)) > 0) {
 288                 data.datalen = readlen;
 289                 LDK::CResult_boolPeerHandleErrorZ res = PeerManager_read_event(&*pm, peer_descriptor, data);
 290                 if (!res->result_ok) {
 291                         peer_descriptor->disconnect_socket(peer_descriptor->this_arg);
 292                         return;
 293                 }
 294                 PeerManager_process_events(pm);
 295         }
 296         PeerManager_socket_disconnected(&*pm, peer_descriptor);
 297 }
 298
 299 class PeersConnection {
 300         int pipefds_1_to_2[2];
 301         int pipefds_2_to_1[2];
 302         std::thread t1, t2;
 303         LDKSocketDescriptor sock1, sock2;
 304
 305 public:
 306         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 307                 assert(!pipe(pipefds_1_to_2));
 308                 assert(!pipe(pipefds_2_to_1));
 309
 310                 sock1 = LDKSocketDescriptor {
 311                         .this_arg = (void*)(long)pipefds_1_to_2[1],
 312                         .send_data = sock_send_data,
 313                         .disconnect_socket = sock_disconnect_socket,
 314                         .eq = sock_eq,
 315                         .hash = sock_hash,
 316                         .cloned = NULL,
 317                         .free = NULL,
 318                 };
 319
 320                 sock2 = LDKSocketDescriptor {
 321                         .this_arg = (void*)(long)pipefds_2_to_1[1],
 322                         .send_data = sock_send_data,
 323                         .disconnect_socket = sock_disconnect_socket,
 324                         .eq = sock_eq,
 325                         .hash = sock_hash,
 326                         .cloned = NULL,
 327                         .free = NULL,
 328                 };
 329
 330                 t1 = std::thread(&sock_read_data_thread, pipefds_2_to_1[0], &sock1, &net1);
 331                 t2 = std::thread(&sock_read_data_thread, pipefds_1_to_2[0], &sock2, &net2);
 332
 333                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 334                 LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1);
 335                 assert(con_res->result_ok);
 336                 LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2);
 337                 assert(con_res2->result_ok);
 338
 339                 auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen);
 340                 assert(writelen > 0 && uint64_t(writelen) == con_res->contents.result->datalen);
 341
 342                 while (true) {
 343                         // Wait for the initial handshakes to complete...
 344                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 345                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 346                         if (peers_1->datalen == 1 && peers_2->datalen ==1) { break; }
 347                         std::this_thread::yield();
 348                 }
 349         }
 350
 351         void stop() {
 352                 close(pipefds_1_to_2[0]);
 353                 close(pipefds_2_to_1[0]);
 354                 close(pipefds_1_to_2[1]);
 355                 close(pipefds_2_to_1[1]);
 356                 t1.join();
 357                 t2.join();
 358         }
 359 };
 360 #endif // !REAL_NET
 361
 362 struct CustomMsgQueue {
 363         std::vector<LDK::Type> msgs;
 364 };
 365
 366 uint16_t custom_msg_type_id(const void *this_arg) {
 367         return 8888;
 368 }
 369 LDKCVec_u8Z custom_msg_bytes(const void *this_arg) {
 370         uint8_t *bytes = (uint8_t *) malloc(1024);
 371         memset(bytes, 42, 1024);
 372         return LDKCVec_u8Z {
 373                 .data = bytes, .datalen = 1024
 374         };
 375 }
 376 LDKStr custom_msg_debug(const void *this_arg) {
 377         return LDKStr {
 378                 .chars = NULL, .len = 0, .chars_is_owned = false
 379         };
 380 }
 381
 382 LDKCResult_COption_TypeZDecodeErrorZ read_custom_message(const void* this_arg, uint16_t type_id, LDKu8slice buf) {
 383         assert(type_id == 8888);
 384         assert(buf.datalen == 1024);
 385         uint8_t cmp[1024];
 386         memset(cmp, 42, 1024);
 387         assert(!memcmp(cmp, buf.data, 1024));
 388         return CResult_COption_TypeZDecodeErrorZ_ok(COption_TypeZ_some(LDKType {
 389                 .this_arg = NULL,
 390                 .type_id = custom_msg_type_id,
 391                 .debug_str = custom_msg_debug,
 392                 .free = NULL,
 393         }));
 394 }
 395
 396 LDKCResult_NoneLightningErrorZ handle_custom_message(const void* this_arg, struct LDKType msg, struct LDKPublicKey _sender_node_id) {
 397         CustomMsgQueue* arg = (CustomMsgQueue*) this_arg;
 398         arg->msgs.push_back(std::move(msg));
 399         return CResult_NoneLightningErrorZ_ok();
 400 }
 401 LDKCVec_C2Tuple_PublicKeyTypeZZ never_send_custom_msgs(const void* this_arg) {
 402         return LDKCVec_C2Tuple_PublicKeyTypeZZ {
 403                 .data = NULL, .datalen = 0
 404         };
 405 }
 406
 407 LDKCVec_C2Tuple_PublicKeyTypeZZ create_custom_msg(const void* this_arg) {
 408         const LDKPublicKey *counterparty_node_id = (const LDKPublicKey *)this_arg;
 409         LDKCVec_C2Tuple_PublicKeyTypeZZ ret = {
 410                 .data = ((LDKC2Tuple_PublicKeyTypeZ*)malloc(sizeof(LDKC2Tuple_PublicKeyTypeZ))),
 411                 .datalen = 1
 412         };
 413         ret.data[0].a = *counterparty_node_id;
 414         ret.data[0].b = LDKType {
 415                 .this_arg = NULL,
 416                 .type_id = custom_msg_type_id,
 417                 .debug_str = custom_msg_debug,
 418                 .write = custom_msg_bytes,
 419                 .free = NULL,
 420         };
 421         return ret;
 422 }
 423
 424 uint64_t get_chan_score(const void *this_arg, uint64_t scid, uint64_t htlc_amt,
 425 LDKCOption_u64Z chan_capacity, const LDKNodeId *src, const LDKNodeId *dst) {
 426         LDK::COption_u64Z _capacity(std::move(chan_capacity));
 427         return 42;
 428 }
 429
 430 struct CustomRouteFinderParams {
 431         LDKLogger *logger;
 432         LDKNetworkGraph *graph_ref;
 433 };
 434 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) {
 435         const struct CustomRouteFinderParams *params = (struct CustomRouteFinderParams *)this_arg;
 436         assert(first_hops->datalen == 1);
 437         assert(ChannelDetails_get_is_usable(&first_hops->data[0]));
 438         return find_route(payer, route_params, params->graph_ref, first_hops, *params->logger, scorer);
 439 }
 440
 441 int main() {
 442         uint8_t channel_open_header[80];
 443         uint8_t header_1[80];
 444         uint8_t header_2[80];
 445         memcpy(channel_open_header, channel_open_block, 80);
 446         memcpy(header_1, block_1, 80);
 447         memcpy(header_2, block_2, 80);
 448
 449         LDKPublicKey null_pk;
 450         memset(&null_pk, 0, sizeof(null_pk));
 451
 452         LDKThirtyTwoBytes random_bytes;
 453         LDKThirtyTwoBytes chain_tip;
 454         memset(&chain_tip, 0, sizeof(chain_tip)); // channel_open_header's prev_blockhash is all-0s
 455
 456         LDKNetwork network = LDKNetwork_Testnet;
 457
 458         // Trait implementations:
 459         LDKBroadcasterInterface broadcast {
 460                 .this_arg = NULL,
 461                 .broadcast_transaction = broadcast_tx,
 462                 .free = NULL,
 463         };
 464
 465         // Instantiate classes for the nodes that don't get reloaded on a ser-des reload
 466         LDKLogger logger1 {
 467                 .this_arg = (void*)1,
 468                 .log = print_log,
 469                 .free = NULL,
 470         };
 471
 472         NodeMonitors mons1;
 473         mons1.logger = &logger1;
 474         LDKWatch mon1 {
 475                 .this_arg = &mons1,
 476                 .watch_channel = add_channel_monitor,
 477                 .update_channel = update_channel_monitor,
 478                 .release_pending_monitor_events = monitors_pending_monitor_events,
 479                 .free = NULL,
 480         };
 481
 482         LDK::NetworkGraph net_graph1 = NetworkGraph_new(genesis_hash);
 483         LDK::NetGraphMsgHandler graph_msg_handler1 = NetGraphMsgHandler_new(&net_graph1, COption_AccessZ_none(), logger1);
 484         LDKSecretKey node_secret1;
 485
 486         LDKLogger logger2 {
 487                 .this_arg = (void*)2,
 488                 .log = print_log,
 489                 .free = NULL,
 490         };
 491
 492         NodeMonitors mons2;
 493         mons2.logger = &logger2;
 494         LDKWatch mon2 {
 495                 .this_arg = &mons2,
 496                 .watch_channel = add_channel_monitor,
 497                 .update_channel = update_channel_monitor,
 498                 .release_pending_monitor_events = monitors_pending_monitor_events,
 499                 .free = NULL,
 500         };
 501
 502         LDK::NetworkGraph net_graph2 = NetworkGraph_new(genesis_hash);
 503         LDK::NetGraphMsgHandler graph_msg_handler2 = NetGraphMsgHandler_new(&net_graph2, COption_AccessZ_none(), logger2);
 504         LDKSecretKey node_secret2;
 505
 506         LDK::CVec_u8Z cm1_ser = LDKCVec_u8Z {}; // ChannelManager 1 serialization at the end of the ser-des scope
 507         LDK::CVec_u8Z cm2_ser = LDKCVec_u8Z {}; // ChannelManager 2 serialization at the end of the ser-des scope
 508
 509         { // Scope for the ser-des reload
 510                 // Instantiate classes for node 1:
 511                 uint8_t node_seed[32];
 512                 memset(&node_seed, 0, 32);
 513                 LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
 514                 LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 515                 node_secret1 = keys_source1->get_node_secret(keys_source1->this_arg);
 516
 517                 LDK::ChannelManager cm1 = ChannelManager_new(fee_est, mon1, broadcast, logger1, KeysManager_as_KeysInterface(&keys1), UserConfig_default(), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 518
 519                 LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
 520                 assert(channels->datalen == 0);
 521
 522                 LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
 523
 524                 LDK::IgnoringMessageHandler ignoring_handler1 = IgnoringMessageHandler_new();
 525                 LDK::CustomMessageHandler custom_msg_handler1 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler1);
 526
 527                 random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 528                 LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
 529
 530                 // Demo getting a channel key and check that its returning real pubkeys:
 531                 LDK::Sign chan_signer1 = keys_source1->get_channel_signer(keys_source1->this_arg, false, 42);
 532                 chan_signer1->BaseSign.set_pubkeys(&chan_signer1->BaseSign); // Make sure pubkeys is defined
 533                 LDKPublicKey payment_point = ChannelPublicKeys_get_payment_point(&chan_signer1->BaseSign.pubkeys);
 534                 assert(memcmp(&payment_point, &null_pk, sizeof(null_pk)));
 535
 536                 // Instantiate classes for node 2:
 537                 memset(&node_seed, 1, 32);
 538                 LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
 539                 LDK::KeysInterface keys_source2 = KeysManager_as_KeysInterface(&keys2);
 540                 node_secret2 = keys_source2->get_node_secret(keys_source2->this_arg);
 541
 542                 LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
 543                 ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
 544                 LDK::UserConfig config2 = UserConfig_default();
 545                 UserConfig_set_own_channel_config(&config2, std::move(handshake_config2));
 546
 547                 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)));
 548
 549                 LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
 550                 assert(channels2->datalen == 0);
 551
 552                 LDK::RoutingMessageHandler net_msgs2 = NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler2);
 553                 LDK::CResult_ChannelAnnouncementDecodeErrorZ chan_ann = ChannelAnnouncement_read(LDKu8slice { .data = valid_node_announcement, .datalen = sizeof(valid_node_announcement) });
 554                 assert(chan_ann->result_ok);
 555                 LDK::CResult_boolLightningErrorZ ann_res = net_msgs2->handle_channel_announcement(net_msgs2->this_arg, chan_ann->contents.result);
 556                 assert(ann_res->result_ok);
 557
 558                 LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2));
 559
 560                 LDK::IgnoringMessageHandler ignoring_handler2 = IgnoringMessageHandler_new();
 561                 LDK::CustomMessageHandler custom_msg_handler2 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler2);
 562
 563                 random_bytes = keys_source2->get_secure_random_bytes(keys_source2->this_arg);
 564                 LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
 565
 566                 // Open a connection!
 567                 PeersConnection conn(cm1, cm2, net1, net2);
 568
 569                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 570                 LDK::CResult__u832APIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, 42, UserConfig_default());
 571                 assert(res->result_ok);
 572                 PeerManager_process_events(&net1);
 573
 574                 LDK::CVec_ChannelDetailsZ new_channels = ChannelManager_list_channels(&cm1);
 575                 assert(new_channels->datalen == 1);
 576                 LDK::ChannelCounterparty new_channels_counterparty = ChannelDetails_get_counterparty(&new_channels->data[0]);
 577                 LDKPublicKey chan_open_pk = ChannelCounterparty_get_node_id(&new_channels_counterparty);
 578                 assert(!memcmp(chan_open_pk.compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 579
 580                 while (true) {
 581                         LDK::CVec_ChannelDetailsZ new_channels_2 = ChannelManager_list_channels(&cm2);
 582                         if (new_channels_2->datalen == 1) {
 583                                 // Sample getting our counterparty's init features (which used to be hard to do without a memory leak):
 584                                 LDK::ChannelCounterparty new_channels_2_counterparty = ChannelDetails_get_counterparty(&new_channels_2->data[0]);
 585                                 const LDK::InitFeatures init_feats = ChannelCounterparty_get_features(&new_channels_2_counterparty);
 586                                 assert(init_feats->inner != NULL);
 587                                 break;
 588                         }
 589                         std::this_thread::yield();
 590                 }
 591
 592                 LDKEventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 593                 while (true) {
 594                         EventQueue queue;
 595                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 596                         ev1.process_pending_events(ev1.this_arg, handler);
 597                         if (queue.events.size() == 1) {
 598                                 assert(queue.events[0]->tag == LDKEvent_FundingGenerationReady);
 599                                 assert(queue.events[0]->funding_generation_ready.user_channel_id == 42);
 600                                 assert(queue.events[0]->funding_generation_ready.channel_value_satoshis == 40000);
 601                                 assert(queue.events[0]->funding_generation_ready.output_script.datalen == 34);
 602                                 assert(!memcmp(queue.events[0]->funding_generation_ready.output_script.data, channel_open_block + 58 + 81, 34));
 603                                 LDKTransaction funding_transaction { .data = const_cast<uint8_t*>(channel_open_block + 81), .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false };
 604
 605                                 LDK::CResult_NoneAPIErrorZ fund_res = ChannelManager_funding_transaction_generated(&cm1, &queue.events[0]->funding_generation_ready.temporary_channel_id.data, funding_transaction);
 606                                 assert(fund_res->result_ok);
 607                                 break;
 608                         }
 609                         std::this_thread::yield();
 610                 }
 611
 612                 // We observe when the funding signed messages have been exchanged by
 613                 // waiting for two monitors to be registered.
 614                 assert(num_txs_broadcasted == 0);
 615                 PeerManager_process_events(&net1);
 616                 while (num_txs_broadcasted != 1) {
 617                         std::this_thread::yield();
 618                 }
 619
 620                 LDK::Listen listener1 = ChannelManager_as_Listen(&cm1);
 621                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 622
 623                 LDK::Listen listener2 = ChannelManager_as_Listen(&cm2);
 624                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 625
 626                 LDKCVec_C2Tuple_usizeTransactionZZ txdata { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 627                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 628                 mons1.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 629
 630                 txdata = LDKCVec_C2Tuple_usizeTransactionZZ { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 631                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 632                 mons2.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 633
 634                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 635                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 636                 mons1.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 637                 mons2.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 638
 639                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 640                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 641                 mons1.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 642                 mons2.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 643
 644                 PeerManager_process_events(&net1);
 645                 PeerManager_process_events(&net2);
 646
 647                 // Now send funds from 1 to 2!
 648                 uint64_t channel_scid;
 649                 while (true) {
 650                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 651                         if (outbound_channels->datalen == 1) {
 652                                 const LDKChannelDetails *channel = &outbound_channels->data[0];
 653                                 LDK::ChannelCounterparty counterparty = ChannelDetails_get_counterparty(channel);
 654                                 // Note that the channel ID is the same as the channel txid reversed as the output index is 0
 655                                 uint8_t expected_chan_id[32];
 656                                 for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; }
 657                                 assert(!memcmp(ChannelDetails_get_channel_id(channel), expected_chan_id, 32));
 658                                 assert(!memcmp(
 659                                         ChannelCounterparty_get_node_id(&counterparty).compressed_form,
 660                                         ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 661                                 assert(ChannelDetails_get_channel_value_satoshis(channel) == 40000);
 662                                 // We opened the channel with 1000 push_msat:
 663                                 assert(ChannelDetails_get_outbound_capacity_msat(channel) ==
 664                                         40000*1000 - 1000 - 1000 * ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty));
 665                                 int64_t inbound_capacity = ((int64_t)1000) - ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty);
 666                                 if (inbound_capacity < 0) inbound_capacity = 0;
 667                                 assert(ChannelDetails_get_inbound_capacity_msat(channel) == (uint64_t)inbound_capacity);
 668                                 assert(ChannelDetails_get_is_usable(channel));
 669                                 LDK::COption_u64Z scid_opt = ChannelDetails_get_short_channel_id(channel);
 670                                 assert(scid_opt->some);
 671                                 channel_scid = scid_opt->some;
 672                                 break;
 673                         }
 674                         std::this_thread::yield();
 675                 }
 676
 677                 LDKCOption_u64Z min_value = {
 678                         .tag = LDKCOption_u64Z_Some,
 679                         .some = 5000,
 680                 };
 681                 LDK::CResult_InvoiceSignOrCreationErrorZ invoice = create_invoice_from_channelmanager(&cm2,
 682                         KeysManager_as_KeysInterface(&keys2),
 683                         LDKCurrency_Bitcoin, min_value,
 684                         LDKStr {
 685                                 .chars = (const uint8_t *)"Invoice Description",
 686                                 .len =             strlen("Invoice Description"),
 687                                 .chars_is_owned = false
 688                         });
 689                 assert(invoice->result_ok);
 690                 LDKThirtyTwoBytes payment_hash;
 691                 memcpy(payment_hash.data, Invoice_payment_hash(invoice->contents.result), 32);
 692
 693                 {
 694                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 695                         LDK::Score chan_scorer = LDKScore {
 696                                 .this_arg = NULL, .channel_penalty_msat = get_chan_score, .free = NULL
 697                         };
 698                         LDK::RouteParameters route_params = RouteParameters_new(Payee_new(
 699                                         ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
 700                                                 .inner = NULL, .is_owned = false
 701                                         }, Invoice_route_hints(invoice->contents.result), COption_u64Z_none()),
 702                                 5000, Invoice_min_final_cltv_expiry(invoice->contents.result));
 703                         LDK::CResult_RouteLightningErrorZ route = find_route(ChannelManager_get_our_node_id(&cm1), &route_params, &net_graph2, &outbound_channels, logger1, &chan_scorer);
 704                         assert(route->result_ok);
 705                         LDK::CVec_CVec_RouteHopZZ paths = Route_get_paths(route->contents.result);
 706                         assert(paths->datalen == 1);
 707                         assert(paths->data[0].datalen == 1);
 708                         assert(!memcmp(RouteHop_get_pubkey(&paths->data[0].data[0]).compressed_form,
 709                                 ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 710                         assert(RouteHop_get_short_channel_id(&paths->data[0].data[0]) == channel_scid);
 711                         LDKThirtyTwoBytes payment_secret;
 712                         memcpy(payment_secret.data, Invoice_payment_secret(invoice->contents.result), 32);
 713                         LDK::CResult_PaymentIdPaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, payment_secret);
 714                         assert(send_res->result_ok);
 715                 }
 716
 717                 mons_updated = 0;
 718                 PeerManager_process_events(&net1);
 719                 while (mons_updated != 4) {
 720                         std::this_thread::yield();
 721                 }
 722
 723                 // Check that we received the payment!
 724                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 725                 while (true) {
 726                         EventQueue queue;
 727                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 728                         ev2.process_pending_events(handler);
 729                         if (queue.events.size() == 1) {
 730                                 assert(queue.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
 731                                 break;
 732                         }
 733                         std::this_thread::yield();
 734                 }
 735                 ChannelManager_process_pending_htlc_forwards(&cm2);
 736                 PeerManager_process_events(&net2);
 737
 738                 mons_updated = 0;
 739                 LDKThirtyTwoBytes payment_preimage;
 740                 {
 741                         EventQueue queue;
 742                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 743                         ev2.process_pending_events(handler);
 744                         assert(queue.events.size() == 1);
 745                         assert(queue.events[0]->tag == LDKEvent_PaymentReceived);
 746                         assert(!memcmp(queue.events[0]->payment_received.payment_hash.data, payment_hash.data, 32));
 747                         assert(queue.events[0]->payment_received.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 748                         assert(!memcmp(queue.events[0]->payment_received.purpose.invoice_payment.payment_secret.data,
 749                                         Invoice_payment_secret(invoice->contents.result), 32));
 750                         assert(queue.events[0]->payment_received.amt == 5000);
 751                         memcpy(payment_preimage.data, queue.events[0]->payment_received.purpose.invoice_payment.payment_preimage.data, 32);
 752                         assert(ChannelManager_claim_funds(&cm2, payment_preimage));
 753                 }
 754                 PeerManager_process_events(&net2);
 755                 // Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages)
 756                 while (mons_updated != 5) {
 757                         std::this_thread::yield();
 758                 }
 759                 {
 760                         EventQueue queue;
 761                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 762                         while (queue.events.size() < 2)
 763                                 ev1.process_pending_events(ev1.this_arg, handler);
 764                         assert(queue.events.size() == 2);
 765                         assert(queue.events[0]->tag == LDKEvent_PaymentSent);
 766                         assert(!memcmp(queue.events[0]->payment_sent.payment_preimage.data, payment_preimage.data, 32));
 767                         assert(queue.events[1]->tag == LDKEvent_PaymentPathSuccessful);
 768                         assert(!memcmp(queue.events[1]->payment_path_successful.payment_hash.data, payment_hash.data, 32));
 769                 }
 770
 771                 conn.stop();
 772
 773                 cm1_ser = ChannelManager_write(&cm1);
 774                 cm2_ser = ChannelManager_write(&cm2);
 775         }
 776
 777         LDK::CVec_ChannelMonitorZ mons_list1 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 778         assert(mons1.mons.size() == 1);
 779         mons_list1->data[0] = *& std::get<1>(mons1.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 780         mons_list1->data[0].is_owned = false; // XXX: God this sucks
 781         uint8_t node_seed[32];
 782         memset(&node_seed, 0, 32);
 783         LDK::KeysManager keys1 = KeysManager_new(&node_seed, 1, 0);
 784         LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 785
 786         LDK::ChannelManagerReadArgs cm1_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys1), fee_est, mon1, broadcast, logger1, UserConfig_default(), std::move(mons_list1));
 787         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm1_read =
 788                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm1_ser->data, .datalen = cm1_ser -> datalen}, std::move(cm1_args));
 789         assert(cm1_read->result_ok);
 790         LDK::ChannelManager cm1(std::move(cm1_read->contents.result->b));
 791
 792         LDK::CVec_ChannelMonitorZ mons_list2 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 793         assert(mons2.mons.size() == 1);
 794         mons_list2->data[0] = *& std::get<1>(mons2.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 795         mons_list2->data[0].is_owned = false; // XXX: God this sucks
 796         memset(&node_seed, 1, 32);
 797         LDK::KeysManager keys2 = KeysManager_new(&node_seed, 1, 0);
 798
 799         LDK::ChannelManagerReadArgs cm2_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys2), fee_est, mon2, broadcast, logger2, UserConfig_default(), std::move(mons_list2));
 800         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm2_read =
 801                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm2_ser->data, .datalen = cm2_ser -> datalen}, std::move(cm2_args));
 802         assert(cm2_read->result_ok);
 803         LDK::ChannelManager cm2(std::move(cm2_read->contents.result->b));
 804
 805         // Attempt to close the channel...
 806         uint8_t chan_id[32];
 807         for (int i = 0; i < 32; i++) { chan_id[i] = channel_open_txid[31-i]; }
 808         LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id);
 809         assert(!close_res->result_ok); // Note that we can't close while disconnected!
 810
 811         // Open a connection!
 812         LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler1));
 813         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 814
 815         LDKPublicKey chan_2_node_id = ChannelManager_get_our_node_id(&cm2);
 816         LDKCustomMessageHandler custom_msg_handler1 = {
 817                 .this_arg = &chan_2_node_id,
 818                 .handle_custom_message = NULL, // We only create custom messages, not handle them
 819                 .get_and_clear_pending_msg = create_custom_msg,
 820                 .CustomMessageReader = LDKCustomMessageReader {
 821                         .this_arg = NULL,
 822                         .read = read_custom_message,
 823                         .free = NULL,
 824                 },
 825                 .free = NULL,
 826         };
 827         LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1, std::move(custom_msg_handler1));
 828
 829         LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), NetGraphMsgHandler_as_RoutingMessageHandler(&graph_msg_handler2));
 830         CustomMsgQueue peer_2_custom_messages;
 831         LDKCustomMessageHandler custom_msg_handler2 = {
 832                 .this_arg = &peer_2_custom_messages,
 833                 .handle_custom_message = handle_custom_message,
 834                 .get_and_clear_pending_msg = never_send_custom_msgs,
 835                 .CustomMessageReader = LDKCustomMessageReader {
 836                         .this_arg = NULL,
 837                         .read = read_custom_message,
 838                         .free = NULL,
 839                 },
 840                 .free = NULL,
 841         };
 842         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 843         LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2, std::move(custom_msg_handler2));
 844
 845         PeersConnection conn(cm1, cm2, net1, net2);
 846
 847         while (true) {
 848                 // Wait for the channels to be considered up once the reestablish messages are processed
 849                 LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 850                 if (outbound_channels->datalen == 1) {
 851                         break;
 852                 }
 853         }
 854
 855         // Send another payment, this time via the InvoicePayer
 856         struct CustomRouteFinderParams router_params = {
 857                 .logger = &logger1,
 858                 .graph_ref = &net_graph1,
 859         };
 860         LDKRouter sending_router = {
 861                 .this_arg = &router_params,
 862                 .find_route = custom_find_route,
 863                 .free = NULL,
 864         };
 865         LDK::Scorer scorer = Scorer_default();
 866         LDK::MultiThreadedLockableScore scorer_mtx = MultiThreadedLockableScore_new(Scorer_as_Score(&scorer));
 867         EventQueue queue1;
 868         LDKEventHandler handler1 = { .this_arg = &queue1, .handle_event = handle_event, .free = NULL };
 869         LDK::InvoicePayer payer = InvoicePayer_new(ChannelManager_as_Payer(&cm1), sending_router, &scorer_mtx, logger1, handler1, RetryAttempts_new(0));
 870
 871         LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
 872                 KeysManager_as_KeysInterface(&keys2),
 873                 LDKCurrency_Bitcoin, COption_u64Z_some(10000),
 874                 LDKStr {
 875                         .chars = (const uint8_t *)"Invoice 2 Description",
 876                         .len =             strlen("Invoice 2 Description"),
 877                         .chars_is_owned = false
 878                 });
 879         assert(invoice_res2->result_ok);
 880         const LDKInvoice *invoice2 = invoice_res2->contents.result;
 881         LDK::CResult_PaymentIdPaymentErrorZ invoice_pay_res = InvoicePayer_pay_invoice(&payer, invoice2);
 882         assert(invoice_pay_res->result_ok);
 883         PeerManager_process_events(&net1);
 884
 885         // Check that we received the payment!
 886         while (true) {
 887                 EventQueue queue2;
 888                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
 889                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 890                 ev2.process_pending_events(handler2);
 891                 if (queue2.events.size() == 1) {
 892                         assert(queue2.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
 893                         break;
 894                 }
 895                 std::this_thread::yield();
 896         }
 897         ChannelManager_process_pending_htlc_forwards(&cm2);
 898         PeerManager_process_events(&net2);
 899
 900         while (true) {
 901                 EventQueue queue2;
 902                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
 903                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 904                 ev2.process_pending_events(handler2);
 905                 if (queue2.events.size() == 1) {
 906                         assert(queue2.events[0]->tag == LDKEvent_PaymentReceived);
 907                         const struct LDKEvent_LDKPaymentReceived_Body *event_data = &queue2.events[0]->payment_received;
 908                         assert(!memcmp(event_data->payment_hash.data, Invoice_payment_hash(invoice2), 32));
 909                         assert(event_data->purpose.tag == LDKPaymentPurpose_InvoicePayment);
 910                         assert(!memcmp(event_data->purpose.invoice_payment.payment_secret.data,
 911                                         Invoice_payment_secret(invoice2), 32));
 912                         assert(event_data->amt == 10000);
 913                         assert(ChannelManager_claim_funds(&cm2, event_data->purpose.invoice_payment.payment_preimage));
 914                         break;
 915                 }
 916                 std::this_thread::yield();
 917         }
 918
 919         while (queue1.events.size() < 2) {
 920                 PeerManager_process_events(&net2);
 921                 PeerManager_process_events(&net1);
 922
 923                 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 924                 LDK::EventHandler evh1 = InvoicePayer_as_EventHandler(&payer);
 925                 ev1.process_pending_events(std::move(evh1));
 926         }
 927         assert(queue1.events.size() == 2);
 928         assert(queue1.events[0]->tag == LDKEvent_PaymentSent);
 929         assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful);
 930
 931         // Actually close the channel
 932         num_txs_broadcasted = 0;
 933         close_res = ChannelManager_close_channel(&cm1, &chan_id);
 934         assert(close_res->result_ok);
 935         PeerManager_process_events(&net1);
 936         while (num_txs_broadcasted != 2) {
 937                 std::this_thread::yield();
 938         }
 939         LDK::CVec_ChannelDetailsZ chans_after_close1 = ChannelManager_list_channels(&cm1);
 940         assert(chans_after_close1->datalen == 0);
 941         LDK::CVec_ChannelDetailsZ chans_after_close2 = ChannelManager_list_channels(&cm2);
 942         assert(chans_after_close2->datalen == 0);
 943
 944         conn.stop();
 945
 946         assert(peer_2_custom_messages.msgs.size() != 0);
 947
 948         // Few extra random tests:
 949         LDKSecretKey sk;
 950         memset(&sk, 42, 32);
 951         LDKThirtyTwoBytes kdiv_params;
 952         memset(&kdiv_params, 43, 32);
 953         LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params);
 954 }