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