_ Git - ldk-java/blob - src/test/java/org/ldk/PeerTest.java

   1 package org.ldk;
   2
   3 import org.bitcoinj.core.*;
   4 import org.bitcoinj.script.Script;
   5 import org.junit.jupiter.api.Test;
   6 import org.ldk.impl.bindings;
   7 import org.ldk.enums.*;
   8
   9 import java.util.ArrayList;
  10 import java.util.Arrays;
  11 import java.util.HashMap;
  12 import java.util.concurrent.ConcurrentHashMap;
  13 import java.util.concurrent.ConcurrentLinkedQueue;
  14
  15 public class PeerTest {
  16     class Peer {
  17         final long logger;
  18         final long fee_estimator;
  19         final long tx_broadcaster;
  20         final long chain_monitor;
  21         final long keys;
  22         final long keys_interface;
  23         final long config;
  24         final long chan_manager;
  25         final long chan_manager_events;
  26         final long chan_handler;
  27         final long router;
  28         final long route_handler;
  29         final long message_handler;
  30         final long peer_manager;
  31         HashMap<byte[], Long> monitors;
  32
  33         Peer(byte seed) {
  34             logger = bindings.LDKLogger_new((String arg)-> System.out.println(seed + ": " + arg));
  35             this.fee_estimator = bindings.LDKFeeEstimator_new(confirmation_target -> 0);
  36             this.tx_broadcaster = bindings.LDKBroadcasterInterface_new(tx -> {
  37                 // We should broadcast
  38             });
  39             this.monitors = new HashMap<>();
  40             this.chain_monitor = bindings.LDKWatch_new(new bindings.LDKWatch() {
  41                 @Override
  42                 public long watch_channel(long funding_txo, long monitor) {
  43                     synchronized (monitors) {
  44                         assert monitors.put(bindings.OutPoint_get_txid(funding_txo), monitor) == null;
  45                     }
  46                     bindings.OutPoint_free(funding_txo);
  47                     return bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
  48                 }
  49
  50                 @Override
  51                 public long update_channel(long funding_txo, long update) {
  52                     synchronized (monitors) {
  53                         bindings.ChannelMonitor_update_monitor(monitors.get(bindings.OutPoint_get_txid(funding_txo)), update, tx_broadcaster, logger);
  54                     }
  55                     bindings.OutPoint_free(funding_txo);
  56                     bindings.ChannelMonitorUpdate_free(update);
  57                     return bindings.CResult_NoneChannelMonitorUpdateErrZ_ok();
  58                 }
  59
  60                 @Override
  61                 public long release_pending_monitor_events() {
  62                     synchronized (monitors) {
  63                         assert monitors.size() <= 1;
  64                         for (Long mon : monitors.values()) {
  65                             return bindings.ChannelMonitor_get_and_clear_pending_monitor_events(mon);
  66                         }
  67                     }
  68                     return bindings.new_empty_slice_vec();
  69                 }
  70             });
  71
  72             byte[] key_seed = new byte[32];
  73             for (byte i = 0; i < 32; i++) { key_seed[i] = (byte) (i ^ seed); }
  74             this.keys = bindings.KeysManager_new(key_seed, LDKNetwork.LDKNetwork_Bitcoin, System.currentTimeMillis() / 1000, (int)(System.currentTimeMillis() * 1000) & 0xffffffff);
  75             this.keys_interface = bindings.KeysManager_as_KeysInterface(keys);
  76             this.config = bindings.UserConfig_default();
  77             this.chan_manager = bindings.ChannelManager_new(LDKNetwork.LDKNetwork_Bitcoin, fee_estimator, chain_monitor, tx_broadcaster, logger, keys_interface, config, 1);
  78             this.chan_manager_events = bindings.ChannelManager_as_EventsProvider(chan_manager);
  79
  80             this.chan_handler = bindings.ChannelManager_as_ChannelMessageHandler(chan_manager);
  81             this.router = bindings.NetGraphMsgHandler_new(0, logger);
  82             this.route_handler = bindings.NetGraphMsgHandler_as_RoutingMessageHandler(router);
  83             this.message_handler = bindings.MessageHandler_new(chan_handler, route_handler);
  84
  85             byte[] random_data = new byte[32];
  86             for (byte i = 0; i < 32; i++) { random_data[i] = (byte) ((i ^ seed) ^ 0xf0); }
  87             this.peer_manager = bindings.PeerManager_new(message_handler, bindings.LDKKeysInterface_call_get_node_secret(keys_interface), random_data, logger);
  88         }
  89
  90         void connect_block(Block b, Transaction t, int height) {
  91             byte[] header = b.bitcoinSerialize();
  92             long txn;
  93             if (t != null)
  94                 txn = bindings.LDKCVecTempl_C2TupleTempl_usize__Transaction_new(
  95                     new long[] {bindings.C2Tuple_usizeTransactionZ_new(1, bindings.new_txpointer_copy_data(t.bitcoinSerialize()))});
  96             else
  97                 txn = bindings.LDKCVecTempl_C2TupleTempl_usize__Transaction_new(new long[0]);
  98             bindings.ChannelManager_block_connected(chan_manager, header, txn, height);
  99             synchronized (monitors) {
 100                 for (Long mon : monitors.values()) {
 101                     if (t != null)
 102                         txn = bindings.LDKCVecTempl_C2TupleTempl_usize__Transaction_new(
 103                             new long[] {bindings.C2Tuple_usizeTransactionZ_new(1, bindings.new_txpointer_copy_data(t.bitcoinSerialize()))});
 104                     else
 105                         txn = bindings.LDKCVecTempl_C2TupleTempl_usize__Transaction_new(new long[0]);
 106                     long ret = bindings.ChannelMonitor_block_connected(mon, header, txn, height, tx_broadcaster, fee_estimator, logger);
 107                     bindings.CVec_C2Tuple_TxidCVec_TxOutZZZ_free(ret);
 108                 }
 109             }
 110         }
 111
 112         void free() {
 113             // Note that we can't rely on finalizer order, so don't bother trying to rely on it here
 114             bindings.Logger_free(logger);
 115             bindings.FeeEstimator_free(fee_estimator);
 116             bindings.BroadcasterInterface_free(tx_broadcaster);
 117             bindings.Watch_free(chain_monitor);
 118             bindings.KeysManager_free(keys);
 119             bindings.KeysInterface_free(keys_interface);
 120             bindings.ChannelManager_free(chan_manager);
 121             bindings.EventsProvider_free(chan_manager_events);
 122             bindings.ChannelMessageHandler_free(chan_handler);
 123             bindings.NetGraphMsgHandler_free(router);
 124             bindings.RoutingMessageHandler_free(route_handler);
 125             //MessageHandler was actually moved into the route_handler!: bindings.MessageHandler_free(message_handler);
 126             bindings.PeerManager_free(peer_manager);
 127             synchronized (monitors) {
 128                 for (Long mon : monitors.values()) {
 129                     bindings.ChannelMonitor_free(mon);
 130                 }
 131             }
 132         }
 133     }
 134
 135     class LongHolder { long val; }
 136
 137     byte[] do_read_event(ConcurrentLinkedQueue<Thread> list, long pm, long descriptor, long data) {
 138         byte[] arr = bindings.get_u8_slice_bytes(data);
 139         Thread thread = new Thread(() -> {
 140             long arr_vec = bindings.bytes_to_u8_vec(arr);
 141             long res = bindings.PeerManager_read_event(pm, descriptor, arr_vec);
 142             assert bindings.LDKCResult_boolPeerHandleErrorZ_result_ok(res);
 143             //assert bindings.deref_bool(bindings.LDKCResult_boolPeerHandleErrorZ_get_inner(res));
 144             bindings.CResult_boolPeerHandleErrorZ_free(res);
 145             bindings.CVec_u8Z_free(arr_vec);
 146         });
 147         thread.start();
 148         list.add(thread);
 149         return arr;
 150     }
 151
 152     @Test
 153     void test_message_handler() throws InterruptedException {
 154         Peer peer1 = new Peer((byte) 1);
 155         Peer peer2 = new Peer((byte) 2);
 156
 157         ConcurrentLinkedQueue<Thread> list = new ConcurrentLinkedQueue<Thread>();
 158         LongHolder descriptor1 = new LongHolder();
 159         LongHolder descriptor1ref = descriptor1;
 160         long descriptor2 = bindings.LDKSocketDescriptor_new(new bindings.LDKSocketDescriptor() {
 161             @Override
 162             public long send_data(long data, boolean resume_read) {
 163                 return do_read_event(list, peer1.peer_manager, descriptor1ref.val, data).length;
 164             }
 165
 166             @Override public void disconnect_socket() { assert false; }
 167             @Override public boolean eq(long other_arg) { return bindings.LDKSocketDescriptor_get_obj_from_jcalls(other_arg).hash() == 2; }
 168             @Override public long hash() { return 2; }
 169         });
 170
 171         descriptor1.val = bindings.LDKSocketDescriptor_new(new bindings.LDKSocketDescriptor() {
 172             @Override
 173             public long send_data(long data, boolean resume_read) {
 174                 return do_read_event(list, peer2.peer_manager, descriptor2, data).length;
 175             }
 176
 177             @Override public void disconnect_socket() { assert false; }
 178             @Override public boolean eq(long other_arg) { return bindings.LDKSocketDescriptor_get_obj_from_jcalls(other_arg).hash() == 1; }
 179             @Override public long hash() { return 1; }
 180         });
 181
 182         long init_vec = bindings.PeerManager_new_outbound_connection(peer1.peer_manager, bindings.ChannelManager_get_our_node_id(peer2.chan_manager), descriptor1.val);
 183         assert(bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(init_vec));
 184
 185         long con_res = bindings.PeerManager_new_inbound_connection(peer2.peer_manager, descriptor2);
 186         assert(bindings.LDKCResult_NonePeerHandleErrorZ_result_ok(con_res));
 187         bindings.CResult_NonePeerHandleErrorZ_free(con_res);
 188         do_read_event(list, peer2.peer_manager, descriptor2, bindings.LDKCResult_CVec_u8ZPeerHandleErrorZ_get_inner(init_vec));
 189         bindings.CResult_CVec_u8ZPeerHandleErrorZ_free(init_vec);
 190
 191         while (!list.isEmpty()) { list.poll().join(); }
 192
 193         long cc_res = bindings.ChannelManager_create_channel(peer1.chan_manager, bindings.ChannelManager_get_our_node_id(peer2.chan_manager), 10000, 1000, 42, 0);
 194         assert bindings.LDKCResult_NoneAPIErrorZ_result_ok(cc_res);
 195         bindings.CResult_NoneAPIErrorZ_free(cc_res);
 196
 197         bindings.PeerManager_process_events(peer1.peer_manager);
 198         while (!list.isEmpty()) { list.poll().join(); }
 199         bindings.PeerManager_process_events(peer2.peer_manager);
 200         while (!list.isEmpty()) { list.poll().join(); }
 201
 202         long events = bindings.LDKEventsProvider_call_get_and_clear_pending_events(peer1.chan_manager_events);
 203         bindings.VecOrSliceDef events_arr_info = bindings.LDKCVecTempl_Event_arr_info(events);
 204         assert events_arr_info.datalen == 1;
 205         bindings.LDKEvent event = bindings.LDKEvent_ref_from_ptr(events_arr_info.dataptr);
 206         assert event instanceof bindings.LDKEvent.FundingGenerationReady;
 207         assert ((bindings.LDKEvent.FundingGenerationReady)event).channel_value_satoshis == 10000;
 208         assert ((bindings.LDKEvent.FundingGenerationReady)event).user_channel_id == 42;
 209         byte[] funding_spk = bindings.get_u8_slice_bytes(((bindings.LDKEvent.FundingGenerationReady)event).output_script);
 210         assert funding_spk.length == 34 && funding_spk[0] == 0 && funding_spk[1] == 32; // P2WSH
 211         byte[] chan_id = ((bindings.LDKEvent.FundingGenerationReady)event).temporary_channel_id;
 212         bindings.CVec_EventZ_free(events);
 213
 214         Transaction funding = new Transaction(NetworkParameters.fromID(NetworkParameters.ID_MAINNET));
 215         funding.addInput(new TransactionInput(NetworkParameters.fromID(NetworkParameters.ID_MAINNET), funding, new byte[0]));
 216         funding.getInputs().get(0).setWitness(new TransactionWitness(2)); // Make sure we don't complain about lack of witness
 217         funding.getInput(0).getWitness().setPush(0, new byte[] {0x1});
 218         funding.addOutput(Coin.SATOSHI.multiply(10000), new Script(funding_spk));
 219         bindings.ChannelManager_funding_transaction_generated(peer1.chan_manager, chan_id, bindings.OutPoint_new(funding.getTxId().getReversedBytes(), (short) 0));
 220
 221         bindings.PeerManager_process_events(peer1.peer_manager);
 222         while (!list.isEmpty()) { list.poll().join(); }
 223         bindings.PeerManager_process_events(peer2.peer_manager);
 224         while (!list.isEmpty()) { list.poll().join(); }
 225
 226         events = bindings.LDKEventsProvider_call_get_and_clear_pending_events(peer1.chan_manager_events);
 227         events_arr_info = bindings.LDKCVecTempl_Event_arr_info(events);
 228         assert events_arr_info.datalen == 1;
 229         event = bindings.LDKEvent_ref_from_ptr(events_arr_info.dataptr);
 230         assert event instanceof bindings.LDKEvent.FundingBroadcastSafe;
 231         bindings.CVec_EventZ_free(events);
 232
 233         Block b = new Block(NetworkParameters.fromID(NetworkParameters.ID_MAINNET), 2, Sha256Hash.ZERO_HASH, Sha256Hash.ZERO_HASH, 42, 0, 0, Arrays.asList(new Transaction[]{funding}));
 234         peer1.connect_block(b, funding, 1);
 235         peer2.connect_block(b, funding, 1);
 236
 237         for (int height = 2; height < 10; height++) {
 238             b = new Block(NetworkParameters.fromID(NetworkParameters.ID_MAINNET), 2, b.getHash(), Sha256Hash.ZERO_HASH, 42, 0, 0, Arrays.asList(new Transaction[]{funding}));
 239             peer1.connect_block(b, null, height);
 240             peer2.connect_block(b, null, height);
 241         }
 242
 243         bindings.PeerManager_process_events(peer1.peer_manager);
 244         bindings.PeerManager_process_events(peer2.peer_manager);
 245         while (!list.isEmpty()) { list.poll().join(); }
 246
 247         long peer1_chans = bindings.ChannelManager_list_channels(peer1.chan_manager);
 248         long peer2_chans = bindings.ChannelManager_list_channels(peer2.chan_manager);
 249         assert bindings.vec_slice_len(peer1_chans) == 1;
 250         assert bindings.vec_slice_len(peer2_chans) == 1;
 251         long[] peer_1_chan_info = bindings.LDKCVecTempl_ChannelDetails_arr_info(peer1_chans);
 252         assert peer_1_chan_info.length == 1;
 253         assert bindings.ChannelDetails_get_channel_value_satoshis(peer_1_chan_info[0]) == 10000;
 254         assert bindings.ChannelDetails_get_is_live(peer_1_chan_info[0]);
 255         assert Arrays.equals(bindings.ChannelDetails_get_channel_id(peer_1_chan_info[0]), funding.getTxId().getReversedBytes());
 256         assert Arrays.equals(bindings.ChannelDetails_get_channel_id(bindings.LDKCVecTempl_ChannelDetails_arr_info(peer2_chans)[0]), funding.getTxId().getReversedBytes());
 257         bindings.CVec_ChannelDetailsZ_free(peer1_chans);
 258         bindings.CVec_ChannelDetailsZ_free(peer2_chans);
 259
 260         peer1.free();
 261         peer2.free();
 262         bindings.SocketDescriptor_free(descriptor2);
 263         bindings.SocketDescriptor_free(descriptor1.val);
 264     }
 265 }