_ 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 //
  58 // Note that the merkle root is incorrect, but it isn't ever checked by LDK, so should be fine.
  59 const uint8_t channel_open_block[] = {
  60         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  61         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  62         0x00, 0x00, 0x00, 0x00, 0xa2, 0x47, 0xd2, 0xf8, 0xd4, 0xe0, 0x6a, 0x3f, 0xf9, 0x7a, 0x9a, 0x34,
  63         0xbb, 0xa9, 0x96, 0xde, 0x63, 0x84, 0x5a, 0xce, 0xcf, 0x98, 0xb8, 0xbb, 0x75, 0x4c, 0x4f, 0x7d,
  64         0xee, 0x4c, 0xa9, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  65         0x01, // transaction count
  66         0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  67         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  68         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  69         0x01, 0x40, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0xc5, 0x1c, 0xad, 0x5e,
  70         0x51, 0x11, 0xb0, 0x11, 0xa1, 0x14, 0xf4, 0xda, 0x02, 0x3d, 0xbc, 0xc1, 0x44, 0x3c, 0x67, 0x31,
  71         0xec, 0x6f, 0x10, 0x2f, 0x89, 0xc1, 0x05, 0x80, 0xfe, 0xfc, 0xd6, 0xc7, 0x01, 0x00, 0x00, 0x00,
  72         0x00, 0x00
  73 };
  74
  75 // The first transaction in the block is header (80 bytes) + transaction count (1 byte) into the block data.
  76 const uint8_t channel_open_txid[] = {
  77         0x7a, 0x14, 0x8f, 0xb4, 0x08, 0x49, 0x9b, 0x51, 0x2e, 0xff, 0xf9, 0x46, 0x73, 0xca, 0xc6, 0x48,
  78         0xfd, 0x95, 0x0e, 0x72, 0xd4, 0xd3, 0xdb, 0x79, 0xc9, 0x20, 0xed, 0x83, 0xb2, 0xde, 0xed, 0x41,
  79 };
  80
  81 // Two blocks built on top of channel_open_block:
  82 const uint8_t block_1[81] = {
  83         0x01, 0x00, 0x00, 0x00, 0x0c, 0x7a, 0xc2, 0xdc, 0x08, 0xaf, 0x40, 0x7d, 0x58, 0x81, 0x9b, 0x44,
  84         0xc7, 0xe0, 0x0f, 0x78, 0xc0, 0xd1, 0x01, 0xa2, 0x03, 0x16, 0x4a, 0x8d, 0x92, 0x66, 0x4e, 0xaf,
  85         0x7f, 0xfc, 0x6e, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  86         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  87         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  88         0x00, // transaction count
  89 };
  90 const uint8_t block_2[81] = {
  91         0x01, 0x00, 0x00, 0x00, 0x36, 0x0b, 0xf5, 0x46, 0x4a, 0xc7, 0x26, 0x4c, 0x4b, 0x36, 0xa6, 0x9d,
  92         0x0e, 0xf0, 0x14, 0xfb, 0x8a, 0xcb, 0x20, 0x84, 0x18, 0xf3, 0xaa, 0x77, 0x32, 0x2d, 0xf7, 0x48,
  93         0x62, 0x92, 0xb1, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  94         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  95         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  96         0x00, // transaction count
  97 };
  98
  99 void print_log(const void *this_arg, const LDKRecord *record) {
 100         LDK::Str mod = Record_get_module_path(record);
 101         LDK::Str str = Record_get_args(record);
 102         printf("%p - %.*s:%d - %.*s\n", this_arg, (int)mod->len, mod->chars, Record_get_line(record), (int)str->len, str->chars);
 103 }
 104
 105 uint32_t get_fee(const void *this_arg, LDKConfirmationTarget target) {
 106         if (target == LDKConfirmationTarget_Background) {
 107                 return 253;
 108         } else {
 109                 return 507;
 110         }
 111         // Note that we don't call _free() on target, but that's OK, its unitary
 112 }
 113 // We use the same fee estimator globally:
 114 const LDKFeeEstimator fee_est {
 115         .this_arg = NULL,
 116         .get_est_sat_per_1000_weight = get_fee,
 117         .free = NULL,
 118 };
 119
 120 static std::atomic_int num_txs_broadcasted(0);
 121 void broadcast_tx(const void *this_arg, LDKTransaction tx) {
 122         num_txs_broadcasted += 1;
 123         //TODO
 124         Transaction_free(tx);
 125 }
 126
 127 struct NodeMonitors {
 128         std::mutex mut;
 129         std::vector<std::pair<LDK::OutPoint, LDK::ChannelMonitor>> mons;
 130         LDKLogger* logger;
 131
 132         void ConnectBlock(const uint8_t (*header)[80], uint32_t height, LDKCVec_C2Tuple_usizeTransactionZZ tx_data, LDKBroadcasterInterface broadcast, LDKFeeEstimator fee_est) {
 133                 std::unique_lock<std::mutex> l(mut);
 134                 for (auto& mon : mons) {
 135                         LDK::CVec_TransactionOutputsZ res = ChannelMonitor_block_connected(&mon.second, header, tx_data, height, broadcast, fee_est, *logger);
 136                 }
 137         }
 138 };
 139
 140 LDKChannelMonitorUpdateStatus add_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, LDKChannelMonitor monitor_arg) {
 141         // First bind the args to C++ objects so they auto-free
 142         LDK::ChannelMonitor mon(std::move(monitor_arg));
 143         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 144
 145         NodeMonitors* arg = (NodeMonitors*) this_arg;
 146         std::unique_lock<std::mutex> l(arg->mut);
 147
 148         arg->mons.push_back(std::make_pair(std::move(funding_txo), std::move(mon)));
 149         return ChannelMonitorUpdateStatus_completed();
 150 }
 151 static std::atomic_int mons_updated(0);
 152 LDKChannelMonitorUpdateStatus update_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, const LDKChannelMonitorUpdate *update) {
 153         // First bind the args to C++ objects so they auto-free
 154         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 155
 156         NodeMonitors* arg = (NodeMonitors*) this_arg;
 157         std::unique_lock<std::mutex> l(arg->mut);
 158
 159         bool updated = false;
 160         for (auto& mon : arg->mons) {
 161                 if (OutPoint_get_index(&mon.first) == OutPoint_get_index(&funding_txo) &&
 162                                 !memcmp(OutPoint_get_txid(&mon.first), OutPoint_get_txid(&funding_txo), 32)) {
 163                         updated = true;
 164                         LDKBroadcasterInterface broadcaster = {
 165                                 .broadcast_transaction = broadcast_tx,
 166                         };
 167                         LDK::CResult_NoneNoneZ res = ChannelMonitor_update_monitor(&mon.second, update, &broadcaster, fee_est, arg->logger);
 168                         assert(res->result_ok);
 169                 }
 170         }
 171         assert(updated);
 172
 173         mons_updated += 1;
 174         return ChannelMonitorUpdateStatus_completed();
 175 }
 176 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ monitors_pending_monitor_events(const void *this_arg) {
 177         NodeMonitors* arg = (NodeMonitors*) this_arg;
 178         std::unique_lock<std::mutex> l(arg->mut);
 179
 180         if (arg->mons.size() == 0) {
 181                 return LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
 182                         .data = NULL,
 183                         .datalen = 0,
 184                 };
 185         } else {
 186                 // We only ever actually have one channel per node, plus concatenating two
 187                 // Rust Vecs to each other from C++ will require a bit of effort.
 188                 assert(arg->mons.size() == 1);
 189                 LDK::CVec_MonitorEventZ events = ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
 190                 LDK::C2Tuple_OutPointScriptZ funding_info = ChannelMonitor_get_funding_txo(&arg->mons[0].second);
 191                 LDK::OutPoint outpoint = std::move(funding_info->a);
 192                 LDKPublicKey counterparty_node_id = ChannelMonitor_get_counterparty_node_id(&arg->mons[0].second);
 193                 LDK::C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ tuple = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(std::move(outpoint), std::move(events), std::move(counterparty_node_id));
 194                 auto vec = LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
 195                         .data = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)malloc(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ)),
 196                         .datalen = 1,
 197                 };
 198                 vec.data[0] = std::move(tuple);
 199                 return vec;
 200         }
 201 }
 202
 203 struct EventQueue {
 204         std::vector<LDK::Event> events;
 205 };
 206 void handle_event(const void *this_arg, LDKEvent event) {
 207         EventQueue* arg = (EventQueue*) this_arg;
 208         arg->events.push_back(std::move(event));
 209 }
 210
 211 #ifdef REAL_NET
 212 class PeersConnection {
 213         void* node1_handler;
 214         void* node2_handler;
 215
 216 public:
 217         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 218                 node1_handler = init_socket_handling(&net1);
 219                 node2_handler = init_socket_handling(&net2);
 220
 221                 struct sockaddr_in listen_addr;
 222                 listen_addr.sin_family = AF_INET;
 223                 listen_addr.sin_addr.s_addr = htonl((127 << 8*3) | 1);
 224                 listen_addr.sin_port = htons(10042);
 225                 assert(!socket_bind(node2_handler, (sockaddr*)&listen_addr, sizeof(listen_addr)));
 226
 227                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 228
 229                 while (true) {
 230                         // Wait for the initial handshakes to complete...
 231                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 232                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 233                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 234                         std::this_thread::yield();
 235                 }
 236
 237                 // Connect twice, which should auto-disconnect, and is a good test of our disconnect pipeline
 238                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 239                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 240
 241                 // Then disconnect the "main" connection, while another connection is being made.
 242                 PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2));
 243                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 244
 245                 while (true) {
 246                         // Wait for the new connection handshake...
 247                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 248                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 249                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 250                         std::this_thread::yield();
 251                 }
 252
 253                 // Wait for all our sockets to disconnect (making sure we disconnect any new connections)...
 254                 while (true) {
 255                         PeerManager_disconnect_by_node_id(&net1, ChannelManager_get_our_node_id(&cm2));
 256                         // Wait for the peers to disconnect...
 257                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 258                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 259                         if (peers_1->datalen == 0 && peers_2->datalen == 0) { break; }
 260                         std::this_thread::yield();
 261                 }
 262                 // Note that the above is somewhat race-y, as node 2 may still think its connected.
 263                 // Thus, make sure any connections are disconnected on its end as well.
 264                 PeerManager_disconnect_by_node_id(&net2, ChannelManager_get_our_node_id(&cm1));
 265
 266                 // Finally make an actual connection and keep it this time
 267                 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
 268
 269                 while (true) {
 270                         // Wait for the initial handshakes to complete...
 271                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 272                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 273                         if (peers_1->datalen == 1 && peers_2->datalen == 1) { break; }
 274                         std::this_thread::yield();
 275                 }
 276         }
 277         void stop() {
 278                 interrupt_socket_handling(node1_handler);
 279                 interrupt_socket_handling(node2_handler);
 280         }
 281 };
 282
 283 #else // REAL_NET
 284
 285 uintptr_t sock_send_data(void *this_arg, LDKu8slice data, bool resume_read) {
 286         return write((int)((long)this_arg), data.data, data.datalen);
 287 }
 288 void sock_disconnect_socket(void *this_arg) {
 289         close((int)((long)this_arg));
 290 }
 291 bool sock_eq(const void *this_arg, const LDKSocketDescriptor *other_arg) {
 292         return this_arg == other_arg->this_arg;
 293 }
 294 uint64_t sock_hash(const void *this_arg) {
 295         return (uint64_t)this_arg;
 296 }
 297 void sock_read_data_thread(int rdfd, LDKSocketDescriptor *peer_descriptor, LDKPeerManager *pm) {
 298         unsigned char buf[1024];
 299         LDKu8slice data;
 300         data.data = buf;
 301         ssize_t readlen = 0;
 302         while ((readlen = read(rdfd, buf, 1024)) > 0) {
 303                 data.datalen = readlen;
 304                 LDK::CResult_boolPeerHandleErrorZ res = PeerManager_read_event(&*pm, peer_descriptor, data);
 305                 if (!res->result_ok) {
 306                         peer_descriptor->disconnect_socket(peer_descriptor->this_arg);
 307                         return;
 308                 }
 309                 PeerManager_process_events(pm);
 310         }
 311         PeerManager_socket_disconnected(&*pm, peer_descriptor);
 312 }
 313
 314 class PeersConnection {
 315         int pipefds_1_to_2[2];
 316         int pipefds_2_to_1[2];
 317         std::thread t1, t2;
 318         LDKSocketDescriptor sock1, sock2;
 319
 320 public:
 321         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 322                 assert(!pipe(pipefds_1_to_2));
 323                 assert(!pipe(pipefds_2_to_1));
 324
 325                 sock1 = LDKSocketDescriptor {
 326                         .this_arg = (void*)(long)pipefds_1_to_2[1],
 327                         .send_data = sock_send_data,
 328                         .disconnect_socket = sock_disconnect_socket,
 329                         .eq = sock_eq,
 330                         .hash = sock_hash,
 331                         .cloned = NULL,
 332                         .free = NULL,
 333                 };
 334
 335                 sock2 = LDKSocketDescriptor {
 336                         .this_arg = (void*)(long)pipefds_2_to_1[1],
 337                         .send_data = sock_send_data,
 338                         .disconnect_socket = sock_disconnect_socket,
 339                         .eq = sock_eq,
 340                         .hash = sock_hash,
 341                         .cloned = NULL,
 342                         .free = NULL,
 343                 };
 344
 345                 t1 = std::thread(&sock_read_data_thread, pipefds_2_to_1[0], &sock1, &net1);
 346                 t2 = std::thread(&sock_read_data_thread, pipefds_1_to_2[0], &sock2, &net2);
 347
 348                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 349                 LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1, COption_NetAddressZ_none());
 350                 assert(con_res->result_ok);
 351                 LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2, COption_NetAddressZ_none());
 352                 assert(con_res2->result_ok);
 353
 354                 auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen);
 355                 assert(writelen > 0 && uint64_t(writelen) == con_res->contents.result->datalen);
 356
 357                 while (true) {
 358                         // Wait for the initial handshakes to complete...
 359                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 360                         LDK::CVec_C2Tuple_PublicKeyCOption_NetAddressZZZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 361                         if (peers_1->datalen == 1 && peers_2->datalen ==1) { break; }
 362                         std::this_thread::yield();
 363                 }
 364         }
 365
 366         void stop() {
 367                 close(pipefds_1_to_2[0]);
 368                 close(pipefds_2_to_1[0]);
 369                 close(pipefds_1_to_2[1]);
 370                 close(pipefds_2_to_1[1]);
 371                 t1.join();
 372                 t2.join();
 373         }
 374 };
 375 #endif // !REAL_NET
 376
 377 struct CustomOnionMsgQueue {
 378         std::mutex mtx;
 379         std::vector<LDK::CustomOnionMessageContents> msgs;
 380 };
 381
 382 uint64_t custom_onion_msg_type_id(const void *this_arg) {
 383         return 8888;
 384 }
 385 LDKCVec_u8Z custom_onion_msg_bytes(const void *this_arg) {
 386         uint8_t *bytes = (uint8_t *) malloc(1024);
 387         memset(bytes, 43, 1024);
 388         return LDKCVec_u8Z {
 389                 .data = bytes, .datalen = 1024
 390         };
 391 }
 392
 393 void handle_custom_onion_message(const void* this_arg, struct LDKCustomOnionMessageContents msg) {
 394         CustomOnionMsgQueue* arg = (CustomOnionMsgQueue*) this_arg;
 395         std::unique_lock<std::mutex> lck(arg->mtx);
 396         arg->msgs.push_back(std::move(msg));
 397 }
 398
 399 LDKCustomOnionMessageContents build_custom_onion_message() {
 400         return LDKCustomOnionMessageContents {
 401                 .this_arg = NULL,
 402                 .tlv_type = custom_onion_msg_type_id,
 403                 .write = custom_onion_msg_bytes,
 404                 .free = NULL,
 405         };
 406 }
 407
 408 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_onion_message(const void* this_arg, uint64_t type, LDKu8slice buf) {
 409         assert(type == 8888);
 410         assert(buf.datalen == 1024);
 411         uint8_t cmp[1024];
 412         memset(cmp, 43, 1024);
 413         assert(!memcmp(cmp, buf.data, 1024));
 414         return CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(COption_CustomOnionMessageContentsZ_some(build_custom_onion_message()));
 415 }
 416
 417
 418 struct CustomMsgQueue {
 419         std::vector<LDK::Type> msgs;
 420 };
 421
 422 uint16_t custom_msg_type_id(const void *this_arg) {
 423         return 8888;
 424 }
 425 LDKCVec_u8Z custom_msg_bytes(const void *this_arg) {
 426         uint8_t *bytes = (uint8_t *) malloc(1024);
 427         memset(bytes, 42, 1024);
 428         return LDKCVec_u8Z {
 429                 .data = bytes, .datalen = 1024
 430         };
 431 }
 432 LDKStr custom_msg_debug(const void *this_arg) {
 433         return LDKStr {
 434                 .chars = NULL, .len = 0, .chars_is_owned = false
 435         };
 436 }
 437
 438 LDKCResult_COption_TypeZDecodeErrorZ read_custom_message(const void* this_arg, uint16_t type_id, LDKu8slice buf) {
 439         assert(type_id == 8888);
 440         assert(buf.datalen == 1024);
 441         uint8_t cmp[1024];
 442         memset(cmp, 42, 1024);
 443         assert(!memcmp(cmp, buf.data, 1024));
 444         return CResult_COption_TypeZDecodeErrorZ_ok(COption_TypeZ_some(LDKType {
 445                 .this_arg = NULL,
 446                 .type_id = custom_msg_type_id,
 447                 .debug_str = custom_msg_debug,
 448                 .free = NULL,
 449         }));
 450 }
 451
 452 LDKCResult_NoneLightningErrorZ handle_custom_message(const void* this_arg, struct LDKType msg, struct LDKPublicKey _sender_node_id) {
 453         CustomMsgQueue* arg = (CustomMsgQueue*) this_arg;
 454         arg->msgs.push_back(std::move(msg));
 455         return CResult_NoneLightningErrorZ_ok();
 456 }
 457 LDKCVec_C2Tuple_PublicKeyTypeZZ never_send_custom_msgs(const void* this_arg) {
 458         return LDKCVec_C2Tuple_PublicKeyTypeZZ {
 459                 .data = NULL, .datalen = 0
 460         };
 461 }
 462
 463 LDKCVec_C2Tuple_PublicKeyTypeZZ create_custom_msg(const void* this_arg) {
 464         const LDKPublicKey *counterparty_node_id = (const LDKPublicKey *)this_arg;
 465         LDKCVec_C2Tuple_PublicKeyTypeZZ ret = {
 466                 .data = ((LDKC2Tuple_PublicKeyTypeZ*)malloc(sizeof(LDKC2Tuple_PublicKeyTypeZ))),
 467                 .datalen = 1
 468         };
 469         ret.data[0].a = *counterparty_node_id;
 470         ret.data[0].b = LDKType {
 471                 .this_arg = NULL,
 472                 .type_id = custom_msg_type_id,
 473                 .debug_str = custom_msg_debug,
 474                 .write = custom_msg_bytes,
 475                 .free = NULL,
 476         };
 477         return ret;
 478 }
 479
 480 uint64_t get_chan_score(const void *this_arg, uint64_t scid, const LDKNodeId *src, const LDKNodeId *dst, LDKChannelUsage usage_in) {
 481         LDK::ChannelUsage usage(std::move(usage_in));
 482         return 42;
 483 }
 484
 485 struct LDKCResult_RouteLightningErrorZ custom_find_route(const void *this_arg, struct LDKPublicKey payer, const struct LDKRouteParameters *NONNULL_PTR route_params, struct LDKCVec_ChannelDetailsZ *first_hops, const struct LDKInFlightHtlcs *in_flights) {
 486         const LDK::DefaultRouter *router = (LDK::DefaultRouter *)this_arg;
 487         assert(first_hops->datalen == 1);
 488         assert(ChannelDetails_get_is_usable(&first_hops->data[0]));
 489         const LDK::Router router_impl = DefaultRouter_as_Router(&*router);
 490         return router_impl->find_route(router_impl->this_arg, payer, route_params, first_hops, in_flights);
 491 }
 492
 493 int main() {
 494         uint8_t channel_open_header[80];
 495         uint8_t header_1[80];
 496         uint8_t header_2[80];
 497         memcpy(channel_open_header, channel_open_block, 80);
 498         memcpy(header_1, block_1, 80);
 499         memcpy(header_2, block_2, 80);
 500
 501         LDKPublicKey null_pk;
 502         memset(&null_pk, 0, sizeof(null_pk));
 503
 504         LDKThirtyTwoBytes random_bytes;
 505         LDKThirtyTwoBytes chain_tip;
 506         memset(&chain_tip, 0, sizeof(chain_tip)); // channel_open_header's prev_blockhash is all-0s
 507
 508         LDKNetwork network = LDKNetwork_Testnet;
 509
 510         // Trait implementations:
 511         LDKBroadcasterInterface broadcast {
 512                 .this_arg = NULL,
 513                 .broadcast_transaction = broadcast_tx,
 514                 .free = NULL,
 515         };
 516
 517         // Instantiate classes for the nodes that don't get reloaded on a ser-des reload
 518         LDKLogger logger1 {
 519                 .this_arg = (void*)1,
 520                 .log = print_log,
 521                 .free = NULL,
 522         };
 523
 524         NodeMonitors mons1;
 525         mons1.logger = &logger1;
 526         LDKWatch mon1 {
 527                 .this_arg = &mons1,
 528                 .watch_channel = add_channel_monitor,
 529                 .update_channel = update_channel_monitor,
 530                 .release_pending_monitor_events = monitors_pending_monitor_events,
 531                 .free = NULL,
 532         };
 533
 534         LDK::NetworkGraph net_graph1 = NetworkGraph_new(network, logger1);
 535         LDK::P2PGossipSync graph_msg_handler1 = P2PGossipSync_new(&net_graph1, COption_UtxoLookupZ_none(), logger1);
 536
 537         LDKLogger logger2 {
 538                 .this_arg = (void*)2,
 539                 .log = print_log,
 540                 .free = NULL,
 541         };
 542
 543         NodeMonitors mons2;
 544         mons2.logger = &logger2;
 545         LDKWatch mon2 {
 546                 .this_arg = &mons2,
 547                 .watch_channel = add_channel_monitor,
 548                 .update_channel = update_channel_monitor,
 549                 .release_pending_monitor_events = monitors_pending_monitor_events,
 550                 .free = NULL,
 551         };
 552
 553         LDKRouter panic_router = {
 554                 .this_arg = NULL,
 555                 .find_route = NULL, // Segfault if we ever try to find a route
 556                 .free = NULL,
 557         };
 558
 559         LDK::NetworkGraph net_graph2 = NetworkGraph_new(network, logger2);
 560         LDK::P2PGossipSync graph_msg_handler2 = P2PGossipSync_new(&net_graph2, COption_UtxoLookupZ_none(), logger2);
 561
 562         LDK::CVec_u8Z cm1_ser = LDKCVec_u8Z {}; // ChannelManager 1 serialization at the end of the ser-des scope
 563         LDK::CVec_u8Z cm2_ser = LDKCVec_u8Z {}; // ChannelManager 2 serialization at the end of the ser-des scope
 564
 565         { // Scope for the ser-des reload
 566                 // Instantiate classes for node 1:
 567                 uint8_t node_seed[32];
 568                 memset(&node_seed, 0, 32);
 569                 LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
 570                 LDK::NodeSigner node_signer1 = KeysManager_as_NodeSigner(&keys1);
 571                 LDK::EntropySource entropy_source1 = KeysManager_as_EntropySource(&keys1);
 572                 LDK::SignerProvider signer_provider1 = KeysManager_as_SignerProvider(&keys1);
 573
 574                 LDK::ChannelManager cm1 = ChannelManager_new(fee_est, mon1, broadcast, panic_router, logger1, KeysManager_as_EntropySource(&keys1), KeysManager_as_NodeSigner(&keys1), KeysManager_as_SignerProvider(&keys1), UserConfig_default(), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 575
 576                 LDK::IgnoringMessageHandler ignoring_handler1 = IgnoringMessageHandler_new();
 577                 LDK::CustomMessageHandler custom_msg_handler1 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler1);
 578                 LDK::CustomOnionMessageHandler custom_onion_msg_handler1 = IgnoringMessageHandler_as_CustomOnionMessageHandler(&ignoring_handler1);
 579
 580                 LDK::OnionMessenger om1 = OnionMessenger_new(KeysManager_as_EntropySource(&keys1), KeysManager_as_NodeSigner(&keys1), logger1, std::move(custom_onion_msg_handler1));
 581
 582                 LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
 583                 assert(channels->datalen == 0);
 584
 585                 LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1), OnionMessenger_as_OnionMessageHandler(&om1));
 586
 587                 random_bytes = entropy_source1.get_secure_random_bytes();
 588                 LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), 0xdeadbeef, &random_bytes.data, logger1, std::move(custom_msg_handler1), std::move(node_signer1));
 589
 590                 // Demo getting a channel key and check that its returning real pubkeys:
 591                 LDKSixteenBytes user_id_1 { .data = {45, 0, 0, 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 0} };
 592                 LDKThirtyTwoBytes chan_signer_id1 = signer_provider1.generate_channel_keys_id(false, 42, U128_new(user_id_1));
 593                 LDK::WriteableEcdsaChannelSigner chan_signer1 = signer_provider1.derive_channel_signer(42, chan_signer_id1);
 594                 chan_signer1->EcdsaChannelSigner.ChannelSigner.set_pubkeys(&chan_signer1->EcdsaChannelSigner.ChannelSigner); // Make sure pubkeys is defined
 595                 LDKPublicKey payment_point = ChannelPublicKeys_get_payment_point(&chan_signer1->EcdsaChannelSigner.ChannelSigner.pubkeys);
 596                 assert(memcmp(&payment_point, &null_pk, sizeof(null_pk)));
 597
 598                 // Instantiate classes for node 2:
 599                 memset(&node_seed, 1, 32);
 600                 LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
 601                 LDK::NodeSigner node_signer2 = KeysManager_as_NodeSigner(&keys2);
 602                 LDK::EntropySource entropy_source2 = KeysManager_as_EntropySource(&keys2);
 603                 LDK::SignerProvider signer_provider2 = KeysManager_as_SignerProvider(&keys2);
 604
 605                 LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
 606                 ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
 607                 LDK::UserConfig config2 = UserConfig_default();
 608                 UserConfig_set_channel_handshake_config(&config2, std::move(handshake_config2));
 609
 610                 LDK::ChannelManager cm2 = ChannelManager_new(fee_est, mon2, broadcast, panic_router, logger2, KeysManager_as_EntropySource(&keys2), KeysManager_as_NodeSigner(&keys2), KeysManager_as_SignerProvider(&keys2), std::move(config2), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 611
 612                 LDK::IgnoringMessageHandler ignoring_handler2 = IgnoringMessageHandler_new();
 613                 LDK::CustomMessageHandler custom_msg_handler2 = IgnoringMessageHandler_as_CustomMessageHandler(&ignoring_handler2);
 614                 LDK::CustomOnionMessageHandler custom_onion_msg_handler2 = IgnoringMessageHandler_as_CustomOnionMessageHandler(&ignoring_handler2);
 615
 616                 LDK::OnionMessenger om2 = OnionMessenger_new(KeysManager_as_EntropySource(&keys2), KeysManager_as_NodeSigner(&keys2), logger2, std::move(custom_onion_msg_handler2));
 617
 618                 LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
 619                 assert(channels2->datalen == 0);
 620
 621                 LDK::RoutingMessageHandler net_msgs2 = P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2);
 622                 LDK::CResult_ChannelAnnouncementDecodeErrorZ chan_ann = ChannelAnnouncement_read(LDKu8slice { .data = valid_node_announcement, .datalen = sizeof(valid_node_announcement) });
 623                 assert(chan_ann->result_ok);
 624                 LDK::CResult_boolLightningErrorZ ann_res = net_msgs2->handle_channel_announcement(net_msgs2->this_arg, chan_ann->contents.result);
 625                 assert(ann_res->result_ok);
 626
 627                 LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2), OnionMessenger_as_OnionMessageHandler(&om1));
 628
 629                 random_bytes = entropy_source2.get_secure_random_bytes();
 630                 LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), 0xdeadbeef, &random_bytes.data, logger2, std::move(custom_msg_handler2), std::move(node_signer2));
 631
 632                 // Open a connection!
 633                 PeersConnection conn(cm1, cm2, net1, net2);
 634
 635                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 636                 LDK::CResult__u832APIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, U128_new(user_id_1), UserConfig_default());
 637                 assert(res->result_ok);
 638                 PeerManager_process_events(&net1);
 639
 640                 LDK::CVec_ChannelDetailsZ new_channels = ChannelManager_list_channels(&cm1);
 641                 assert(new_channels->datalen == 1);
 642                 LDK::ChannelCounterparty new_channels_counterparty = ChannelDetails_get_counterparty(&new_channels->data[0]);
 643                 LDKPublicKey chan_open_pk = ChannelCounterparty_get_node_id(&new_channels_counterparty);
 644                 assert(!memcmp(chan_open_pk.compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 645
 646                 while (true) {
 647                         LDK::CVec_ChannelDetailsZ new_channels_2 = ChannelManager_list_channels(&cm2);
 648                         if (new_channels_2->datalen == 1) {
 649                                 // Sample getting our counterparty's init features (which used to be hard to do without a memory leak):
 650                                 LDK::ChannelCounterparty new_channels_2_counterparty = ChannelDetails_get_counterparty(&new_channels_2->data[0]);
 651                                 const LDK::InitFeatures init_feats = ChannelCounterparty_get_features(&new_channels_2_counterparty);
 652                                 assert(init_feats->inner != NULL);
 653                                 break;
 654                         }
 655                         std::this_thread::yield();
 656                 }
 657
 658                 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 659                 while (true) {
 660                         EventQueue queue;
 661                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 662                         ev1.process_pending_events(handler);
 663                         if (queue.events.size() == 1) {
 664                                 assert(queue.events[0]->tag == LDKEvent_FundingGenerationReady);
 665                                 LDKSixteenBytes event_id = U128_le_bytes(queue.events[0]->funding_generation_ready.user_channel_id);
 666                                 assert(!memcmp(&event_id, &user_id_1, 16));
 667                                 assert(queue.events[0]->funding_generation_ready.channel_value_satoshis == 40000);
 668                                 assert(queue.events[0]->funding_generation_ready.output_script.datalen == 34);
 669
 670                                 assert(!memcmp(queue.events[0]->funding_generation_ready.output_script.data, channel_open_block + 58 + 81, 34));
 671                                 LDKTransaction funding_transaction { .data = const_cast<uint8_t*>(channel_open_block + 81), .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false };
 672
 673                                 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);
 674                                 assert(fund_res->result_ok);
 675                                 break;
 676                         }
 677                         std::this_thread::yield();
 678                 }
 679
 680                 // We observe when the funding signed messages have been exchanged by
 681                 // waiting for two monitors to be registered.
 682                 assert(num_txs_broadcasted == 0);
 683                 PeerManager_process_events(&net1);
 684                 while (num_txs_broadcasted != 1) {
 685                         std::this_thread::yield();
 686                 }
 687
 688                 LDK::Listen listener1 = ChannelManager_as_Listen(&cm1);
 689                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 690
 691                 LDK::Listen listener2 = ChannelManager_as_Listen(&cm2);
 692                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 693
 694                 LDKCVec_C2Tuple_usizeTransactionZZ txdata { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 695                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 696                 mons1.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 697
 698                 txdata = LDKCVec_C2Tuple_usizeTransactionZZ { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 699                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 700                 mons2.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 701
 702                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 703                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 704                 mons1.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 705                 mons2.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 706
 707                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 708                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 709                 mons1.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 710                 mons2.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 711
 712                 PeerManager_process_events(&net1);
 713                 PeerManager_process_events(&net2);
 714
 715                 // Note that the channel ID is the same as the channel txid reversed as the output index is 0
 716                 uint8_t expected_chan_id[32];
 717                 for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; }
 718
 719                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 720                 while (true) {
 721                         EventQueue queue;
 722                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 723                         ev2.process_pending_events(handler);
 724                         if (queue.events.size() == 1) {
 725                                 assert(queue.events[0]->tag == LDKEvent_ChannelReady);
 726                                 assert(!memcmp(queue.events[0]->channel_ready.channel_id.data, expected_chan_id, 32));
 727                                 break;
 728                         }
 729                         std::this_thread::yield();
 730                 }
 731
 732                 while (true) {
 733                         EventQueue queue;
 734                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 735                         ev1.process_pending_events(handler);
 736                         if (queue.events.size() == 1) {
 737                                 assert(queue.events[0]->tag == LDKEvent_ChannelReady);
 738                                 assert(!memcmp(queue.events[0]->channel_ready.channel_id.data, expected_chan_id, 32));
 739                                 break;
 740                         }
 741                         std::this_thread::yield();
 742                 }
 743
 744                 // Now send funds from 1 to 2!
 745                 uint64_t channel_scid;
 746                 while (true) {
 747                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 748                         if (outbound_channels->datalen == 1) {
 749                                 const LDKChannelDetails *channel = &outbound_channels->data[0];
 750                                 LDK::ChannelCounterparty counterparty = ChannelDetails_get_counterparty(channel);
 751
 752                                 assert(!memcmp(ChannelDetails_get_channel_id(channel), expected_chan_id, 32));
 753                                 assert(!memcmp(
 754                                         ChannelCounterparty_get_node_id(&counterparty).compressed_form,
 755                                         ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 756                                 assert(ChannelDetails_get_channel_value_satoshis(channel) == 40000);
 757                                 // We opened the channel with 1000 push_msat:
 758                                 assert(ChannelDetails_get_outbound_capacity_msat(channel) ==
 759                                         40000*1000 - 1000 - 1000 * ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty));
 760                                 int64_t inbound_capacity = ((int64_t)1000) - ChannelCounterparty_get_unspendable_punishment_reserve(&counterparty);
 761                                 if (inbound_capacity < 0) inbound_capacity = 0;
 762                                 assert(ChannelDetails_get_inbound_capacity_msat(channel) == (uint64_t)inbound_capacity);
 763                                 assert(ChannelDetails_get_is_usable(channel));
 764                                 LDK::COption_u64Z scid_opt = ChannelDetails_get_short_channel_id(channel);
 765                                 assert(scid_opt->some);
 766                                 channel_scid = scid_opt->some;
 767                                 break;
 768                         }
 769                         std::this_thread::yield();
 770                 }
 771
 772                 LDKCOption_u64Z min_value = {
 773                         .tag = LDKCOption_u64Z_Some,
 774                         .some = 5000,
 775                 };
 776                 LDK::CResult_InvoiceSignOrCreationErrorZ invoice = create_invoice_from_channelmanager(&cm2,
 777                         KeysManager_as_NodeSigner(&keys2), logger2,
 778                         LDKCurrency_Bitcoin, min_value,
 779                         LDKStr {
 780                                 .chars = (const uint8_t *)"Invoice Description",
 781                                 .len =             strlen("Invoice Description"),
 782                                 .chars_is_owned = false
 783                         }, 3600, COption_u16Z_none());
 784                 assert(invoice->result_ok);
 785                 LDKThirtyTwoBytes payment_hash;
 786                 memcpy(payment_hash.data, Invoice_payment_hash(invoice->contents.result), 32);
 787
 788                 {
 789                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 790                         LDK::Score chan_scorer = LDKScore {
 791                                 .this_arg = NULL, .channel_penalty_msat = get_chan_score, .free = NULL
 792                         };
 793                         LDK::RouteParameters route_params = RouteParameters_new(PaymentParameters_new(
 794                                         ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
 795                                                 .inner = NULL, .is_owned = false
 796                                         }, Invoice_route_hints(invoice->contents.result), COption_u64Z_none(), 0xffffffff,
 797                                         1, 2, LDKCVec_u64Z { .data = NULL, .datalen = 0 },
 798                                         Invoice_min_final_cltv_expiry_delta(invoice->contents.result)),
 799                                 5000);
 800                         random_bytes = entropy_source1.get_secure_random_bytes();
 801
 802                         LDK::CResult_RouteLightningErrorZ route = find_route(ChannelManager_get_our_node_id(&cm1), &route_params, &net_graph2, &outbound_channels, logger1, &chan_scorer, &random_bytes.data);
 803
 804                         assert(route->result_ok);
 805                         LDK::CVec_CVec_RouteHopZZ paths = Route_get_paths(route->contents.result);
 806                         assert(paths->datalen == 1);
 807                         assert(paths->data[0].datalen == 1);
 808                         assert(!memcmp(RouteHop_get_pubkey(&paths->data[0].data[0]).compressed_form,
 809                                 ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 810                         assert(RouteHop_get_short_channel_id(&paths->data[0].data[0]) == channel_scid);
 811                         LDKThirtyTwoBytes payment_secret;
 812                         memcpy(payment_secret.data, Invoice_payment_secret(invoice->contents.result), 32);
 813                         LDK::CResult_NonePaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash, payment_secret, payment_hash);
 814                         assert(send_res->result_ok);
 815                 }
 816
 817                 mons_updated = 0;
 818                 PeerManager_process_events(&net1);
 819                 while (mons_updated != 4) {
 820                         std::this_thread::yield();
 821                 }
 822
 823                 // Check that we received the payment!
 824                 while (true) {
 825                         EventQueue queue;
 826                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 827                         ev2.process_pending_events(handler);
 828                         if (queue.events.size() == 1) {
 829                                 assert(queue.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
 830                                 break;
 831                         }
 832                         std::this_thread::yield();
 833                 }
 834                 ChannelManager_process_pending_htlc_forwards(&cm2);
 835                 PeerManager_process_events(&net2);
 836
 837                 mons_updated = 0;
 838                 LDKThirtyTwoBytes payment_preimage;
 839                 {
 840                         EventQueue queue;
 841                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 842                         ev2.process_pending_events(handler);
 843                         assert(queue.events.size() == 1);
 844                         assert(queue.events[0]->tag == LDKEvent_PaymentClaimable);
 845                         assert(!memcmp(queue.events[0]->payment_claimable.payment_hash.data, payment_hash.data, 32));
 846                         assert(queue.events[0]->payment_claimable.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 847                         assert(!memcmp(queue.events[0]->payment_claimable.purpose.invoice_payment.payment_secret.data,
 848                                         Invoice_payment_secret(invoice->contents.result), 32));
 849                         assert(queue.events[0]->payment_claimable.amount_msat == 5000);
 850                         memcpy(payment_preimage.data, queue.events[0]->payment_claimable.purpose.invoice_payment.payment_preimage.data, 32);
 851                         ChannelManager_claim_funds(&cm2, payment_preimage);
 852
 853                         queue.events.clear();
 854                         ev2.process_pending_events(handler);
 855                         assert(queue.events.size() == 1);
 856                         assert(queue.events[0]->tag == LDKEvent_PaymentClaimed);
 857                         assert(!memcmp(queue.events[0]->payment_claimed.payment_hash.data, payment_hash.data, 32));
 858                         assert(queue.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
 859                 }
 860                 PeerManager_process_events(&net2);
 861                 // Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages)
 862                 while (mons_updated != 5) {
 863                         std::this_thread::yield();
 864                 }
 865                 {
 866                         EventQueue queue;
 867                         LDKEventHandler handler = { .this_arg = &queue, .handle_event = handle_event, .free = NULL };
 868                         while (queue.events.size() < 2)
 869                                 ev1.process_pending_events(handler);
 870                         assert(queue.events.size() == 2);
 871                         assert(queue.events[0]->tag == LDKEvent_PaymentSent);
 872                         assert(!memcmp(queue.events[0]->payment_sent.payment_preimage.data, payment_preimage.data, 32));
 873                         assert(queue.events[1]->tag == LDKEvent_PaymentPathSuccessful);
 874                         assert(!memcmp(queue.events[1]->payment_path_successful.payment_hash.data, payment_hash.data, 32));
 875                 }
 876
 877                 conn.stop();
 878
 879                 cm1_ser = ChannelManager_write(&cm1);
 880                 cm2_ser = ChannelManager_write(&cm2);
 881         }
 882
 883         LDK::CVec_ChannelMonitorZ mons_list1 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 884         assert(mons1.mons.size() == 1);
 885         mons_list1->data[0] = *& std::get<1>(mons1.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 886         mons_list1->data[0].is_owned = false; // XXX: God this sucks
 887         uint8_t node_seed[32];
 888         memset(&node_seed, 0, 32);
 889         LDK::KeysManager keys1 = KeysManager_new(&node_seed, 1, 0);
 890         LDK::NodeSigner node_signer1 = KeysManager_as_NodeSigner(&keys1);
 891         LDK::EntropySource entropy_source1 = KeysManager_as_EntropySource(&keys1);
 892         LDK::SignerProvider signer_provider1 = KeysManager_as_SignerProvider(&keys1);
 893
 894         LDK::ProbabilisticScorer scorer1 = ProbabilisticScorer_new(ProbabilisticScoringParameters_default(), &net_graph1, logger1);
 895         LDK::Score scorer_trait1 = ProbabilisticScorer_as_Score(&scorer1);
 896         LDK::MultiThreadedLockableScore scorer_mtx1 = MultiThreadedLockableScore_new(std::move(scorer_trait1));
 897         LDK::LockableScore scorer_mtx_trait1 = MultiThreadedLockableScore_as_LockableScore(&scorer_mtx1);
 898         const LDK::DefaultRouter default_router_1 = DefaultRouter_new(&net_graph1, logger1, entropy_source1.get_secure_random_bytes(), std::move(scorer_mtx_trait1));
 899         LDKRouter router1 = {
 900                 .this_arg = (void*)&default_router_1,
 901                 .find_route = custom_find_route,
 902                 .free = NULL,
 903         };
 904
 905         LDK::ChannelManagerReadArgs cm1_args = ChannelManagerReadArgs_new(KeysManager_as_EntropySource(&keys1), KeysManager_as_NodeSigner(&keys1), KeysManager_as_SignerProvider(&keys1), fee_est, mon1, broadcast, router1, logger1, UserConfig_default(), std::move(mons_list1));
 906         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm1_read =
 907                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm1_ser->data, .datalen = cm1_ser -> datalen}, std::move(cm1_args));
 908         assert(cm1_read->result_ok);
 909         LDK::ChannelManager cm1(std::move(cm1_read->contents.result->b));
 910
 911         LDKCustomOnionMessageHandler custom_onion_msg_handler1 = {
 912                 .this_arg = NULL,
 913                 .handle_custom_message = NULL, // We only create custom messages, not handle them
 914                 .read_custom_message = NULL, // We only create custom messages, not handle them
 915                 .free = NULL,
 916         };
 917         LDK::OnionMessenger om1 = OnionMessenger_new(KeysManager_as_EntropySource(&keys1), KeysManager_as_NodeSigner(&keys1), logger1, custom_onion_msg_handler1);
 918
 919         LDK::CVec_ChannelMonitorZ mons_list2 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 920         assert(mons2.mons.size() == 1);
 921         mons_list2->data[0] = *& std::get<1>(mons2.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 922         mons_list2->data[0].is_owned = false; // XXX: God this sucks
 923         memset(&node_seed, 1, 32);
 924         LDK::KeysManager keys2 = KeysManager_new(&node_seed, 1, 0);
 925         LDK::NodeSigner node_signer2 = KeysManager_as_NodeSigner(&keys2);
 926         LDK::EntropySource entropy_source2 = KeysManager_as_EntropySource(&keys2);
 927         LDK::SignerProvider signer_provider2 = KeysManager_as_SignerProvider(&keys2);
 928
 929         LDK::ChannelManagerReadArgs cm2_args = ChannelManagerReadArgs_new(KeysManager_as_EntropySource(&keys2), KeysManager_as_NodeSigner(&keys2), KeysManager_as_SignerProvider(&keys2), fee_est, mon2, broadcast, panic_router, logger2, UserConfig_default(), std::move(mons_list2));
 930         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm2_read =
 931                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm2_ser->data, .datalen = cm2_ser -> datalen}, std::move(cm2_args));
 932         assert(cm2_read->result_ok);
 933         LDK::ChannelManager cm2(std::move(cm2_read->contents.result->b));
 934
 935         CustomOnionMsgQueue peer_2_custom_onion_messages;
 936         LDKCustomOnionMessageHandler custom_onion_msg_handler2 = {
 937                 .this_arg = &peer_2_custom_onion_messages,
 938                 .handle_custom_message = handle_custom_onion_message,
 939                 .read_custom_message = read_custom_onion_message,
 940                 .free = NULL,
 941         };
 942         LDK::OnionMessenger om2 = OnionMessenger_new(KeysManager_as_EntropySource(&keys2), KeysManager_as_NodeSigner(&keys2), logger2, custom_onion_msg_handler2);
 943
 944         // Attempt to close the channel...
 945         uint8_t chan_id[32];
 946         for (int i = 0; i < 32; i++) { chan_id[i] = channel_open_txid[31-i]; }
 947         LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
 948         assert(!close_res->result_ok); // Note that we can't close while disconnected!
 949
 950         // Open a connection!
 951         LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1), OnionMessenger_as_OnionMessageHandler(&om1));
 952         random_bytes = entropy_source1.get_secure_random_bytes();
 953
 954         LDKPublicKey chan_2_node_id = ChannelManager_get_our_node_id(&cm2);
 955         LDKCustomMessageHandler custom_msg_handler1 = {
 956                 .this_arg = &chan_2_node_id,
 957                 .handle_custom_message = NULL, // We only create custom messages, not handle them
 958                 .get_and_clear_pending_msg = create_custom_msg,
 959                 .CustomMessageReader = LDKCustomMessageReader {
 960                         .this_arg = NULL,
 961                         .read = read_custom_message,
 962                         .free = NULL,
 963                 },
 964                 .free = NULL,
 965         };
 966         LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), 0xdeadbeef, &random_bytes.data, logger1, std::move(custom_msg_handler1), std::move(node_signer1));
 967
 968         LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler2), OnionMessenger_as_OnionMessageHandler(&om2));
 969         CustomMsgQueue peer_2_custom_messages;
 970         LDKCustomMessageHandler custom_msg_handler2 = {
 971                 .this_arg = &peer_2_custom_messages,
 972                 .handle_custom_message = handle_custom_message,
 973                 .get_and_clear_pending_msg = never_send_custom_msgs,
 974                 .CustomMessageReader = LDKCustomMessageReader {
 975                         .this_arg = NULL,
 976                         .read = read_custom_message,
 977                         .free = NULL,
 978                 },
 979                 .free = NULL,
 980         };
 981         random_bytes = entropy_source1.get_secure_random_bytes();
 982         LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), 0xdeadbeef, &random_bytes.data, logger2, std::move(custom_msg_handler2), std::move(node_signer2));
 983
 984         PeersConnection conn(cm1, cm2, net1, net2);
 985
 986         while (true) {
 987                 // Wait for the channels to be considered up once the reestablish messages are processed
 988                 LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 989                 if (outbound_channels->datalen == 1) {
 990                         break;
 991                 }
 992         }
 993
 994         // Send another payment, this time via the retires path
 995         LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
 996                 KeysManager_as_NodeSigner(&keys2), logger1,
 997                 LDKCurrency_Bitcoin, COption_u64Z_some(10000),
 998                 LDKStr {
 999                         .chars = (const uint8_t *)"Invoice 2 Description",
1000                         .len =             strlen("Invoice 2 Description"),
1001                         .chars_is_owned = false
1002                 }, 3600, COption_u16Z_none());
1003         assert(invoice_res2->result_ok);
1004         const LDKInvoice *invoice2 = invoice_res2->contents.result;
1005         LDK::CResult_PaymentIdPaymentErrorZ invoice_pay_res = pay_invoice(invoice2, Retry_attempts(0), &cm1);
1006         assert(invoice_pay_res->result_ok);
1007         PeerManager_process_events(&net1);
1008
1009         // Check that we received the payment!
1010         while (true) {
1011                 EventQueue queue2;
1012                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
1013                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
1014                 ev2.process_pending_events(handler2);
1015                 if (queue2.events.size() == 1) {
1016                         assert(queue2.events[0]->tag == LDKEvent_PendingHTLCsForwardable);
1017                         break;
1018                 }
1019                 std::this_thread::yield();
1020         }
1021         ChannelManager_process_pending_htlc_forwards(&cm2);
1022         PeerManager_process_events(&net2);
1023
1024         while (true) {
1025                 EventQueue queue2;
1026                 LDKEventHandler handler2 = { .this_arg = &queue2, .handle_event = handle_event, .free = NULL };
1027                 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
1028                 ev2.process_pending_events(handler2);
1029                 if (queue2.events.size() == 1) {
1030                         assert(queue2.events[0]->tag == LDKEvent_PaymentClaimable);
1031                         const struct LDKEvent_LDKPaymentClaimable_Body *event_data = &queue2.events[0]->payment_claimable;
1032                         assert(!memcmp(event_data->payment_hash.data, Invoice_payment_hash(invoice2), 32));
1033                         assert(event_data->purpose.tag == LDKPaymentPurpose_InvoicePayment);
1034                         assert(!memcmp(event_data->purpose.invoice_payment.payment_secret.data,
1035                                         Invoice_payment_secret(invoice2), 32));
1036                         assert(event_data->amount_msat == 10000);
1037                         ChannelManager_claim_funds(&cm2, event_data->purpose.invoice_payment.payment_preimage);
1038
1039                         queue2.events.clear();
1040                         ev2.process_pending_events(handler2);
1041                         assert(queue2.events.size() == 1);
1042                         assert(queue2.events[0]->tag == LDKEvent_PaymentClaimed);
1043                         assert(!memcmp(queue2.events[0]->payment_claimed.payment_hash.data, Invoice_payment_hash(invoice2), 32));
1044                         assert(queue2.events[0]->payment_claimed.purpose.tag == LDKPaymentPurpose_InvoicePayment);
1045
1046                         break;
1047                 }
1048                 std::this_thread::yield();
1049         }
1050
1051         EventQueue queue1;
1052         LDKEventHandler handler1 = { .this_arg = &queue1, .handle_event = handle_event, .free = NULL };
1053         while (queue1.events.size() < 2) {
1054                 PeerManager_process_events(&net2);
1055                 PeerManager_process_events(&net1);
1056
1057                 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
1058                 ev1.process_pending_events(handler1);
1059         }
1060         assert(queue1.events.size() == 2);
1061         assert(queue1.events[0]->tag == LDKEvent_PaymentSent);
1062         assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful);
1063
1064         // Actually close the channel
1065         num_txs_broadcasted = 0;
1066         close_res = ChannelManager_close_channel(&cm1, &chan_id, ChannelManager_get_our_node_id(&cm2));
1067         assert(close_res->result_ok);
1068         PeerManager_process_events(&net1);
1069         while (num_txs_broadcasted != 2) {
1070                 std::this_thread::yield();
1071         }
1072         LDK::CVec_ChannelDetailsZ chans_after_close1 = ChannelManager_list_channels(&cm1);
1073         assert(chans_after_close1->datalen == 0);
1074         LDK::CVec_ChannelDetailsZ chans_after_close2 = ChannelManager_list_channels(&cm2);
1075         assert(chans_after_close2->datalen == 0);
1076
1077         assert(OnionMessenger_send_onion_message(&om1,
1078                         LDKCVec_PublicKeyZ { .data = NULL, .datalen = 0, },
1079                         Destination_node(ChannelManager_get_our_node_id(&cm2)),
1080                         LDKOnionMessageContents {
1081                                 .tag = LDKOnionMessageContents_Custom,
1082                                 .custom = build_custom_onion_message()
1083                         }, LDKBlindedPath { .inner = NULL, .is_owned = true })
1084                 .result_ok);
1085         PeerManager_process_events(&net1);
1086         while (true) {
1087                 std::this_thread::yield();
1088                 std::unique_lock<std::mutex> lck(peer_2_custom_onion_messages.mtx);
1089                 if (peer_2_custom_onion_messages.msgs.size() != 0) break;
1090         }
1091
1092         conn.stop();
1093
1094         std::unique_lock<std::mutex> lck(peer_2_custom_onion_messages.mtx);
1095         assert(peer_2_custom_onion_messages.msgs.size() == 1);
1096         assert(peer_2_custom_onion_messages.msgs[0].tlv_type() == 8888);
1097         assert(peer_2_custom_messages.msgs.size() != 0);
1098
1099         // Few extra random tests:
1100         LDKSecretKey sk;
1101         memset(&sk, 42, 32);
1102         LDKThirtyTwoBytes kdiv_params;
1103         memset(&kdiv_params, 43, 32);
1104         LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params);
1105 }