2 using System.Collections.Generic;
3 using System.Diagnostics;
10 static void Assert(bool a, int assertion) {
12 Console.WriteLine("Assertion " + assertion + " failed at");
13 Console.WriteLine(new StackTrace().ToString());
18 static void SimpleConstructionTest() {
19 Ping ping = Ping.of(42, 43);
20 Assert(ping.get_ponglen() == 42, 0);
23 class TestBroadcaster : BroadcasterInterfaceInterface {
24 public int broadcasted_len = 0;
25 public void broadcast_transactions(byte[][] txn) {
26 Assert(txn.Length == 1, 1);
27 broadcasted_len = txn[0].Length;
31 static void SimpleTraitTest() {
32 TestBroadcaster impl = new TestBroadcaster();
33 BroadcasterInterface broadcaster = BroadcasterInterface.new_impl(impl);
34 byte[][] txn = new byte[1][];
35 txn[0] = new byte[42];
36 broadcaster.broadcast_transactions(txn);
37 Assert(impl.broadcasted_len == 42, 3);
40 class TestEstimator : FeeEstimatorInterface {
41 public int get_est_sat_per_1000_weight(ConfirmationTarget confirmation_target) {
42 if (confirmation_target == ConfirmationTarget.LDKConfirmationTarget_MinAllowedNonAnchorChannelRemoteFee) {
50 class TestLogger : LoggerInterface {
51 public void log(Record record) {
52 Console.WriteLine(record.get_module_path() + ":" + record.get_line() + " " + record.get_args());
56 class TestPersister : PersistInterface {
57 public ChannelMonitorUpdateStatus persist_new_channel(OutPoint channel_id, ChannelMonitor data, MonitorUpdateId update_id) {
58 return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
60 public ChannelMonitorUpdateStatus update_persisted_channel(OutPoint channel_id, ChannelMonitorUpdate update, ChannelMonitor data, MonitorUpdateId update_id) {
61 return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
63 public void archive_persisted_channel(OutPoint channel_id) { }
66 class TestEventHandler : EventHandlerInterface {
67 public List<Event> events = new List<Event>();
68 public void handle_event(Event ev) {
72 static Event get_event(ChannelManager manager) {
73 TestEventHandler impl = new TestEventHandler();
74 org.ldk.structs.EventHandler handler = org.ldk.structs.EventHandler.new_impl(impl);
75 manager.as_EventsProvider().process_pending_events(handler);
76 Assert(impl.events.Count == 1, 100);
77 return impl.events[0];
80 class TestRouter : RouterInterface, MessageRouterInterface {
82 EntropySource entropy;
83 public TestRouter(DefaultRouter inner, EntropySource entropy) {
85 this.entropy = entropy;
87 public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters param, ChannelDetails[] chans, InFlightHtlcs htlcs) {
88 return inner.as_Router().find_route(payer, param, chans, htlcs);
90 public Result_RouteLightningErrorZ find_route_with_id(byte[] payer, RouteParameters param, ChannelDetails[] chans, InFlightHtlcs htlcs, byte[] payment_hash, byte[] payment_id) {
91 return inner.as_Router().find_route_with_id(payer, param, chans, htlcs, payment_hash, payment_id);
93 public Result_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ create_blinded_payment_paths(byte[] recipient, ChannelDetails[] first_hops, ReceiveTlvs tlvs, long amount_msats) {
94 Result_C2Tuple_BlindedPayInfoBlindedPathZNoneZ info_path = UtilMethods.BlindedPath_one_hop_for_payment(recipient, tlvs, 40, entropy);
95 TwoTuple_BlindedPayInfoBlindedPathZ hop = ((Result_C2Tuple_BlindedPayInfoBlindedPathZNoneZ.Result_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_OK)info_path).res;
96 TwoTuple_BlindedPayInfoBlindedPathZ[] hops = new TwoTuple_BlindedPayInfoBlindedPathZ[1];
98 return Result_CVec_C2Tuple_BlindedPayInfoBlindedPathZZNoneZ.ok(hops);
101 public Result_OnionMessagePathNoneZ find_path(byte[] sender, byte[][] peers, Destination dest) {
102 return inner.as_MessageRouter().find_path(sender, peers, dest);
104 public Result_CVec_BlindedPathZNoneZ create_blinded_paths(byte[] recipient, byte[][] peers) {
105 Result_BlindedPathNoneZ path = BlindedPath.one_hop_for_message(recipient, entropy);
106 Assert(path.is_ok(), 2);
107 BlindedPath[] paths = new BlindedPath[1];
108 paths[0] = ((Result_BlindedPathNoneZ.Result_BlindedPathNoneZ_OK)path).res;
109 return Result_CVec_BlindedPathZNoneZ.ok(paths);
114 public TestBroadcaster broadcaster = new TestBroadcaster();
115 public FeeEstimator estimator = FeeEstimator.new_impl(new TestEstimator());
116 public Logger logger = Logger.new_impl(new TestLogger());
117 public Persist persister = Persist.new_impl(new TestPersister());
118 public ChainParameters chain_params = ChainParameters.of(Network.LDKNetwork_Bitcoin, BestBlock.from_network(Network.LDKNetwork_Bitcoin));
120 public BroadcasterInterface ldk_broadcaster;
121 public ChainMonitor chain_monitor;
122 public NetworkGraph graph;
123 public MultiThreadedLockableScore scorer;
124 public Router router;
125 public KeysManager keys;
126 public ChannelManager manager;
127 public OnionMessenger messenger;
129 public Node(byte seed) {
130 byte[] seed_bytes = new byte[32];
131 for (int i = 0; i < 32; i++) seed_bytes[i] = seed;
132 keys = KeysManager.of(seed_bytes, 42, 43);
134 ldk_broadcaster = BroadcasterInterface.new_impl(broadcaster);
135 chain_monitor = ChainMonitor.of(Option_FilterZ.none(), ldk_broadcaster, logger, estimator, persister);
136 graph = NetworkGraph.of(Network.LDKNetwork_Bitcoin, logger);
137 scorer = MultiThreadedLockableScore.of(ProbabilisticScorer.of(ProbabilisticScoringDecayParameters.with_default(), graph, logger).as_Score());
139 DefaultRouter router_impl = DefaultRouter.of(graph, logger, keys.as_EntropySource(), scorer.as_LockableScore(), ProbabilisticScoringFeeParameters.with_default());
140 TestRouter router_wrapper = new TestRouter(router_impl, keys.as_EntropySource());
141 router = Router.new_impl(router_wrapper, router_wrapper);
143 UserConfig config = UserConfig.with_default();
144 config.set_manually_accept_inbound_channels(true);
146 manager = ChannelManager.of(estimator, chain_monitor.as_Watch(), ldk_broadcaster, router, logger, keys.as_EntropySource(), keys.as_NodeSigner(), keys.as_SignerProvider(), config, chain_params, 42);
148 messenger = OnionMessenger.of(keys.as_EntropySource(), keys.as_NodeSigner(), logger, manager.as_NodeIdLookUp(), MessageRouter.new_impl(router_wrapper), manager.as_OffersMessageHandler(), IgnoringMessageHandler.of().as_CustomOnionMessageHandler());
152 static void NodeTest() {
153 Node node_a = new Node(1);
154 Node node_b = new Node(2);
156 InitFeatures init_features = node_a.manager.as_ChannelMessageHandler().provided_init_features(node_b.manager.get_our_node_id());
157 init_features.set_onion_messages_optional();
158 Init init_msg = Init.of(init_features, Option_CVec_ThirtyTwoBytesZZ.none(), Option_SocketAddressZ.none());
159 node_a.manager.as_ChannelMessageHandler().peer_connected(node_b.manager.get_our_node_id(), init_msg, false);
160 node_b.manager.as_ChannelMessageHandler().peer_connected(node_a.manager.get_our_node_id(), init_msg, false);
161 node_a.messenger.as_OnionMessageHandler().peer_connected(node_b.manager.get_our_node_id(), init_msg, false);
162 node_b.messenger.as_OnionMessageHandler().peer_connected(node_a.manager.get_our_node_id(), init_msg, false);
164 Result_ChannelIdAPIErrorZ res = node_a.manager.create_channel(node_b.manager.get_our_node_id(), 100000, 42, new UInt128(43), null, null);
165 Assert(res.is_ok(), 4);
167 MessageSendEvent[] msgs = node_a.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
168 Assert(msgs.Length == 1, 5);
169 Assert(msgs[0] is MessageSendEvent.MessageSendEvent_SendOpenChannel, 6);
170 node_b.manager.as_ChannelMessageHandler().handle_open_channel(node_a.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendOpenChannel) msgs[0]).msg);
172 Event inbound_chan = get_event(node_b.manager);
173 Assert(inbound_chan is Event.Event_OpenChannelRequest, 7);
174 Event.Event_OpenChannelRequest chan_request = (Event.Event_OpenChannelRequest)inbound_chan;
175 Result_NoneAPIErrorZ accept_res = node_b.manager.accept_inbound_channel_from_trusted_peer_0conf(chan_request.temporary_channel_id, chan_request.counterparty_node_id, new UInt128(42));
176 Assert(accept_res.is_ok(), 8);
178 MessageSendEvent[] response_msgs = node_b.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
179 Assert(response_msgs.Length == 1, 9);
180 Assert(response_msgs[0] is MessageSendEvent.MessageSendEvent_SendAcceptChannel, 10);
181 node_a.manager.as_ChannelMessageHandler().handle_accept_channel(node_b.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendAcceptChannel) response_msgs[0]).msg);
183 Event funding_ready = get_event(node_a.manager);
184 Assert(funding_ready is Event.Event_FundingGenerationReady, 11);
186 // We could use funding_transaction_generated here, but test batching
187 TwoTuple_ChannelIdPublicKeyZ[] channel = new TwoTuple_ChannelIdPublicKeyZ[1];
188 channel[0] = TwoTuple_ChannelIdPublicKeyZ.of(((Event.Event_FundingGenerationReady) funding_ready).temporary_channel_id, ((Event.Event_FundingGenerationReady) funding_ready).counterparty_node_id);
190 // Hand-crafted transaction which has a dummy witness and can pay to our script
191 byte[] transaction = new byte[99];
202 transaction[10] = 66;
203 transaction[11] = 66;
204 transaction[12] = 66;
205 transaction[13] = 66;
206 transaction[14] = 66;
207 transaction[15] = 66;
208 transaction[16] = 66;
209 transaction[17] = 66;
210 transaction[18] = 66;
211 transaction[19] = 66;
212 transaction[20] = 66;
213 transaction[21] = 66;
214 transaction[22] = 66;
215 transaction[23] = 66;
216 transaction[24] = 66;
217 transaction[25] = 66;
218 transaction[26] = 66;
219 transaction[27] = 66;
220 transaction[28] = 66;
221 transaction[29] = 66;
222 transaction[30] = 66;
223 transaction[31] = 66;
224 transaction[32] = 66;
225 transaction[33] = 66;
226 transaction[34] = 66;
227 transaction[35] = 66;
228 transaction[36] = 66;
229 transaction[37] = 66;
230 transaction[38] = 66;
231 transaction[39] = 18;
236 transaction[44] = 253;
237 transaction[45] = 255;
238 transaction[46] = 255;
239 transaction[47] = 255;
241 transaction[49] = 160;
242 transaction[50] = 134;
249 transaction[57] = 34;
251 Assert(((Event.Event_FundingGenerationReady) funding_ready).output_script.Length == 34, 12);
252 for (int i = 0; i < 34; i++) {
253 transaction[58 + i] = ((Event.Event_FundingGenerationReady) funding_ready).output_script[i];
264 node_a.manager.batch_funding_transaction_generated(channel, transaction);
266 MessageSendEvent[] funding_msg = node_a.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
267 Assert(funding_msg.Length == 1, 13);
268 Assert(funding_msg[0] is MessageSendEvent.MessageSendEvent_SendFundingCreated, 14);
269 node_b.manager.as_ChannelMessageHandler().handle_funding_created(node_a.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendFundingCreated) funding_msg[0]).msg);
271 Event bs_chan_pending = get_event(node_b.manager);
272 Assert(bs_chan_pending is Event.Event_ChannelPending, 15);
274 MessageSendEvent[] signed_ready_msgs = node_b.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
275 Assert(signed_ready_msgs.Length == 2, 16);
276 Assert(signed_ready_msgs[0] is MessageSendEvent.MessageSendEvent_SendFundingSigned, 17);
277 node_a.manager.as_ChannelMessageHandler().handle_funding_signed(node_b.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendFundingSigned) signed_ready_msgs[0]).msg);
278 Assert(node_a.broadcaster.broadcasted_len == 99, 18);
280 Event as_chan_pending = get_event(node_a.manager);
281 Assert(as_chan_pending is Event.Event_ChannelPending, 19);
283 MessageSendEvent[] as_ready = node_a.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
284 Assert(as_ready.Length == 1, 20);
285 Assert(as_ready[0] is MessageSendEvent.MessageSendEvent_SendChannelReady, 21);
287 Assert(signed_ready_msgs[1] is MessageSendEvent.MessageSendEvent_SendChannelReady, 22);
288 node_a.manager.as_ChannelMessageHandler().handle_channel_ready(node_b.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendChannelReady) signed_ready_msgs[1]).msg);
290 MessageSendEvent[] as_chan_update = node_a.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
291 Assert(as_chan_update.Length == 1, 23);
292 Assert(as_chan_update[0] is MessageSendEvent.MessageSendEvent_SendChannelUpdate, 24);
294 node_b.manager.as_ChannelMessageHandler().handle_channel_ready(node_a.manager.get_our_node_id(), ((MessageSendEvent.MessageSendEvent_SendChannelReady) as_ready[0]).msg);
296 Event as_chan_ready = get_event(node_a.manager);
297 Assert(as_chan_ready is Event.Event_ChannelReady, 25);
299 Event bs_chan_ready = get_event(node_b.manager);
300 Assert(bs_chan_ready is Event.Event_ChannelReady, 26);
302 MessageSendEvent[] bs_chan_update = node_b.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
303 Assert(bs_chan_update.Length == 1, 27);
304 Assert(bs_chan_update[0] is MessageSendEvent.MessageSendEvent_SendChannelUpdate, 28);
306 // Now that we have a channel, pay using a BOLT12 offer!
308 Result_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ builder_res = node_b.manager.create_offer_builder();
309 Assert(builder_res.is_ok(), 29);
310 Result_OfferBolt12SemanticErrorZ offer_res = ((Result_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ.Result_OfferWithDerivedMetadataBuilderBolt12SemanticErrorZ_OK)builder_res).res.build();
311 Assert(offer_res.is_ok(), 30);
312 Offer offer = ((Result_OfferBolt12SemanticErrorZ.Result_OfferBolt12SemanticErrorZ_OK)offer_res).res;
314 Result_NoneBolt12SemanticErrorZ pay_res = node_a.manager.pay_for_offer(offer, Option_u64Z.none(), Option_u64Z.some(42000), Option_StrZ.none(), new byte[32], Retry.attempts(0), Option_u64Z.none());
315 Assert(pay_res.is_ok(), 31);
317 OnionMessage as_invreq = node_a.messenger.as_OnionMessageHandler().next_onion_message_for_peer(node_b.manager.get_our_node_id());
318 node_b.messenger.as_OnionMessageHandler().handle_onion_message(node_a.manager.get_our_node_id(), as_invreq);
320 OnionMessage bs_inv = node_b.messenger.as_OnionMessageHandler().next_onion_message_for_peer(node_a.manager.get_our_node_id());
321 node_a.messenger.as_OnionMessageHandler().handle_onion_message(node_b.manager.get_our_node_id(), bs_inv);
323 // At this point node_a will generate a commitment update for node_b, which we check exists but don't bother to handle:
324 MessageSendEvent[] as_commit = node_a.manager.as_MessageSendEventsProvider().get_and_clear_pending_msg_events();
325 Assert(as_commit.Length == 1, 32);
326 Assert(as_commit[0] is MessageSendEvent.MessageSendEvent_UpdateHTLCs, 33);
329 static void Main(string[] args) {
330 SimpleConstructionTest();
334 Console.WriteLine("\n\nTESTS PASSED\n\n");
336 GC.WaitForPendingFinalizers();