8 #include "include/lightningpp.hpp"
12 #include <sys/socket.h>
13 #include <netinet/in.h>
14 #include <arpa/inet.h>
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
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.
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,
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
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
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
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 }
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);
109 uint32_t get_fee(const void *this_arg, LDKConfirmationTarget target) {
110 if (target == LDKConfirmationTarget_Background) {
115 // Note that we don't call _free() on target, but that's OK, its unitary
117 // We use the same fee estimator globally:
118 const LDKFeeEstimator fee_est {
120 .get_est_sat_per_1000_weight = get_fee,
124 static std::atomic_int num_txs_broadcasted(0);
125 void broadcast_tx(const void *this_arg, LDKTransaction tx) {
126 num_txs_broadcasted += 1;
128 Transaction_free(tx);
131 struct NodeMonitors {
133 std::vector<std::pair<LDK::OutPoint, LDK::ChannelMonitor>> mons;
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);
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));
149 NodeMonitors* arg = (NodeMonitors*) this_arg;
150 std::unique_lock<std::mutex> l(arg->mut);
152 arg->mons.push_back(std::make_pair(std::move(funding_txo), std::move(mon)));
153 return ChannelMonitorUpdateStatus_completed();
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));
161 NodeMonitors* arg = (NodeMonitors*) this_arg;
162 std::unique_lock<std::mutex> l(arg->mut);
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)) {
169 LDKBroadcasterInterface broadcaster = {
170 .broadcast_transaction = broadcast_tx,
172 LDK::CResult_NoneNoneZ res = ChannelMonitor_update_monitor(&mon.second, &update, &broadcaster, fee_est, arg->logger);
173 assert(res->result_ok);
179 return ChannelMonitorUpdateStatus_completed();
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);
185 if (arg->mons.size() == 0) {
186 return LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ {
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)),
203 vec.data[0] = std::move(tuple);
209 std::vector<LDK::Event> events;
211 void handle_event(const void *this_arg, LDKEvent event) {
212 EventQueue* arg = (EventQueue*) this_arg;
213 arg->events.push_back(std::move(event));
217 class PeersConnection {
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);
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)));
232 assert(!socket_connect(node1_handler, ChannelManager_get_our_node_id(&cm2), (sockaddr*)&listen_addr, sizeof(listen_addr)));
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();
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)));
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)));
250 // Wait for all our sockets to disconnect (making sure we disconnect any new connections)...
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();
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);
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)));
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();
275 interrupt_socket_handling(node1_handler);
276 interrupt_socket_handling(node2_handler);
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);
285 void sock_disconnect_socket(void *this_arg) {
286 close((int)((long)this_arg));
288 bool sock_eq(const void *this_arg, const LDKSocketDescriptor *other_arg) {
289 return this_arg == other_arg->this_arg;
291 uint64_t sock_hash(const void *this_arg) {
292 return (uint64_t)this_arg;
294 void sock_read_data_thread(int rdfd, LDKSocketDescriptor *peer_descriptor, LDKPeerManager *pm) {
295 unsigned char buf[1024];
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);
306 PeerManager_process_events(pm);
308 PeerManager_socket_disconnected(&*pm, peer_descriptor);
311 class PeersConnection {
312 int pipefds_1_to_2[2];
313 int pipefds_2_to_1[2];
315 LDKSocketDescriptor sock1, sock2;
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));
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,
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,
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);
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);
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);
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();
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]);
374 struct CustomOnionMsgQueue {
376 std::vector<LDK::CustomOnionMessageContents> msgs;
379 uint64_t custom_onion_msg_type_id(const void *this_arg) {
382 LDKCVec_u8Z custom_onion_msg_bytes(const void *this_arg) {
383 uint8_t *bytes = (uint8_t *) malloc(1024);
384 memset(bytes, 43, 1024);
386 .data = bytes, .datalen = 1024
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));
396 LDKCustomOnionMessageContents build_custom_onion_message() {
397 return LDKCustomOnionMessageContents {
399 .tlv_type = custom_onion_msg_type_id,
400 .write = custom_onion_msg_bytes,
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);
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()));
415 struct CustomMsgQueue {
416 std::vector<LDK::Type> msgs;
419 uint16_t custom_msg_type_id(const void *this_arg) {
422 LDKCVec_u8Z custom_msg_bytes(const void *this_arg) {
423 uint8_t *bytes = (uint8_t *) malloc(1024);
424 memset(bytes, 42, 1024);
426 .data = bytes, .datalen = 1024
429 LDKStr custom_msg_debug(const void *this_arg) {
431 .chars = NULL, .len = 0, .chars_is_owned = false
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);
439 memset(cmp, 42, 1024);
440 assert(!memcmp(cmp, buf.data, 1024));
441 return CResult_COption_TypeZDecodeErrorZ_ok(COption_TypeZ_some(LDKType {
443 .type_id = custom_msg_type_id,
444 .debug_str = custom_msg_debug,
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();
454 LDKCVec_C2Tuple_PublicKeyTypeZZ never_send_custom_msgs(const void* this_arg) {
455 return LDKCVec_C2Tuple_PublicKeyTypeZZ {
456 .data = NULL, .datalen = 0
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))),
466 ret.data[0].a = *counterparty_node_id;
467 ret.data[0].b = LDKType {
469 .type_id = custom_msg_type_id,
470 .debug_str = custom_msg_debug,
471 .write = custom_msg_bytes,
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));
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);
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);
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);
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);
509 LDKPublicKey null_pk;
510 memset(&null_pk, 0, sizeof(null_pk));
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
516 LDKNetwork network = LDKNetwork_Testnet;
518 // Trait implementations:
519 LDKBroadcasterInterface broadcast {
521 .broadcast_transaction = broadcast_tx,
525 // Instantiate classes for the nodes that don't get reloaded on a ser-des reload
527 .this_arg = (void*)1,
533 mons1.logger = &logger1;
536 .watch_channel = add_channel_monitor,
537 .update_channel = update_channel_monitor,
538 .release_pending_monitor_events = monitors_pending_monitor_events,
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;
547 .this_arg = (void*)2,
553 mons2.logger = &logger2;
556 .watch_channel = add_channel_monitor,
557 .update_channel = update_channel_monitor,
558 .release_pending_monitor_events = monitors_pending_monitor_events,
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;
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
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;
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)));
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);
585 LDK::OnionMessenger om1 = OnionMessenger_new(KeysManager_as_KeysInterface(&keys1), logger1, std::move(custom_onion_msg_handler1));
587 LDK::CVec_ChannelDetailsZ channels = ChannelManager_list_channels(&cm1);
588 assert(channels->datalen == 0);
590 LDK::MessageHandler msg_handler1 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm1), P2PGossipSync_as_RoutingMessageHandler(&graph_msg_handler1), OnionMessenger_as_OnionMessageHandler(&om1));
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));
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)));
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;
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));
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)));
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);
622 LDK::OnionMessenger om2 = OnionMessenger_new(KeysManager_as_KeysInterface(&keys2), logger2, std::move(custom_onion_msg_handler2));
624 LDK::CVec_ChannelDetailsZ channels2 = ChannelManager_list_channels(&cm2);
625 assert(channels2->datalen == 0);
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);
633 LDK::MessageHandler msg_handler2 = MessageHandler_new(ChannelManager_as_ChannelMessageHandler(&cm2), std::move(net_msgs2), OnionMessenger_as_OnionMessageHandler(&om1));
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));
638 // Open a connection!
639 PeersConnection conn(cm1, cm2, net1, net2);
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);
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));
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);
661 std::this_thread::yield();
664 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
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);
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 };
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);
683 std::this_thread::yield();
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();
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);
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);
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);
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);
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);
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);
718 PeerManager_process_events(&net1);
719 PeerManager_process_events(&net2);
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]; }
725 LDK::EventsProvider ev2 = ChannelManager_as_EventsProvider(&cm2);
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));
735 std::this_thread::yield();
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));
747 std::this_thread::yield();
750 // Now send funds from 1 to 2!
751 uint64_t channel_scid;
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);
758 assert(!memcmp(ChannelDetails_get_channel_id(channel), expected_chan_id, 32));
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;
775 std::this_thread::yield();
778 LDKCOption_u64Z min_value = {
779 .tag = LDKCOption_u64Z_Some,
782 LDK::CResult_InvoiceSignOrCreationErrorZ invoice = create_invoice_from_channelmanager(&cm2,
783 KeysManager_as_KeysInterface(&keys2), logger2,
784 LDKCurrency_Bitcoin, min_value,
786 .chars = (const uint8_t *)"Invoice Description",
787 .len = strlen("Invoice Description"),
788 .chars_is_owned = false
790 assert(invoice->result_ok);
791 LDKThirtyTwoBytes payment_hash;
792 memcpy(payment_hash.data, Invoice_payment_hash(invoice->contents.result), 32);
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
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);
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);
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);
823 PeerManager_process_events(&net1);
824 while (mons_updated != 4) {
825 std::this_thread::yield();
828 // Check that we received the payment!
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);
837 std::this_thread::yield();
839 ChannelManager_process_pending_htlc_forwards(&cm2);
840 PeerManager_process_events(&net2);
843 LDKThirtyTwoBytes payment_preimage;
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);
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);
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();
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));
884 cm1_ser = ChannelManager_write(&cm1);
885 cm2_ser = ChannelManager_write(&cm2);
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);
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));
903 LDKCustomOnionMessageHandler custom_onion_msg_handler1 = {
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
909 LDK::OnionMessenger om1 = OnionMessenger_new(KeysManager_as_KeysInterface(&keys1), logger1, custom_onion_msg_handler1);
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);
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));
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,
931 LDK::OnionMessenger om2 = OnionMessenger_new(KeysManager_as_KeysInterface(&keys2), logger2, custom_onion_msg_handler2);
933 // Attempt to close the channel...
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!
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);
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 {
950 .read = read_custom_message,
955 LDK::PeerManager net1 = PeerManager_new(std::move(msg_handler1), node_secret1, 0xdeadbeef, &random_bytes.data, logger1, std::move(custom_msg_handler1));
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 {
965 .read = read_custom_message,
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));
973 PeersConnection conn(cm1, cm2, net1, net2);
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) {
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,
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));
1003 LDK::CResult_InvoiceSignOrCreationErrorZ invoice_res2 = create_invoice_from_channelmanager(&cm2,
1004 KeysManager_as_KeysInterface(&keys2), logger1,
1005 LDKCurrency_Bitcoin, COption_u64Z_some(10000),
1007 .chars = (const uint8_t *)"Invoice 2 Description",
1008 .len = strlen("Invoice 2 Description"),
1009 .chars_is_owned = false
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);
1017 // Check that we received the payment!
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);
1027 std::this_thread::yield();
1029 ChannelManager_process_pending_htlc_forwards(&cm2);
1030 PeerManager_process_events(&net2);
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);
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);
1056 std::this_thread::yield();
1059 while (queue1.events.size() < 2) {
1060 PeerManager_process_events(&net2);
1061 PeerManager_process_events(&net1);
1063 LDK::EventsProvider ev1 = ChannelManager_as_EventsProvider(&cm1);
1064 LDK::EventHandler evh1 = InvoicePayer_as_EventHandler(&payer);
1065 ev1.process_pending_events(std::move(evh1));
1067 assert(queue1.events.size() == 2);
1068 assert(queue1.events[0]->tag == LDKEvent_PaymentSent);
1069 assert(queue1.events[1]->tag == LDKEvent_PaymentPathSuccessful);
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();
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);
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 })
1092 PeerManager_process_events(&net1);
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;
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);
1106 // Few extra random tests:
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);