X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fstructs%2FChannelMessageHandler.java;h=20173f72520bcbb735c02190a702047d6bf45628;hb=2f0e19ab23f28c5c1bc11dc6bff24e156da3ec01;hp=b8367adc84aa20464577ae03a856b9cc124779e9;hpb=5e9de82b3a7712a41189756d9d16d946142b2ac5;p=ldk-java diff --git a/src/main/java/org/ldk/structs/ChannelMessageHandler.java b/src/main/java/org/ldk/structs/ChannelMessageHandler.java index b8367adc..20173f72 100644 --- a/src/main/java/org/ldk/structs/ChannelMessageHandler.java +++ b/src/main/java/org/ldk/structs/ChannelMessageHandler.java @@ -10,8 +10,8 @@ import javax.annotation.Nullable; /** * A trait to describe an object which can receive channel messages. * - * Messages MAY be called in parallel when they originate from different their_node_ids, however - * they MUST NOT be called in parallel when the two calls have the same their_node_id. + * Messages MAY be called in parallel when they originate from different `their_node_ids`, however + * they MUST NOT be called in parallel when the two calls have the same `their_node_id`. */ @SuppressWarnings("unchecked") // We correctly assign various generic arrays public class ChannelMessageHandler extends CommonBase { @@ -27,96 +27,146 @@ public class ChannelMessageHandler extends CommonBase { protected void finalize() throws Throwable { if (ptr != 0) { bindings.ChannelMessageHandler_free(ptr); } super.finalize(); } - + /** + * Destroys the object, freeing associated resources. After this call, any access + * to this object may result in a SEGFAULT or worse. + * + * You should generally NEVER call this method. You should let the garbage collector + * do this for you when it finalizes objects. However, it may be useful for types + * which represent locks and should be closed immediately to avoid holding locks + * until the GC runs. + */ + public void destroy() { + if (ptr != 0) { bindings.ChannelMessageHandler_free(ptr); } + ptr = 0; + } public static interface ChannelMessageHandlerInterface { /** - * Handle an incoming open_channel message from the given peer. + * Handle an incoming `open_channel` message from the given peer. + */ + void handle_open_channel(byte[] their_node_id, OpenChannel msg); + /** + * Handle an incoming `open_channel2` message from the given peer. + */ + void handle_open_channel_v2(byte[] their_node_id, OpenChannelV2 msg); + /** + * Handle an incoming `accept_channel` message from the given peer. */ - void handle_open_channel(byte[] their_node_id, InitFeatures their_features, OpenChannel msg); + void handle_accept_channel(byte[] their_node_id, AcceptChannel msg); /** - * Handle an incoming accept_channel message from the given peer. + * Handle an incoming `accept_channel2` message from the given peer. */ - void handle_accept_channel(byte[] their_node_id, InitFeatures their_features, AcceptChannel msg); + void handle_accept_channel_v2(byte[] their_node_id, AcceptChannelV2 msg); /** - * Handle an incoming funding_created message from the given peer. + * Handle an incoming `funding_created` message from the given peer. */ void handle_funding_created(byte[] their_node_id, FundingCreated msg); /** - * Handle an incoming funding_signed message from the given peer. + * Handle an incoming `funding_signed` message from the given peer. */ void handle_funding_signed(byte[] their_node_id, FundingSigned msg); /** - * Handle an incoming channel_ready message from the given peer. + * Handle an incoming `channel_ready` message from the given peer. */ void handle_channel_ready(byte[] their_node_id, ChannelReady msg); /** - * Handle an incoming shutdown message from the given peer. + * Handle an incoming `shutdown` message from the given peer. */ - void handle_shutdown(byte[] their_node_id, InitFeatures their_features, Shutdown msg); + void handle_shutdown(byte[] their_node_id, Shutdown msg); /** - * Handle an incoming closing_signed message from the given peer. + * Handle an incoming `closing_signed` message from the given peer. */ void handle_closing_signed(byte[] their_node_id, ClosingSigned msg); /** - * Handle an incoming update_add_htlc message from the given peer. + * Handle an incoming `tx_add_input message` from the given peer. + */ + void handle_tx_add_input(byte[] their_node_id, TxAddInput msg); + /** + * Handle an incoming `tx_add_output` message from the given peer. + */ + void handle_tx_add_output(byte[] their_node_id, TxAddOutput msg); + /** + * Handle an incoming `tx_remove_input` message from the given peer. + */ + void handle_tx_remove_input(byte[] their_node_id, TxRemoveInput msg); + /** + * Handle an incoming `tx_remove_output` message from the given peer. + */ + void handle_tx_remove_output(byte[] their_node_id, TxRemoveOutput msg); + /** + * Handle an incoming `tx_complete message` from the given peer. + */ + void handle_tx_complete(byte[] their_node_id, TxComplete msg); + /** + * Handle an incoming `tx_signatures` message from the given peer. + */ + void handle_tx_signatures(byte[] their_node_id, TxSignatures msg); + /** + * Handle an incoming `tx_init_rbf` message from the given peer. + */ + void handle_tx_init_rbf(byte[] their_node_id, TxInitRbf msg); + /** + * Handle an incoming `tx_ack_rbf` message from the given peer. + */ + void handle_tx_ack_rbf(byte[] their_node_id, TxAckRbf msg); + /** + * Handle an incoming `tx_abort message` from the given peer. + */ + void handle_tx_abort(byte[] their_node_id, TxAbort msg); + /** + * Handle an incoming `update_add_htlc` message from the given peer. */ void handle_update_add_htlc(byte[] their_node_id, UpdateAddHTLC msg); /** - * Handle an incoming update_fulfill_htlc message from the given peer. + * Handle an incoming `update_fulfill_htlc` message from the given peer. */ void handle_update_fulfill_htlc(byte[] their_node_id, UpdateFulfillHTLC msg); /** - * Handle an incoming update_fail_htlc message from the given peer. + * Handle an incoming `update_fail_htlc` message from the given peer. */ void handle_update_fail_htlc(byte[] their_node_id, UpdateFailHTLC msg); /** - * Handle an incoming update_fail_malformed_htlc message from the given peer. + * Handle an incoming `update_fail_malformed_htlc` message from the given peer. */ void handle_update_fail_malformed_htlc(byte[] their_node_id, UpdateFailMalformedHTLC msg); /** - * Handle an incoming commitment_signed message from the given peer. + * Handle an incoming `commitment_signed` message from the given peer. */ void handle_commitment_signed(byte[] their_node_id, CommitmentSigned msg); /** - * Handle an incoming revoke_and_ack message from the given peer. + * Handle an incoming `revoke_and_ack` message from the given peer. */ void handle_revoke_and_ack(byte[] their_node_id, RevokeAndACK msg); /** - * Handle an incoming update_fee message from the given peer. + * Handle an incoming `update_fee` message from the given peer. */ void handle_update_fee(byte[] their_node_id, UpdateFee msg); /** - * Handle an incoming announcement_signatures message from the given peer. + * Handle an incoming `announcement_signatures` message from the given peer. */ void handle_announcement_signatures(byte[] their_node_id, AnnouncementSignatures msg); /** - * Indicates a connection to the peer failed/an existing connection was lost. If no connection - * is believed to be possible in the future (eg they're sending us messages we don't - * understand or indicate they require unknown feature bits), no_connection_possible is set - * and any outstanding channels should be failed. - * - * Note that in some rare cases this may be called without a corresponding - * [`Self::peer_connected`]. + * Indicates a connection to the peer failed/an existing connection was lost. */ - void peer_disconnected(byte[] their_node_id, boolean no_connection_possible); + void peer_disconnected(byte[] their_node_id); /** - * Handle a peer reconnecting, possibly generating channel_reestablish message(s). + * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s). * * May return an `Err(())` if the features the peer supports are not sufficient to communicate * with us. Implementors should be somewhat conservative about doing so, however, as other * message handlers may still wish to communicate with this peer. */ - Result_NoneNoneZ peer_connected(byte[] their_node_id, Init msg); + Result_NoneNoneZ peer_connected(byte[] their_node_id, Init msg, boolean inbound); /** - * Handle an incoming channel_reestablish message from the given peer. + * Handle an incoming `channel_reestablish` message from the given peer. */ void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish msg); /** - * Handle an incoming channel update from the given peer. + * Handle an incoming `channel_update` message from the given peer. */ void handle_channel_update(byte[] their_node_id, ChannelUpdate msg); /** - * Handle an incoming error message from the given peer. + * Handle an incoming `error` message from the given peer. */ void handle_error(byte[] their_node_id, ErrorMessage msg); /** @@ -133,23 +183,36 @@ public class ChannelMessageHandler extends CommonBase { * Note that this method is called before [`Self::peer_connected`]. */ InitFeatures provided_init_features(byte[] their_node_id); + /** + * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports. + * + * If it's `None`, then no particular network chain hash compatibility will be enforced when + * connecting to peers. + */ + Option_CVec_ThirtyTwoBytesZZ get_chain_hashes(); } private static class LDKChannelMessageHandlerHolder { ChannelMessageHandler held; } public static ChannelMessageHandler new_impl(ChannelMessageHandlerInterface arg, MessageSendEventsProvider.MessageSendEventsProviderInterface MessageSendEventsProvider_impl) { final LDKChannelMessageHandlerHolder impl_holder = new LDKChannelMessageHandlerHolder(); impl_holder.held = new ChannelMessageHandler(new bindings.LDKChannelMessageHandler() { - @Override public void handle_open_channel(byte[] their_node_id, long their_features, long msg) { - org.ldk.structs.InitFeatures their_features_hu_conv = null; if (their_features < 0 || their_features > 4096) { their_features_hu_conv = new org.ldk.structs.InitFeatures(null, their_features); } - if (their_features_hu_conv != null) { their_features_hu_conv.ptrs_to.add(this); }; + @Override public void handle_open_channel(byte[] their_node_id, long msg) { org.ldk.structs.OpenChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.OpenChannel(null, msg); } - arg.handle_open_channel(their_node_id, their_features_hu_conv, msg_hu_conv); + arg.handle_open_channel(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } - @Override public void handle_accept_channel(byte[] their_node_id, long their_features, long msg) { - org.ldk.structs.InitFeatures their_features_hu_conv = null; if (their_features < 0 || their_features > 4096) { their_features_hu_conv = new org.ldk.structs.InitFeatures(null, their_features); } - if (their_features_hu_conv != null) { their_features_hu_conv.ptrs_to.add(this); }; + @Override public void handle_open_channel_v2(byte[] their_node_id, long msg) { + org.ldk.structs.OpenChannelV2 msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.OpenChannelV2(null, msg); } + arg.handle_open_channel_v2(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_accept_channel(byte[] their_node_id, long msg) { org.ldk.structs.AcceptChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AcceptChannel(null, msg); } - arg.handle_accept_channel(their_node_id, their_features_hu_conv, msg_hu_conv); + arg.handle_accept_channel(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_accept_channel_v2(byte[] their_node_id, long msg) { + org.ldk.structs.AcceptChannelV2 msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AcceptChannelV2(null, msg); } + arg.handle_accept_channel_v2(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } @Override public void handle_funding_created(byte[] their_node_id, long msg) { @@ -167,10 +230,9 @@ public class ChannelMessageHandler extends CommonBase { arg.handle_channel_ready(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } - @Override public void handle_shutdown(byte[] their_node_id, long their_features, long msg) { - org.ldk.structs.InitFeatures their_features_hu_conv = null; if (their_features < 0 || their_features > 4096) { their_features_hu_conv = new org.ldk.structs.InitFeatures(null, their_features); } + @Override public void handle_shutdown(byte[] their_node_id, long msg) { org.ldk.structs.Shutdown msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.Shutdown(null, msg); } - arg.handle_shutdown(their_node_id, their_features_hu_conv, msg_hu_conv); + arg.handle_shutdown(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } @Override public void handle_closing_signed(byte[] their_node_id, long msg) { @@ -178,6 +240,51 @@ public class ChannelMessageHandler extends CommonBase { arg.handle_closing_signed(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } + @Override public void handle_tx_add_input(byte[] their_node_id, long msg) { + org.ldk.structs.TxAddInput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAddInput(null, msg); } + arg.handle_tx_add_input(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_add_output(byte[] their_node_id, long msg) { + org.ldk.structs.TxAddOutput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAddOutput(null, msg); } + arg.handle_tx_add_output(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_remove_input(byte[] their_node_id, long msg) { + org.ldk.structs.TxRemoveInput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxRemoveInput(null, msg); } + arg.handle_tx_remove_input(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_remove_output(byte[] their_node_id, long msg) { + org.ldk.structs.TxRemoveOutput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxRemoveOutput(null, msg); } + arg.handle_tx_remove_output(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_complete(byte[] their_node_id, long msg) { + org.ldk.structs.TxComplete msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxComplete(null, msg); } + arg.handle_tx_complete(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_signatures(byte[] their_node_id, long msg) { + org.ldk.structs.TxSignatures msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxSignatures(null, msg); } + arg.handle_tx_signatures(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_init_rbf(byte[] their_node_id, long msg) { + org.ldk.structs.TxInitRbf msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxInitRbf(null, msg); } + arg.handle_tx_init_rbf(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_ack_rbf(byte[] their_node_id, long msg) { + org.ldk.structs.TxAckRbf msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAckRbf(null, msg); } + arg.handle_tx_ack_rbf(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } + @Override public void handle_tx_abort(byte[] their_node_id, long msg) { + org.ldk.structs.TxAbort msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAbort(null, msg); } + arg.handle_tx_abort(their_node_id, msg_hu_conv); + Reference.reachabilityFence(arg); + } @Override public void handle_update_add_htlc(byte[] their_node_id, long msg) { org.ldk.structs.UpdateAddHTLC msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.UpdateAddHTLC(null, msg); } arg.handle_update_add_htlc(their_node_id, msg_hu_conv); @@ -218,13 +325,13 @@ public class ChannelMessageHandler extends CommonBase { arg.handle_announcement_signatures(their_node_id, msg_hu_conv); Reference.reachabilityFence(arg); } - @Override public void peer_disconnected(byte[] their_node_id, boolean no_connection_possible) { - arg.peer_disconnected(their_node_id, no_connection_possible); + @Override public void peer_disconnected(byte[] their_node_id) { + arg.peer_disconnected(their_node_id); Reference.reachabilityFence(arg); } - @Override public long peer_connected(byte[] their_node_id, long msg) { + @Override public long peer_connected(byte[] their_node_id, long msg, boolean inbound) { org.ldk.structs.Init msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.Init(null, msg); } - Result_NoneNoneZ ret = arg.peer_connected(their_node_id, msg_hu_conv); + Result_NoneNoneZ ret = arg.peer_connected(their_node_id, msg_hu_conv, inbound); Reference.reachabilityFence(arg); long result = ret == null ? 0 : ret.clone_ptr(); return result; @@ -256,6 +363,13 @@ public class ChannelMessageHandler extends CommonBase { long result = ret == null ? 0 : ret.clone_ptr(); return result; } + @Override public long get_chain_hashes() { + Option_CVec_ThirtyTwoBytesZZ ret = arg.get_chain_hashes(); + Reference.reachabilityFence(arg); + long result = ret == null ? 0 : ret.clone_ptr(); + if (impl_holder.held != null) { impl_holder.held.ptrs_to.add(ret); }; + return result; + } }, MessageSendEventsProvider.new_impl(MessageSendEventsProvider_impl).bindings_instance); return impl_holder.held; } @@ -265,40 +379,58 @@ public class ChannelMessageHandler extends CommonBase { */ public MessageSendEventsProvider get_message_send_events_provider() { MessageSendEventsProvider res = new MessageSendEventsProvider(null, bindings.LDKChannelMessageHandler_get_MessageSendEventsProvider(this.ptr)); - this.ptrs_to.add(res); + res.ptrs_to.add(this); return res; } /** - * Handle an incoming open_channel message from the given peer. + * Handle an incoming `open_channel` message from the given peer. + */ + public void handle_open_channel(byte[] their_node_id, org.ldk.structs.OpenChannel msg) { + bindings.ChannelMessageHandler_handle_open_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `open_channel2` message from the given peer. */ - public void handle_open_channel(byte[] their_node_id, InitFeatures their_features, OpenChannel msg) { - bindings.ChannelMessageHandler_handle_open_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr, msg == null ? 0 : msg.ptr); + public void handle_open_channel_v2(byte[] their_node_id, org.ldk.structs.OpenChannelV2 msg) { + bindings.ChannelMessageHandler_handle_open_channel_v2(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); - Reference.reachabilityFence(their_features); Reference.reachabilityFence(msg); - if (this != null) { this.ptrs_to.add(their_features); }; if (this != null) { this.ptrs_to.add(msg); }; } /** - * Handle an incoming accept_channel message from the given peer. + * Handle an incoming `accept_channel` message from the given peer. */ - public void handle_accept_channel(byte[] their_node_id, InitFeatures their_features, AcceptChannel msg) { - bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr, msg == null ? 0 : msg.ptr); + public void handle_accept_channel(byte[] their_node_id, org.ldk.structs.AcceptChannel msg) { + bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); - Reference.reachabilityFence(their_features); Reference.reachabilityFence(msg); - if (this != null) { this.ptrs_to.add(their_features); }; if (this != null) { this.ptrs_to.add(msg); }; } /** - * Handle an incoming funding_created message from the given peer. + * Handle an incoming `accept_channel2` message from the given peer. */ - public void handle_funding_created(byte[] their_node_id, FundingCreated msg) { + public void handle_accept_channel_v2(byte[] their_node_id, org.ldk.structs.AcceptChannelV2 msg) { + bindings.ChannelMessageHandler_handle_accept_channel_v2(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `funding_created` message from the given peer. + */ + public void handle_funding_created(byte[] their_node_id, org.ldk.structs.FundingCreated msg) { bindings.ChannelMessageHandler_handle_funding_created(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -307,9 +439,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming funding_signed message from the given peer. + * Handle an incoming `funding_signed` message from the given peer. */ - public void handle_funding_signed(byte[] their_node_id, FundingSigned msg) { + public void handle_funding_signed(byte[] their_node_id, org.ldk.structs.FundingSigned msg) { bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -318,9 +450,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming channel_ready message from the given peer. + * Handle an incoming `channel_ready` message from the given peer. */ - public void handle_channel_ready(byte[] their_node_id, ChannelReady msg) { + public void handle_channel_ready(byte[] their_node_id, org.ldk.structs.ChannelReady msg) { bindings.ChannelMessageHandler_handle_channel_ready(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -329,22 +461,20 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming shutdown message from the given peer. + * Handle an incoming `shutdown` message from the given peer. */ - public void handle_shutdown(byte[] their_node_id, InitFeatures their_features, Shutdown msg) { - bindings.ChannelMessageHandler_handle_shutdown(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), their_features == null ? 0 : their_features.ptr, msg == null ? 0 : msg.ptr); + public void handle_shutdown(byte[] their_node_id, org.ldk.structs.Shutdown msg) { + bindings.ChannelMessageHandler_handle_shutdown(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); - Reference.reachabilityFence(their_features); Reference.reachabilityFence(msg); - if (this != null) { this.ptrs_to.add(their_features); }; if (this != null) { this.ptrs_to.add(msg); }; } /** - * Handle an incoming closing_signed message from the given peer. + * Handle an incoming `closing_signed` message from the given peer. */ - public void handle_closing_signed(byte[] their_node_id, ClosingSigned msg) { + public void handle_closing_signed(byte[] their_node_id, org.ldk.structs.ClosingSigned msg) { bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -353,9 +483,108 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming update_add_htlc message from the given peer. + * Handle an incoming `tx_add_input message` from the given peer. + */ + public void handle_tx_add_input(byte[] their_node_id, org.ldk.structs.TxAddInput msg) { + bindings.ChannelMessageHandler_handle_tx_add_input(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_add_output` message from the given peer. + */ + public void handle_tx_add_output(byte[] their_node_id, org.ldk.structs.TxAddOutput msg) { + bindings.ChannelMessageHandler_handle_tx_add_output(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_remove_input` message from the given peer. + */ + public void handle_tx_remove_input(byte[] their_node_id, org.ldk.structs.TxRemoveInput msg) { + bindings.ChannelMessageHandler_handle_tx_remove_input(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_remove_output` message from the given peer. */ - public void handle_update_add_htlc(byte[] their_node_id, UpdateAddHTLC msg) { + public void handle_tx_remove_output(byte[] their_node_id, org.ldk.structs.TxRemoveOutput msg) { + bindings.ChannelMessageHandler_handle_tx_remove_output(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_complete message` from the given peer. + */ + public void handle_tx_complete(byte[] their_node_id, org.ldk.structs.TxComplete msg) { + bindings.ChannelMessageHandler_handle_tx_complete(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_signatures` message from the given peer. + */ + public void handle_tx_signatures(byte[] their_node_id, org.ldk.structs.TxSignatures msg) { + bindings.ChannelMessageHandler_handle_tx_signatures(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_init_rbf` message from the given peer. + */ + public void handle_tx_init_rbf(byte[] their_node_id, org.ldk.structs.TxInitRbf msg) { + bindings.ChannelMessageHandler_handle_tx_init_rbf(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_ack_rbf` message from the given peer. + */ + public void handle_tx_ack_rbf(byte[] their_node_id, org.ldk.structs.TxAckRbf msg) { + bindings.ChannelMessageHandler_handle_tx_ack_rbf(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `tx_abort message` from the given peer. + */ + public void handle_tx_abort(byte[] their_node_id, org.ldk.structs.TxAbort msg) { + bindings.ChannelMessageHandler_handle_tx_abort(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + Reference.reachabilityFence(this); + Reference.reachabilityFence(their_node_id); + Reference.reachabilityFence(msg); + if (this != null) { this.ptrs_to.add(msg); }; + } + + /** + * Handle an incoming `update_add_htlc` message from the given peer. + */ + public void handle_update_add_htlc(byte[] their_node_id, org.ldk.structs.UpdateAddHTLC msg) { bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -364,9 +593,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming update_fulfill_htlc message from the given peer. + * Handle an incoming `update_fulfill_htlc` message from the given peer. */ - public void handle_update_fulfill_htlc(byte[] their_node_id, UpdateFulfillHTLC msg) { + public void handle_update_fulfill_htlc(byte[] their_node_id, org.ldk.structs.UpdateFulfillHTLC msg) { bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -375,9 +604,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming update_fail_htlc message from the given peer. + * Handle an incoming `update_fail_htlc` message from the given peer. */ - public void handle_update_fail_htlc(byte[] their_node_id, UpdateFailHTLC msg) { + public void handle_update_fail_htlc(byte[] their_node_id, org.ldk.structs.UpdateFailHTLC msg) { bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -386,9 +615,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming update_fail_malformed_htlc message from the given peer. + * Handle an incoming `update_fail_malformed_htlc` message from the given peer. */ - public void handle_update_fail_malformed_htlc(byte[] their_node_id, UpdateFailMalformedHTLC msg) { + public void handle_update_fail_malformed_htlc(byte[] their_node_id, org.ldk.structs.UpdateFailMalformedHTLC msg) { bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -397,9 +626,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming commitment_signed message from the given peer. + * Handle an incoming `commitment_signed` message from the given peer. */ - public void handle_commitment_signed(byte[] their_node_id, CommitmentSigned msg) { + public void handle_commitment_signed(byte[] their_node_id, org.ldk.structs.CommitmentSigned msg) { bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -408,9 +637,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming revoke_and_ack message from the given peer. + * Handle an incoming `revoke_and_ack` message from the given peer. */ - public void handle_revoke_and_ack(byte[] their_node_id, RevokeAndACK msg) { + public void handle_revoke_and_ack(byte[] their_node_id, org.ldk.structs.RevokeAndACK msg) { bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -419,9 +648,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming update_fee message from the given peer. + * Handle an incoming `update_fee` message from the given peer. */ - public void handle_update_fee(byte[] their_node_id, UpdateFee msg) { + public void handle_update_fee(byte[] their_node_id, org.ldk.structs.UpdateFee msg) { bindings.ChannelMessageHandler_handle_update_fee(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -430,9 +659,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming announcement_signatures message from the given peer. + * Handle an incoming `announcement_signatures` message from the given peer. */ - public void handle_announcement_signatures(byte[] their_node_id, AnnouncementSignatures msg) { + public void handle_announcement_signatures(byte[] their_node_id, org.ldk.structs.AnnouncementSignatures msg) { bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -441,33 +670,27 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Indicates a connection to the peer failed/an existing connection was lost. If no connection - * is believed to be possible in the future (eg they're sending us messages we don't - * understand or indicate they require unknown feature bits), no_connection_possible is set - * and any outstanding channels should be failed. - * - * Note that in some rare cases this may be called without a corresponding - * [`Self::peer_connected`]. + * Indicates a connection to the peer failed/an existing connection was lost. */ - public void peer_disconnected(byte[] their_node_id, boolean no_connection_possible) { - bindings.ChannelMessageHandler_peer_disconnected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), no_connection_possible); + public void peer_disconnected(byte[] their_node_id) { + bindings.ChannelMessageHandler_peer_disconnected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33)); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); - Reference.reachabilityFence(no_connection_possible); } /** - * Handle a peer reconnecting, possibly generating channel_reestablish message(s). + * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s). * * May return an `Err(())` if the features the peer supports are not sufficient to communicate * with us. Implementors should be somewhat conservative about doing so, however, as other * message handlers may still wish to communicate with this peer. */ - public Result_NoneNoneZ peer_connected(byte[] their_node_id, Init msg) { - long ret = bindings.ChannelMessageHandler_peer_connected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); + public Result_NoneNoneZ peer_connected(byte[] their_node_id, org.ldk.structs.Init msg, boolean inbound) { + long ret = bindings.ChannelMessageHandler_peer_connected(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr, inbound); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); Reference.reachabilityFence(msg); + Reference.reachabilityFence(inbound); if (ret >= 0 && ret <= 4096) { return null; } Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret); if (this != null) { this.ptrs_to.add(msg); }; @@ -475,9 +698,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming channel_reestablish message from the given peer. + * Handle an incoming `channel_reestablish` message from the given peer. */ - public void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish msg) { + public void handle_channel_reestablish(byte[] their_node_id, org.ldk.structs.ChannelReestablish msg) { bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -486,9 +709,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming channel update from the given peer. + * Handle an incoming `channel_update` message from the given peer. */ - public void handle_channel_update(byte[] their_node_id, ChannelUpdate msg) { + public void handle_channel_update(byte[] their_node_id, org.ldk.structs.ChannelUpdate msg) { bindings.ChannelMessageHandler_handle_channel_update(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -497,9 +720,9 @@ public class ChannelMessageHandler extends CommonBase { } /** - * Handle an incoming error message from the given peer. + * Handle an incoming `error` message from the given peer. */ - public void handle_error(byte[] their_node_id, ErrorMessage msg) { + public void handle_error(byte[] their_node_id, org.ldk.structs.ErrorMessage msg) { bindings.ChannelMessageHandler_handle_error(this.ptr, InternalUtils.check_arr_len(their_node_id, 33), msg == null ? 0 : msg.ptr); Reference.reachabilityFence(this); Reference.reachabilityFence(their_node_id); @@ -538,4 +761,19 @@ public class ChannelMessageHandler extends CommonBase { return ret_hu_conv; } + /** + * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports. + * + * If it's `None`, then no particular network chain hash compatibility will be enforced when + * connecting to peers. + */ + public Option_CVec_ThirtyTwoBytesZZ get_chain_hashes() { + long ret = bindings.ChannelMessageHandler_get_chain_hashes(this.ptr); + Reference.reachabilityFence(this); + if (ret >= 0 && ret <= 4096) { return null; } + org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ ret_hu_conv = org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); }; + return ret_hu_conv; + } + }