KeysInterface manual_keysif(KeysInterface underlying_if) {
return KeysInterface.new_impl(new KeysInterface.KeysInterfaceInterface() {
@Override public Result_SecretKeyNoneZ get_node_secret(Recipient recipient) { return underlying_if.get_node_secret(recipient); }
+ @Override public Result_PublicKeyNoneZ get_node_id(Recipient recipient) { return underlying_if.get_node_id(recipient); }
+
+ @Override public Result_SharedSecretNoneZ ecdh(Recipient recipient, byte[] other_key, Option_ScalarZ tweak) { return underlying_if.ecdh(recipient, other_key, tweak); }
@Override public byte[] get_destination_script() { return underlying_if.get_destination_script(); }
@Override public ShutdownScript get_shutdown_scriptpubkey() { return underlying_if.get_shutdown_scriptpubkey(); }
@Override public Result_SignatureNoneZ sign_closing_transaction(ClosingTransaction closing_tx) {
return underlying_base.sign_closing_transaction(closing_tx);
}
+ @Override public Result_SignatureNoneZ sign_holder_anchor_input(byte[] anchor_tx, long input) {
+ return underlying_base.sign_holder_anchor_input(anchor_tx, input);
+ }
@Override public Result_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement(UnsignedChannelAnnouncement msg) {
return underlying_base.sign_channel_announcement(msg);
}
Watch get_manual_watch() {
Watch.WatchInterface watch_impl = new Watch.WatchInterface() {
- public Result_NoneChannelMonitorUpdateErrZ watch_channel(OutPoint funding_txo, ChannelMonitor monitor) {
+ public ChannelMonitorUpdateStatus watch_channel(OutPoint funding_txo, ChannelMonitor monitor) {
synchronized (monitors) {
assert monitors.put(Arrays.toString(funding_txo.get_txid()), monitor) == null;
}
- return Result_NoneChannelMonitorUpdateErrZ.ok();
+ return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
}
- public Result_NoneChannelMonitorUpdateErrZ update_channel(OutPoint funding_txo, ChannelMonitorUpdate update) {
+ public ChannelMonitorUpdateStatus update_channel(OutPoint funding_txo, ChannelMonitorUpdate update) {
synchronized (monitors) {
String txid = Arrays.toString(funding_txo.get_txid());
assert monitors.containsKey(txid);
Result_NoneNoneZ update_res = monitors.get(txid).update_monitor(update, tx_broadcaster, fee_estimator, logger);
assert update_res instanceof Result_NoneNoneZ.Result_NoneNoneZ_OK;
}
- return Result_NoneChannelMonitorUpdateErrZ.ok();
+ return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
}
@Override
// ChannelMonitor is. This used to be broken.
Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ roundtrip_monitor = UtilMethods.C2Tuple_BlockHashChannelMonitorZ_read(data, keys_interface);
assert roundtrip_monitor instanceof Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK;
+ must_free_objs.add(new WeakReference<>(roundtrip_monitor));
TwoTuple_OutPointScriptZ funding_txo = ((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK) roundtrip_monitor).res.get_b().get_funding_txo();
+ must_free_objs.add(new WeakReference<>(funding_txo));
System.gc(); System.runFinalization(); // Give the GC a chance to run.
assert Arrays.equals(funding_txo.get_a().get_txid(), expected_id.get_txid());
assert funding_txo.get_a().get_index() == expected_id.get_index();
Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ roundtrip_two = UtilMethods.C2Tuple_BlockHashChannelMonitorZ_read(data, keys_interface);
assert roundtrip_two instanceof Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK;
+ must_free_objs.add(new WeakReference<>(((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK) roundtrip_two).res.get_b()));
+ must_free_objs.add(new WeakReference<>(((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK) roundtrip_two).res));
+ must_free_objs.add(new WeakReference<>(roundtrip_two));
return ((Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ.Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_OK) roundtrip_two).res.get_b();
}
this.seed = seed;
Persist persister = Persist.new_impl(new Persist.PersistInterface() {
@Override
- public Result_NoneChannelMonitorUpdateErrZ persist_new_channel(OutPoint id, ChannelMonitor data, MonitorUpdateId update_id) {
+ public ChannelMonitorUpdateStatus persist_new_channel(OutPoint id, ChannelMonitor data, MonitorUpdateId update_id) {
synchronized (monitors) {
String key = Arrays.toString(id.to_channel_id());
ChannelMonitor res = test_mon_roundtrip(id, data.write());
assert monitors.put(key, res) == null;
}
- return Result_NoneChannelMonitorUpdateErrZ.ok();
+ return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
}
@Override
- public Result_NoneChannelMonitorUpdateErrZ update_persisted_channel(OutPoint id, ChannelMonitorUpdate update, ChannelMonitor data, MonitorUpdateId update_id) {
+ public ChannelMonitorUpdateStatus update_persisted_channel(OutPoint id, ChannelMonitorUpdate update, ChannelMonitor data, MonitorUpdateId update_id) {
synchronized (monitors) {
String key = Arrays.toString(id.to_channel_id());
ChannelMonitor res = test_mon_roundtrip(id, data.write());
// expose the JVM JIT bug where it finalize()s things still being called.
assert monitors.put(key, res) != null;
}
- return Result_NoneChannelMonitorUpdateErrZ.ok();
+ return ChannelMonitorUpdateStatus.LDKChannelMonitorUpdateStatus_Completed;
}
});
@Override public void register_tx(byte[] txid, byte[] script_pubkey) {
filter_additions.add(Arrays.toString(txid));
}
- @Override public Option_C2Tuple_usizeTransactionZZ register_output(WatchedOutput output) {
+ @Override public void register_output(WatchedOutput output) {
filter_additions.add(Arrays.toString(output.get_outpoint().get_txid()) + ":" + output.get_outpoint().get_index());
- return Option_C2Tuple_usizeTransactionZZ.none();
}
}));
} else {
Result_SecretKeyNoneZ node_secret = keys_interface.get_node_secret(Recipient.LDKRecipient_Node);
assert node_secret.is_ok();
this.peer_manager = PeerManager.of(chan_manager.as_ChannelMessageHandler(), route_handler.as_RoutingMessageHandler(),
- ((Result_SecretKeyNoneZ.Result_SecretKeyNoneZ_OK)node_secret).res, random_data, logger, this.custom_message_handler);
+ IgnoringMessageHandler.of().as_OnionMessageHandler(),
+ ((Result_SecretKeyNoneZ.Result_SecretKeyNoneZ_OK)node_secret).res, (int)(System.currentTimeMillis() / 1000),
+ random_data, logger, this.custom_message_handler);
if (use_invoice_payer) {
this.payer = InvoicePayer.of(this.chan_manager.as_Payer(), Router.new_impl(new Router.RouterInterface() {
+ @Override public void notify_payment_path_failed(RouteHop[] path, long short_channel_id) {}
+ @Override public void notify_payment_path_successful(RouteHop[] path) {}
+ @Override public void notify_payment_probe_successful(RouteHop[] path) {}
+ @Override public void notify_payment_probe_failed(RouteHop[] path, long short_channel_id) {}
+
@Override
- public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters params, byte[] payment_hash, ChannelDetails[] first_hops, Score scorer) {
- return UtilMethods.find_route(payer, params, router, first_hops, logger, scorer, new byte[32]);
+ public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters params, byte[] payment_hash, ChannelDetails[] first_hops, InFlightHtlcs inflight_htlcs) {
+ while (true) {
+ try (ReadOnlyNetworkGraph graph = router.read_only()) {
+ assert graph.channel(424242) == null;
+ long[] channels = graph.list_channels();
+ if (channels.length != 1) {
+ // If we're using a NioPeerHandler, the handling of announcement signatures and
+ // channel broadcasting may be done async, so just wait until the channel shows up.
+ assert use_nio_peer_handler;
+ continue;
+ }
+ ChannelInfo chan = graph.channel(channels[0]);
+ assert Arrays.equals(chan.get_node_one().as_slice(), chan.get_node_one().write());
+ assert Arrays.equals(chan.get_node_one().as_slice(), chan_manager.get_our_node_id()) ||
+ Arrays.equals(chan.get_node_two().as_slice(), chan_manager.get_our_node_id());
+ break;
+ }
+ }
+ return UtilMethods.find_route(payer, params, router, first_hops, logger, Score.new_impl(new Score.ScoreInterface() {
+ @Override public void payment_path_failed(RouteHop[] path, long scid) {}
+ @Override public long channel_penalty_msat(long short_channel_id, NodeId source, NodeId target, ChannelUsage usage) { return 0; }
+ @Override public void payment_path_successful(RouteHop[] path) {}
+ @Override public void probe_failed(RouteHop[] path, long short_channel_id) { assert false; }
+ @Override public void probe_successful(RouteHop[] path) { assert false; }
+ @Override public byte[] write() { assert false; return null; }
+ }), new byte[32]);
}
- }), MultiThreadedLockableScore.of(Score.new_impl(new Score.ScoreInterface() {
- @Override public void payment_path_failed(RouteHop[] path, long scid) {}
- @Override public long channel_penalty_msat(long short_channel_id, NodeId source, NodeId target, ChannelUsage usage) { return 0; }
- @Override public void payment_path_successful(RouteHop[] path) {}
- @Override public void probe_failed(RouteHop[] path, long short_channel_id) { assert false; }
- @Override public void probe_successful(RouteHop[] path) { assert false; }
- @Override public byte[] write() { assert false; return null; }
- })), logger, EventHandler.new_impl(new EventHandler.EventHandlerInterface() {
+ }), logger, EventHandler.new_impl(new EventHandler.EventHandlerInterface() {
@Override public void handle_event(Event event) {
synchronized (pending_manager_events) {
pending_manager_events.add(event);
Result_SecretKeyNoneZ node_secret = keys_interface.get_node_secret(Recipient.LDKRecipient_Node);
assert node_secret.is_ok();
this.peer_manager = PeerManager.of(chan_manager.as_ChannelMessageHandler(), route_handler.as_RoutingMessageHandler(),
- ((Result_SecretKeyNoneZ.Result_SecretKeyNoneZ_OK)node_secret).res,
+ IgnoringMessageHandler.of().as_OnionMessageHandler(),
+ ((Result_SecretKeyNoneZ.Result_SecretKeyNoneZ_OK)node_secret).res, (int)(System.currentTimeMillis() / 1000),
random_data, logger, this.custom_message_handler);
if (!break_cross_peer_refs && (use_manual_watch || use_km_wrapper)) {
// When we pass monitors[0] into chain_watch.watch_channel we create a reference from the new Peer to a
}
if (use_invoice_payer) {
this.payer = InvoicePayer.of(this.chan_manager.as_Payer(), Router.new_impl(new Router.RouterInterface() {
+ @Override public void notify_payment_path_failed(RouteHop[] path, long short_channel_id) {}
+ @Override public void notify_payment_path_successful(RouteHop[] path) {}
+ @Override public void notify_payment_probe_successful(RouteHop[] path) {}
+ @Override public void notify_payment_probe_failed(RouteHop[] path, long short_channel_id) {}
+
@Override
- public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters params, byte[] _payment_hash, ChannelDetails[] first_hops, Score scorer) {
- return UtilMethods.find_route(payer, params, router, first_hops, logger, scorer, new byte[32]);
+ public Result_RouteLightningErrorZ find_route(byte[] payer, RouteParameters route_params, byte[] payment_hash, ChannelDetails[] first_hops, InFlightHtlcs inflight_htlcs) {
+ return UtilMethods.find_route(payer, route_params, router, first_hops, logger, Score.new_impl(new Score.ScoreInterface() {
+ @Override public long channel_penalty_msat(long short_channel_id, NodeId source, NodeId target, ChannelUsage usage) { return 0; }
+ @Override public void payment_path_failed(RouteHop[] path, long scid) {}
+ @Override public void payment_path_successful(RouteHop[] path) {}
+ @Override public void probe_failed(RouteHop[] path, long short_channel_id) { assert false; }
+ @Override public void probe_successful(RouteHop[] path) { assert false; }
+ @Override public byte[] write() { assert false; return null; }
+ }), new byte[32]);
}
- }), MultiThreadedLockableScore.of(Score.new_impl(new Score.ScoreInterface() {
- @Override public long channel_penalty_msat(long short_channel_id, NodeId source, NodeId target, ChannelUsage usage) { return 0; }
- @Override public void payment_path_failed(RouteHop[] path, long scid) {}
- @Override public void payment_path_successful(RouteHop[] path) {}
- @Override public void probe_failed(RouteHop[] path, long short_channel_id) { assert false; }
- @Override public void probe_successful(RouteHop[] path) { assert false; }
- @Override public byte[] write() { assert false; return null; }
- })), logger, EventHandler.new_impl(new EventHandler.EventHandlerInterface() {
+ }), logger, EventHandler.new_impl(new EventHandler.EventHandlerInterface() {
@Override public void handle_event(Event event) {
synchronized (pending_manager_events) {
pending_manager_events.add(event);
assert Arrays.equals(peer1_chans[0].get_channel_id(), funding.getTxId().getReversedBytes());
assert Arrays.equals(peer2_chans[0].get_channel_id(), funding.getTxId().getReversedBytes());
- Result_InvoiceSignOrCreationErrorZ invoice = UtilMethods.create_invoice_from_channelmanager(peer2.chan_manager, peer2.keys_interface, Currency.LDKCurrency_Bitcoin, Option_u64Z.some(10000000), "Invoice Description", 7200);
+ Result_InvoiceSignOrCreationErrorZ invoice = UtilMethods.create_invoice_from_channelmanager(peer2.chan_manager, peer2.keys_interface, peer2.logger, Currency.LDKCurrency_Bitcoin, Option_u64Z.some(10000000), "Invoice Description", 7200);
assert invoice instanceof Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_OK;
System.out.println("Got invoice: " + ((Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_OK) invoice).res.to_str());
assert Arrays.equals(((Result_InvoiceParseOrSemanticErrorZ.Result_InvoiceParseOrSemanticErrorZ_OK) parsed_invoice).res.payment_hash(), ((Result_InvoiceSignOrCreationErrorZ.Result_InvoiceSignOrCreationErrorZ_OK) invoice).res.payment_hash());
SignedRawInvoice signed_raw = ((Result_InvoiceParseOrSemanticErrorZ.Result_InvoiceParseOrSemanticErrorZ_OK) parsed_invoice).res.into_signed_raw();
RawInvoice raw_invoice = signed_raw.raw_invoice();
- byte[] desc_hash = raw_invoice.hash();
+ byte[] desc_hash = raw_invoice.signable_hash();
Description raw_invoice_description = raw_invoice.description();
String description_string = raw_invoice_description.into_inner();
assert description_string.equals("Invoice Description");
byte[] hop_pubkey = new byte[33];
hop_pubkey[0] = 3;
hop_pubkey[1] = 42;
- hops[0][0] = RouteHop.of(hop_pubkey, NodeFeatures.known(), 42, ChannelFeatures.known(), 100, 0);
+ NodeFeatures node_features = NodeFeatures.empty();
+ ChannelFeatures channel_features = ChannelFeatures.empty();
+ hops[0][0] = RouteHop.of(hop_pubkey, node_features, 42, channel_features, 100, 0);
Route r2 = Route.of(hops, payee);
payment_res = peer1.chan_manager.send_payment(r2, payment_hash, payment_secret);
assert payment_res instanceof Result_PaymentIdPaymentSendFailureZ.Result_PaymentIdPaymentSendFailureZ_Err;
// so we cannot exchange custom messages with it
if (!use_chan_manager_constructor) {
byte[] custom_message_bytes = new byte[]{0x42, 0x44, 0x43, 0x00};
- state.peer1.custom_messages_to_send.add(custom_message_bytes);
+ synchronized(state.peer1.custom_messages_to_send) {
+ state.peer1.custom_messages_to_send.add(custom_message_bytes);
+ }
state.peer1.peer_manager.process_events();
synchronized (state.peer2.received_custom_messages) {
while (true) {
projects / ldk-java / blobdiff