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

   1 extern "C" {
   2 #include "include/rust_types.h"
   3 #include "include/lightning.h"
   4 }
   5 #include "include/lightningpp.hpp"
   6
   7 #include <assert.h>
   8 #include <stdio.h>
   9 #include <sys/socket.h>
  10 #include <unistd.h>
  11
  12 #include <atomic>
  13 #include <chrono>
  14 #include <functional>
  15 #include <thread>
  16 #include <mutex>
  17 #include <vector>
  18
  19 const uint8_t valid_node_announcement[] = {
  20         0x94, 0xe4, 0xf5, 0x61, 0x41, 0x24, 0x7d, 0x90, 0x23, 0xa0, 0xc8, 0x34, 0x8c, 0xc4, 0xca, 0x51,
  21         0xd8, 0x17, 0x59, 0xff, 0x7d, 0xac, 0x8c, 0x9b, 0x63, 0x29, 0x1c, 0xe6, 0x12, 0x12, 0x93, 0xbd,
  22         0x66, 0x4d, 0x6b, 0x9c, 0xfb, 0x35, 0xda, 0x16, 0x06, 0x3d, 0xf0, 0x8f, 0x8a, 0x39, 0x99, 0xa2,
  23         0xf2, 0x5d, 0x12, 0x0f, 0x2b, 0x42, 0x1b, 0x8b, 0x9a, 0xfe, 0x33, 0x0c, 0xeb, 0x33, 0x5e, 0x52,
  24         0xee, 0x99, 0xa1, 0x07, 0x06, 0xed, 0xf8, 0x48, 0x7a, 0xc6, 0xe5, 0xf5, 0x5e, 0x01, 0x3a, 0x41,
  25         0x2f, 0x18, 0x94, 0x8a, 0x3b, 0x0a, 0x52, 0x3f, 0xbf, 0x61, 0xa9, 0xc5, 0x4f, 0x70, 0xee, 0xb8,
  26         0x79, 0x23, 0xbb, 0x1a, 0x44, 0x7d, 0x91, 0xe6, 0x2a, 0xbc, 0xa1, 0x07, 0xbc, 0x65, 0x3b, 0x02,
  27         0xd9, 0x1d, 0xb2, 0xf2, 0x3a, 0xcb, 0x75, 0x79, 0xc6, 0x66, 0xd8, 0xc1, 0x71, 0x29, 0xdf, 0x04,
  28         0x60, 0xf4, 0xbf, 0x07, 0x7b, 0xb9, 0xc2, 0x11, 0x94, 0x6a, 0x28, 0xc2, 0xdd, 0xd8, 0x7b, 0x44,
  29         0x8f, 0x08, 0xe3, 0xc8, 0xd8, 0xf4, 0x81, 0xb0, 0x9f, 0x94, 0xcb, 0xc8, 0xc1, 0x3c, 0xc2, 0x6e,
  30         0x31, 0x26, 0xfc, 0x33, 0x16, 0x3b, 0xe0, 0xde, 0xa1, 0x16, 0x21, 0x9f, 0x89, 0xdd, 0x97, 0xa4,
  31         0x41, 0xf2, 0x9f, 0x19, 0xb1, 0xae, 0x82, 0xf7, 0x85, 0x9a, 0xb7, 0x8f, 0xb7, 0x52, 0x7a, 0x72,
  32         0xf1, 0x5e, 0x89, 0xe1, 0x8a, 0xcd, 0x40, 0xb5, 0x8e, 0xc3, 0xca, 0x42, 0x76, 0xa3, 0x6e, 0x1b,
  33         0xf4, 0x87, 0x35, 0x30, 0x58, 0x43, 0x04, 0xd9, 0x2c, 0x50, 0x54, 0x55, 0x47, 0x6f, 0x70, 0x9b,
  34         0x42, 0x1f, 0x91, 0xfc, 0xa1, 0xdb, 0x72, 0x53, 0x96, 0xc8, 0xe5, 0xcd, 0x0e, 0xcb, 0xa0, 0xfe,
  35         0x6b, 0x08, 0x77, 0x48, 0xb7, 0xad, 0x4a, 0x69, 0x7c, 0xdc, 0xd8, 0x04, 0x28, 0x35, 0x9b, 0x73,
  36         0x00, 0x00, 0x43, 0x49, 0x7f, 0xd7, 0xf8, 0x26, 0x95, 0x71, 0x08, 0xf4, 0xa3, 0x0f, 0xd9, 0xce,
  37         0xc3, 0xae, 0xba, 0x79, 0x97, 0x20, 0x84, 0xe9, 0x0e, 0xad, 0x01, 0xea, 0x33, 0x09, 0x00, 0x00,
  38         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x5b, 0xe5, 0xe9, 0x47, 0x82,
  39         0x09, 0x67, 0x4a, 0x96, 0xe6, 0x0f, 0x1f, 0x03, 0x7f, 0x61, 0x76, 0x54, 0x0f, 0xd0, 0x01, 0xfa,
  40         0x1d, 0x64, 0x69, 0x47, 0x70, 0xc5, 0x6a, 0x77, 0x09, 0xc4, 0x2c, 0x03, 0x5c, 0x4e, 0x0d, 0xec,
  41         0x72, 0x15, 0xe2, 0x68, 0x33, 0x93, 0x87, 0x30, 0xe5, 0xe5, 0x05, 0xaa, 0x62, 0x50, 0x4d, 0xa8,
  42         0x5b, 0xa5, 0x71, 0x06, 0xa4, 0x6b, 0x5a, 0x24, 0x04, 0xfc, 0x9d, 0x8e, 0x02, 0xba, 0x72, 0xa6,
  43         0xe8, 0xba, 0x53, 0xe8, 0xb9, 0x71, 0xad, 0x0c, 0x98, 0x23, 0x96, 0x8a, 0xef, 0x4d, 0x78, 0xce,
  44         0x8a, 0xf2, 0x55, 0xab, 0x43, 0xdf, 0xf8, 0x30, 0x03, 0xc9, 0x02, 0xfb, 0x8d, 0x02, 0x16, 0x34,
  45         0x5b, 0xf8, 0x31, 0x16, 0x4a, 0x03, 0x75, 0x8e, 0xae, 0xa5, 0xe8, 0xb6, 0x6f, 0xee, 0x2b, 0xe7,
  46         0x71, 0x0b, 0x8f, 0x19, 0x0e, 0xe8, 0x80, 0x24, 0x90, 0x32, 0xa2, 0x9e, 0xd6, 0x6e
  47 };
  48
  49 // A simple block containing only one transaction (which is the channel-open transaction for the
  50 // channel we'll create). This was originally created by printing additional data in a simple
  51 // rust-lightning unit test.
  52 const uint8_t channel_open_block[] = {
  53         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  54         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  55         0x00, 0x00, 0x00, 0x00, 0xa2, 0x47, 0xd2, 0xf8, 0xd4, 0xe0, 0x6a, 0x3f, 0xf9, 0x7a, 0x9a, 0x34,
  56         0xbb, 0xa9, 0x96, 0xde, 0x63, 0x84, 0x5a, 0xce, 0xcf, 0x98, 0xb8, 0xbb, 0x75, 0x4c, 0x4f, 0x7d,
  57         0xee, 0x4c, 0xa9, 0x5f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  58         0x01, // transaction count
  59         0x02, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  60         0x00, 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         0x01, 0x40, 0x9c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0x20, 0xd1, 0xd9, 0x13, 0xa9,
  63         0x76, 0x09, 0x05, 0xa3, 0x4d, 0x13, 0x5b, 0x69, 0xaa, 0xe7, 0x79, 0x71, 0xb9, 0x75, 0xa1, 0xd0,
  64         0x77, 0xcb, 0xa2, 0xf6, 0x6a, 0x25, 0x37, 0x3a, 0xaf, 0xdc, 0x11, 0x09, 0x01, 0x00, 0x00, 0x00,
  65         0x00, 0x00
  66 };
  67
  68 // The first transaction in the block is header (80 bytes) + transaction count (1 byte) into the block data.
  69 const uint8_t channel_open_txid[] = {
  70         0x02, 0xe0, 0x50, 0x05, 0x33, 0xd3, 0x29, 0x66, 0x0c, 0xb2, 0xcb, 0x1e, 0x7a, 0x4a, 0xc7, 0xc7,
  71         0x8b, 0x02, 0x46, 0x7e, 0x30, 0x2c, 0xe6, 0x19, 0xce, 0x43, 0x3e, 0xdf, 0x43, 0x65, 0xae, 0xf9,
  72 };
  73
  74 // Two blocks built on top of channel_open_block:
  75 const uint8_t block_1[81] = {
  76         0x01, 0x00, 0x00, 0x00, 0x0c, 0x7a, 0xc2, 0xdc, 0x08, 0xaf, 0x40, 0x7d, 0x58, 0x81, 0x9b, 0x44,
  77         0xc7, 0xe0, 0x0f, 0x78, 0xc0, 0xd1, 0x01, 0xa2, 0x03, 0x16, 0x4a, 0x8d, 0x92, 0x66, 0x4e, 0xaf,
  78         0x7f, 0xfc, 0x6e, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  79         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  80         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  81         0x00, // transaction count
  82 };
  83 const uint8_t block_2[81] = {
  84         0x01, 0x00, 0x00, 0x00, 0x36, 0x0b, 0xf5, 0x46, 0x4a, 0xc7, 0x26, 0x4c, 0x4b, 0x36, 0xa6, 0x9d,
  85         0x0e, 0xf0, 0x14, 0xfb, 0x8a, 0xcb, 0x20, 0x84, 0x18, 0xf3, 0xaa, 0x77, 0x32, 0x2d, 0xf7, 0x48,
  86         0x62, 0x92, 0xb1, 0xb4, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  89         0x00, // transaction count
  90 };
  91
  92 const LDKThirtyTwoBytes payment_preimage_1 = {
  93         .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 }
  94 };
  95 const LDKThirtyTwoBytes payment_hash_1 = {
  96         .data = {
  97                 0xdc, 0xb1, 0xac, 0x4a, 0x5d, 0xe3, 0x70, 0xca, 0xd0, 0x91, 0xc1, 0x3f, 0x13, 0xae, 0xe2, 0xf9,
  98                 0x36, 0xc2, 0x78, 0xfa, 0x05, 0xd2, 0x64, 0x65, 0x3c, 0x0c, 0x13, 0x21, 0x85, 0x2a, 0x35, 0xe8
  99         }
 100 };
 101
 102 const LDKThirtyTwoBytes genesis_hash = { // We don't care particularly if this is "right"
 103         .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 }
 104 };
 105
 106 void print_log(const void *this_arg, const char *record) {
 107         printf("%p - %s\n", this_arg, record);
 108 }
 109
 110 uint32_t get_fee(const void *this_arg, LDKConfirmationTarget target) {
 111         if (target == LDKConfirmationTarget_Background) {
 112                 return 253;
 113         } else {
 114                 return 507;
 115         }
 116         // Note that we don't call _free() on target, but that's OK, its unitary
 117 }
 118 // We use the same fee estimator globally:
 119 const LDKFeeEstimator fee_est {
 120         .this_arg = NULL,
 121         .get_est_sat_per_1000_weight = get_fee,
 122         .free = NULL,
 123 };
 124
 125 static std::atomic_int num_txs_broadcasted(0);
 126 void broadcast_tx(const void *this_arg, LDKTransaction tx) {
 127         num_txs_broadcasted += 1;
 128         //TODO
 129         Transaction_free(tx);
 130 }
 131
 132 struct NodeMonitors {
 133         std::mutex mut;
 134         std::vector<std::pair<LDK::OutPoint, LDK::ChannelMonitor>> mons;
 135         LDKLogger* logger;
 136
 137         void ConnectBlock(const uint8_t (*header)[80], uint32_t height, LDKCVec_C2Tuple_usizeTransactionZZ tx_data, LDKBroadcasterInterface broadcast, LDKFeeEstimator fee_est) {
 138                 std::unique_lock<std::mutex> l(mut);
 139                 for (auto& mon : mons) {
 140                         LDK::CVec_TransactionOutputsZ res = ChannelMonitor_block_connected(&mon.second, header, tx_data, height, broadcast, fee_est, *logger);
 141                 }
 142         }
 143 };
 144
 145 LDKCResult_NoneChannelMonitorUpdateErrZ add_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, LDKChannelMonitor monitor_arg) {
 146         // First bind the args to C++ objects so they auto-free
 147         LDK::ChannelMonitor mon(std::move(monitor_arg));
 148         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 149
 150         NodeMonitors* arg = (NodeMonitors*) this_arg;
 151         std::unique_lock<std::mutex> l(arg->mut);
 152
 153         arg->mons.push_back(std::make_pair(std::move(funding_txo), std::move(mon)));
 154         return CResult_NoneChannelMonitorUpdateErrZ_ok();
 155 }
 156 static std::atomic_int mons_updated(0);
 157 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_monitor(const void *this_arg, LDKOutPoint funding_txo_arg, LDKChannelMonitorUpdate monitor_arg) {
 158         // First bind the args to C++ objects so they auto-free
 159         LDK::ChannelMonitorUpdate update(std::move(monitor_arg));
 160         LDK::OutPoint funding_txo(std::move(funding_txo_arg));
 161
 162         NodeMonitors* arg = (NodeMonitors*) this_arg;
 163         std::unique_lock<std::mutex> l(arg->mut);
 164
 165         bool updated = false;
 166         for (auto& mon : arg->mons) {
 167                 if (OutPoint_get_index(&mon.first) == OutPoint_get_index(&funding_txo) &&
 168                                 !memcmp(OutPoint_get_txid(&mon.first), OutPoint_get_txid(&funding_txo), 32)) {
 169                         updated = true;
 170                         LDKBroadcasterInterface broadcaster = {
 171                                 .broadcast_transaction = broadcast_tx,
 172                         };
 173                         LDK::CResult_NoneMonitorUpdateErrorZ res = ChannelMonitor_update_monitor(&mon.second, &update, &broadcaster, &fee_est, arg->logger);
 174                         assert(res->result_ok);
 175                 }
 176         }
 177         assert(updated);
 178
 179         mons_updated += 1;
 180         return CResult_NoneChannelMonitorUpdateErrZ_ok();
 181 }
 182 LDKCVec_MonitorEventZ monitors_pending_monitor_events(const void *this_arg) {
 183         NodeMonitors* arg = (NodeMonitors*) this_arg;
 184         std::unique_lock<std::mutex> l(arg->mut);
 185
 186         if (arg->mons.size() == 0) {
 187                 return LDKCVec_MonitorEventZ {
 188                         .data = NULL,
 189                         .datalen = 0,
 190                 };
 191         } else {
 192                 // We only ever actually have one channel per node, plus concatenating two
 193                 // Rust Vecs to each other from C++ will require a bit of effort.
 194                 assert(arg->mons.size() == 1);
 195                 return ChannelMonitor_get_and_clear_pending_monitor_events(&arg->mons[0].second);
 196         }
 197 }
 198
 199 uintptr_t sock_send_data(void *this_arg, LDKu8slice data, bool resume_read) {
 200         return write((int)((long)this_arg), data.data, data.datalen);
 201 }
 202 void sock_disconnect_socket(void *this_arg) {
 203         close((int)((long)this_arg));
 204 }
 205 bool sock_eq(const void *this_arg, const LDKSocketDescriptor *other_arg) {
 206         return this_arg == other_arg->this_arg;
 207 }
 208 uint64_t sock_hash(const void *this_arg) {
 209         return (uint64_t)this_arg;
 210 }
 211 void sock_read_data_thread(int rdfd, LDKSocketDescriptor *peer_descriptor, LDKPeerManager *pm) {
 212         unsigned char buf[1024];
 213         LDKu8slice data;
 214         data.data = buf;
 215         ssize_t readlen = 0;
 216         while ((readlen = read(rdfd, buf, 1024)) > 0) {
 217                 data.datalen = readlen;
 218                 LDK::CResult_boolPeerHandleErrorZ res = PeerManager_read_event(&*pm, peer_descriptor, data);
 219                 if (!res->result_ok) {
 220                         peer_descriptor->disconnect_socket(peer_descriptor->this_arg);
 221                         return;
 222                 }
 223                 PeerManager_process_events(pm);
 224         }
 225         PeerManager_socket_disconnected(&*pm, peer_descriptor);
 226 }
 227
 228 class PeersConnection {
 229         int pipefds_1_to_2[2];
 230         int pipefds_2_to_1[2];
 231         std::thread t1, t2;
 232         LDKSocketDescriptor sock1, sock2;
 233
 234 public:
 235         PeersConnection(LDK::ChannelManager& cm1, LDK::ChannelManager& cm2, LDK::PeerManager& net1, LDK::PeerManager& net2) {
 236                 assert(!pipe(pipefds_1_to_2));
 237                 assert(!pipe(pipefds_2_to_1));
 238
 239                 sock1 = LDKSocketDescriptor {
 240                         .this_arg = (void*)(long)pipefds_1_to_2[1],
 241                         .send_data = sock_send_data,
 242                         .disconnect_socket = sock_disconnect_socket,
 243                         .eq = sock_eq,
 244                         .hash = sock_hash,
 245                         .clone = NULL,
 246                         .free = NULL,
 247                 };
 248
 249                 sock2 = LDKSocketDescriptor {
 250                         .this_arg = (void*)(long)pipefds_2_to_1[1],
 251                         .send_data = sock_send_data,
 252                         .disconnect_socket = sock_disconnect_socket,
 253                         .eq = sock_eq,
 254                         .hash = sock_hash,
 255                         .clone = NULL,
 256                         .free = NULL,
 257                 };
 258
 259                 t1 = std::thread(&sock_read_data_thread, pipefds_2_to_1[0], &sock1, &net1);
 260                 t2 = std::thread(&sock_read_data_thread, pipefds_1_to_2[0], &sock2, &net2);
 261
 262                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 263                 LDK::CResult_CVec_u8ZPeerHandleErrorZ con_res = PeerManager_new_outbound_connection(&net1, ChannelManager_get_our_node_id(&cm2), sock1);
 264                 assert(con_res->result_ok);
 265                 LDK::CResult_NonePeerHandleErrorZ con_res2 = PeerManager_new_inbound_connection(&net2, sock2);
 266                 assert(con_res2->result_ok);
 267
 268                 auto writelen = write(pipefds_1_to_2[1], con_res->contents.result->data, con_res->contents.result->datalen);
 269                 assert(writelen > 0 && uint64_t(writelen) == con_res->contents.result->datalen);
 270
 271                 while (true) {
 272                         // Wait for the initial handshakes to complete...
 273                         LDK::CVec_PublicKeyZ peers_1 = PeerManager_get_peer_node_ids(&net1);
 274                         LDK::CVec_PublicKeyZ peers_2 = PeerManager_get_peer_node_ids(&net2);
 275                         if (peers_1->datalen == 1 && peers_2->datalen ==1) { break; }
 276                         std::this_thread::yield();
 277                 }
 278         }
 279
 280         void stop() {
 281                 close(pipefds_1_to_2[0]);
 282                 close(pipefds_2_to_1[0]);
 283                 close(pipefds_1_to_2[1]);
 284                 close(pipefds_2_to_1[1]);
 285                 t1.join();
 286                 t2.join();
 287         }
 288 };
 289
 290 int main() {
 291         uint8_t channel_open_header[80];
 292         uint8_t header_1[80];
 293         uint8_t header_2[80];
 294         memcpy(channel_open_header, channel_open_block, 80);
 295         memcpy(header_1, block_1, 80);
 296         memcpy(header_2, block_2, 80);
 297
 298         LDKPublicKey null_pk;
 299         memset(&null_pk, 0, sizeof(null_pk));
 300
 301         LDKThirtyTwoBytes random_bytes;
 302         LDKThirtyTwoBytes chain_tip;
 303         memset(&chain_tip, 0, sizeof(chain_tip)); // channel_open_header's prev_blockhash is all-0s
 304
 305         LDKNetwork network = LDKNetwork_Testnet;
 306
 307         // Trait implementations:
 308         LDKBroadcasterInterface broadcast {
 309                 .this_arg = NULL,
 310                 .broadcast_transaction = broadcast_tx,
 311                 .free = NULL,
 312         };
 313
 314         // Instantiate classes for the nodes that don't get reloaded on a ser-des reload
 315         LDKLogger logger1 {
 316                 .this_arg = (void*)1,
 317                 .log = print_log,
 318                 .free = NULL,
 319         };
 320
 321         NodeMonitors mons1;
 322         mons1.logger = &logger1;
 323         LDKWatch mon1 {
 324                 .this_arg = &mons1,
 325                 .watch_channel = add_channel_monitor,
 326                 .update_channel = update_channel_monitor,
 327                 .release_pending_monitor_events = monitors_pending_monitor_events,
 328                 .free = NULL,
 329         };
 330
 331         LDK::NetGraphMsgHandler net_graph1 = NetGraphMsgHandler_new(genesis_hash, NULL, logger1);
 332         LDKSecretKey node_secret1;
 333
 334         LDKLogger logger2 {
 335                 .this_arg = (void*)2,
 336                 .log = print_log,
 337                 .free = NULL,
 338         };
 339
 340         NodeMonitors mons2;
 341         mons2.logger = &logger2;
 342         LDKWatch mon2 {
 343                 .this_arg = &mons2,
 344                 .watch_channel = add_channel_monitor,
 345                 .update_channel = update_channel_monitor,
 346                 .release_pending_monitor_events = monitors_pending_monitor_events,
 347                 .free = NULL,
 348         };
 349
 350         LDK::NetGraphMsgHandler net_graph2 = NetGraphMsgHandler_new(genesis_hash, NULL, logger2);
 351         LDKSecretKey node_secret2;
 352
 353         LDK::CVec_u8Z cm1_ser = LDKCVec_u8Z {}; // ChannelManager 1 serialization at the end of the ser-des scope
 354         LDK::CVec_u8Z cm2_ser = LDKCVec_u8Z {}; // ChannelManager 2 serialization at the end of the ser-des scope
 355
 356         { // Scope for the ser-des reload
 357                 // Instantiate classes for node 1:
 358                 uint8_t node_seed[32];
 359                 memset(&node_seed, 0, 32);
 360                 LDK::KeysManager keys1 = KeysManager_new(&node_seed, 0, 0);
 361                 LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 362                 node_secret1 = keys_source1->get_node_secret(keys_source1->this_arg);
 363
 364                 LDK::ChannelManager cm1 = ChannelManager_new(fee_est, mon1, broadcast, logger1, KeysManager_as_KeysInterface(&keys1), UserConfig_default(), ChainParameters_new(network, BestBlock_new(chain_tip, 0)));
 365
 366                 LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
 367                 assert(channels->datalen == 0);
 368
 369                 LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph1));
 370
 371                 random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 372                 LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1);
 373
 374                 // Demo getting a channel key and check that its returning real pubkeys:
 375                 LDK::Sign chan_signer1 = keys_source1->get_channel_signer(keys_source1->this_arg, false, 42);
 376                 chan_signer1->BaseSign.set_pubkeys(&chan_signer1->BaseSign); // Make sure pubkeys is defined
 377                 LDKPublicKey payment_point = ChannelPublicKeys_get_payment_point(&chan_signer1->BaseSign.pubkeys);
 378                 assert(memcmp(&payment_point, &null_pk, sizeof(null_pk)));
 379
 380                 // Instantiate classes for node 2:
 381                 memset(&node_seed, 1, 32);
 382                 LDK::KeysManager keys2 = KeysManager_new(&node_seed, 0, 0);
 383                 LDK::KeysInterface keys_source2 = KeysManager_as_KeysInterface(&keys2);
 384                 node_secret2 = keys_source2->get_node_secret(keys_source2->this_arg);
 385
 386                 LDK::ChannelHandshakeConfig handshake_config2 = ChannelHandshakeConfig_default();
 387                 ChannelHandshakeConfig_set_minimum_depth(&handshake_config2, 2);
 388                 LDK::UserConfig config2 = UserConfig_default();
 389                 UserConfig_set_own_channel_config(&config2, std::move(handshake_config2));
 390
 391                 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)));
 392
 393                 LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
 394                 assert(channels2->datalen == 0);
 395
 396                 LDK::RoutingMessageHandler net_msgs2 = NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph2);
 397                 LDK::CResult_ChannelAnnouncementDecodeErrorZ chan_ann = ChannelAnnouncement_read(LDKu8slice { .data = valid_node_announcement, .datalen = sizeof(valid_node_announcement) });
 398                 assert(chan_ann->result_ok);
 399                 LDK::CResult_boolLightningErrorZ ann_res = net_msgs2->handle_channel_announcement(net_msgs2->this_arg, chan_ann->contents.result);
 400                 assert(ann_res->result_ok);
 401
 402                 LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2));
 403
 404                 random_bytes = keys_source2->get_secure_random_bytes(keys_source2->this_arg);
 405                 LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2);
 406
 407                 // Open a connection!
 408                 PeersConnection conn(cm1, cm2, net1, net2);
 409
 410                 // Note that we have to bind the result to a C++ class to make sure it gets free'd
 411                 LDK::CResult_NoneAPIErrorZ res = ChannelManager_create_channel(&cm1, ChannelManager_get_our_node_id(&cm2), 40000, 1000, 42, UserConfig_default());
 412                 assert(res->result_ok);
 413                 PeerManager_process_events(&net1);
 414
 415                 LDK::CVec_ChannelDetailsZ new_channels = ChannelManager_list_channels(&cm1);
 416                 assert(new_channels->datalen == 1);
 417                 LDKPublicKey chan_open_pk = ChannelDetails_get_remote_network_id(&new_channels->data[0]);
 418                 assert(!memcmp(chan_open_pk.compressed_form, ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 419
 420                 while (true) {
 421                         LDK::CVec_ChannelDetailsZ new_channels_2 = ChannelManager_list_channels(&cm2);
 422                         if (new_channels_2->datalen == 1) {
 423                                 // Sample getting our counterparty's init features (which used to be hard to do without a memory leak):
 424                                 const LDK::InitFeatures init_feats = ChannelDetails_get_counterparty_features(&new_channels_2->data[0]);
 425                                 assert(init_feats->inner != NULL);
 426                                 break;
 427                         }
 428                         std::this_thread::yield();
 429                 }
 430
 431                 LDKEventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
 432                 while (true) {
 433                         LDK::CVec_EventZ events = ev1.get_and_clear_pending_events(ev1.this_arg);
 434                         if (events->datalen == 1) {
 435                                 assert(events->data[0].tag == LDKEvent_FundingGenerationReady);
 436                                 assert(events->data[0].funding_generation_ready.user_channel_id == 42);
 437                                 assert(events->data[0].funding_generation_ready.channel_value_satoshis == 40000);
 438                                 assert(events->data[0].funding_generation_ready.output_script.datalen == 34);
 439                                 assert(!memcmp(events->data[0].funding_generation_ready.output_script.data, channel_open_block + 58 + 81, 34));
 440                                 LDKTransaction funding_transaction { .data = const_cast<uint8_t*>(channel_open_block + 81), .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false };
 441
 442                                 LDK::CResult_NoneAPIErrorZ fund_res = ChannelManager_funding_transaction_generated(&cm1, &events->data[0].funding_generation_ready.temporary_channel_id.data, funding_transaction);
 443                                 assert(fund_res->result_ok);
 444                                 break;
 445                         }
 446                         std::this_thread::yield();
 447                 }
 448
 449                 // We observe when the funding signed messages have been exchanged by
 450                 // waiting for two monitors to be registered.
 451                 assert(num_txs_broadcasted == 0);
 452                 PeerManager_process_events(&net1);
 453                 while (num_txs_broadcasted != 1) {
 454                         std::this_thread::yield();
 455                 }
 456
 457                 LDK::Listen listener1 = ChannelManager_as_Listen(&cm1);
 458                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 459
 460                 LDK::Listen listener2 = ChannelManager_as_Listen(&cm2);
 461                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = channel_open_block, .datalen = sizeof(channel_open_block) }, 1);
 462
 463                 LDKCVec_C2Tuple_usizeTransactionZZ txdata { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 464                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 465                 mons1.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 466
 467                 txdata = LDKCVec_C2Tuple_usizeTransactionZZ { .data = (LDKC2Tuple_usizeTransactionZ*)malloc(sizeof(LDKC2Tuple_usizeTransactionZ)), .datalen = 1 };
 468                 *txdata.data = C2Tuple_usizeTransactionZ_new(0, LDKTransaction { .data = (uint8_t*)channel_open_block + 81, .datalen = sizeof(channel_open_block) - 81, .data_is_owned = false });
 469                 mons2.ConnectBlock(&channel_open_header, 1, txdata, broadcast, fee_est);
 470
 471                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 472                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_1, .datalen = sizeof(block_1) }, 2);
 473                 mons1.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 474                 mons2.ConnectBlock(&header_1, 2, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 475
 476                 listener1->block_connected(listener1->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 477                 listener2->block_connected(listener2->this_arg, LDKu8slice { .data = block_2, .datalen = sizeof(block_1) }, 3);
 478                 mons1.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 479                 mons2.ConnectBlock(&header_2, 3, LDKCVec_C2Tuple_usizeTransactionZZ { .data = NULL, .datalen = 0 }, broadcast, fee_est);
 480
 481                 PeerManager_process_events(&net1);
 482                 PeerManager_process_events(&net2);
 483
 484                 // Now send funds from 1 to 2!
 485                 while (true) {
 486                         LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 487                         if (outbound_channels->datalen == 1) {
 488                                 const LDKChannelDetails *channel = &outbound_channels->data[0];
 489                                 // Note that the channel ID is the same as the channel txid reversed as the output index is 0
 490                                 uint8_t expected_chan_id[32];
 491                                 for (int i = 0; i < 32; i++) { expected_chan_id[i] = channel_open_txid[31-i]; }
 492                                 assert(!memcmp(ChannelDetails_get_channel_id(channel), expected_chan_id, 32));
 493                                 assert(!memcmp(ChannelDetails_get_remote_network_id(channel).compressed_form,
 494                                                 ChannelManager_get_our_node_id(&cm2).compressed_form, 33));
 495                                 assert(ChannelDetails_get_channel_value_satoshis(channel) == 40000);
 496                                 // We opened the channel with 1000 push_msat:
 497                                 assert(ChannelDetails_get_outbound_capacity_msat(channel) == 40000*1000 - 1000);
 498                                 assert(ChannelDetails_get_inbound_capacity_msat(channel) == 1000);
 499                                 assert(ChannelDetails_get_is_live(channel));
 500                                 break;
 501                         }
 502                         std::this_thread::yield();
 503                 }
 504
 505                 LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 506                 LDKThirtyTwoBytes payment_secret;
 507                 memset(payment_secret.data, 0x42, 32);
 508                 {
 509                         LDK::LockedNetworkGraph graph_2_locked = NetGraphMsgHandler_read_locked_graph(&net_graph2);
 510                         LDK::NetworkGraph graph_2_ref = LockedNetworkGraph_graph(&graph_2_locked);
 511                         LDK::CResult_RouteLightningErrorZ route = get_route(ChannelManager_get_our_node_id(&cm1), &graph_2_ref, ChannelManager_get_our_node_id(&cm2), LDKInvoiceFeatures {
 512                                         .inner = NULL, .is_owned = false
 513                                 }, &outbound_channels, LDKCVec_RouteHintZ {
 514                                         .data = NULL, .datalen = 0
 515                                 }, 5000, 10, logger1);
 516                         assert(route->result_ok);
 517                         LDK::CResult_NonePaymentSendFailureZ send_res = ChannelManager_send_payment(&cm1, route->contents.result, payment_hash_1, payment_secret);
 518                         assert(send_res->result_ok);
 519                 }
 520
 521                 mons_updated = 0;
 522                 PeerManager_process_events(&net1);
 523                 while (mons_updated != 4) {
 524                         std::this_thread::yield();
 525                 }
 526
 527                 // Check that we received the payment!
 528                 LDKEventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
 529                 while (true) {
 530                         LDK::CVec_EventZ events = ev2.get_and_clear_pending_events(ev2.this_arg);
 531                         if (events->datalen == 1) {
 532                                 assert(events->data[0].tag == LDKEvent_PendingHTLCsForwardable);
 533                                 break;
 534                         }
 535                         std::this_thread::yield();
 536                 }
 537                 ChannelManager_process_pending_htlc_forwards(&cm2);
 538                 PeerManager_process_events(&net2);
 539
 540                 mons_updated = 0;
 541                 {
 542                         LDK::CVec_EventZ events = ev2.get_and_clear_pending_events(ev2.this_arg);
 543                         assert(events->datalen == 1);
 544                         assert(events->data[0].tag == LDKEvent_PaymentReceived);
 545                         assert(!memcmp(events->data[0].payment_received.payment_hash.data, payment_hash_1.data, 32));
 546                         assert(!memcmp(events->data[0].payment_received.payment_secret.data, payment_secret.data, 32));
 547                         assert(events->data[0].payment_received.amt == 5000);
 548                         assert(ChannelManager_claim_funds(&cm2, payment_preimage_1, payment_secret, 5000));
 549                 }
 550                 PeerManager_process_events(&net2);
 551                 // Wait until we've passed through a full set of monitor updates (ie new preimage + CS/RAA messages)
 552                 while (mons_updated != 5) {
 553                         std::this_thread::yield();
 554                 }
 555                 {
 556                         LDK::CVec_EventZ events = ev1.get_and_clear_pending_events(ev1.this_arg);
 557                         assert(events->datalen == 1);
 558                         assert(events->data[0].tag == LDKEvent_PaymentSent);
 559                         assert(!memcmp(events->data[0].payment_sent.payment_preimage.data, payment_preimage_1.data, 32));
 560                 }
 561
 562                 conn.stop();
 563
 564                 cm1_ser = ChannelManager_write(&cm1);
 565                 cm2_ser = ChannelManager_write(&cm2);
 566         }
 567
 568         LDK::CVec_ChannelMonitorZ mons_list1 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 569         assert(mons1.mons.size() == 1);
 570         mons_list1->data[0] = *& std::get<1>(mons1.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 571         mons_list1->data[0].is_owned = false; // XXX: God this sucks
 572         uint8_t node_seed[32];
 573         memset(&node_seed, 0, 32);
 574         LDK::KeysManager keys1 = KeysManager_new(&node_seed, 1, 0);
 575         LDK::KeysInterface keys_source1 = KeysManager_as_KeysInterface(&keys1);
 576
 577         LDK::ChannelManagerReadArgs cm1_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys1), fee_est, mon1, broadcast, logger1, UserConfig_default(), std::move(mons_list1));
 578         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm1_read =
 579                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm1_ser->data, .datalen = cm1_ser -> datalen}, std::move(cm1_args));
 580         assert(cm1_read->result_ok);
 581         LDK::ChannelManager cm1(std::move(cm1_read->contents.result->b));
 582
 583         LDK::CVec_ChannelMonitorZ mons_list2 = LDKCVec_ChannelMonitorZ { .data = (LDKChannelMonitor*)malloc(sizeof(LDKChannelMonitor)), .datalen = 1 };
 584         assert(mons2.mons.size() == 1);
 585         mons_list2->data[0] = *& std::get<1>(mons2.mons[0]); // Note that we need a reference, thus need a raw clone here, which *& does.
 586         mons_list2->data[0].is_owned = false; // XXX: God this sucks
 587         memset(&node_seed, 1, 32);
 588         LDK::KeysManager keys2 = KeysManager_new(&node_seed, 1, 0);
 589
 590         LDK::ChannelManagerReadArgs cm2_args = ChannelManagerReadArgs_new(KeysManager_as_KeysInterface(&keys2), fee_est, mon2, broadcast, logger2, UserConfig_default(), std::move(mons_list2));
 591         LDK::CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ cm2_read =
 592                 C2Tuple_BlockHashChannelManagerZ_read(LDKu8slice { .data = cm2_ser->data, .datalen = cm2_ser -> datalen}, std::move(cm2_args));
 593         assert(cm2_read->result_ok);
 594         LDK::ChannelManager cm2(std::move(cm2_read->contents.result->b));
 595
 596         // Attempt to close the channel...
 597         uint8_t chan_id[32];
 598         for (int i = 0; i < 32; i++) { chan_id[i] = channel_open_txid[31-i]; }
 599         LDK::CResult_NoneAPIErrorZ close_res = ChannelManager_close_channel(&cm1, &chan_id);
 600         assert(!close_res->result_ok); // Note that we can't close while disconnected!
 601
 602         // Open a connection!
 603         LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph1));
 604         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 605         LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, &random_bytes.data, logger1);
 606
 607         LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), NetGraphMsgHandler_as_RoutingMessageHandler(&net_graph2));
 608         random_bytes = keys_source1->get_secure_random_bytes(keys_source1->this_arg);
 609         LDK::PeerManager net2 = PeerManager_new(std::move(msg_handler2), node_secret2, &random_bytes.data, logger2);
 610
 611         PeersConnection conn(cm1, cm2, net1, net2);
 612
 613         while (true) {
 614                 // Wait for the channels to be considered up once the reestablish messages are processed
 615                 LDK::CVec_ChannelDetailsZ outbound_channels = ChannelManager_list_usable_channels(&cm1);
 616                 if (outbound_channels->datalen == 1) {
 617                         break;
 618                 }
 619         }
 620
 621         // Actually close the channel
 622         close_res = ChannelManager_close_channel(&cm1, &chan_id);
 623         assert(close_res->result_ok);
 624         PeerManager_process_events(&net1);
 625         num_txs_broadcasted = 0;
 626         while (num_txs_broadcasted != 2) {
 627                 std::this_thread::yield();
 628         }
 629         LDK::CVec_ChannelDetailsZ chans_after_close1 = ChannelManager_list_channels(&cm1);
 630         assert(chans_after_close1->datalen == 0);
 631         LDK::CVec_ChannelDetailsZ chans_after_close2 = ChannelManager_list_channels(&cm2);
 632         assert(chans_after_close2->datalen == 0);
 633
 634         conn.stop();
 635
 636         // Few extra random tests:
 637         LDKSecretKey sk;
 638         memset(&sk, 42, 32);
 639         LDKThirtyTwoBytes kdiv_params;
 640         memset(&kdiv_params, 43, 32);
 641         LDK::InMemorySigner signer = InMemorySigner_new(sk, sk, sk, sk, sk, random_bytes, 42, kdiv_params);
 642 }