_ Git - ldk-java/blob - c_sharp/src/org/ldk/structs/ChannelMessageHandler.cs

   1
   2 using org.ldk.impl;
   3 using org.ldk.enums;
   4 using org.ldk.util;
   5 using System;
   6
   7 namespace org { namespace ldk { namespace structs {
   8
   9
  10
  11 /** An implementation of ChannelMessageHandler */
  12 public interface ChannelMessageHandlerInterface {
  13         /**Handle an incoming `open_channel` message from the given peer.
  14          */
  15         void handle_open_channel(byte[] their_node_id, OpenChannel msg);
  16         /**Handle an incoming `open_channel2` message from the given peer.
  17          */
  18         void handle_open_channel_v2(byte[] their_node_id, OpenChannelV2 msg);
  19         /**Handle an incoming `accept_channel` message from the given peer.
  20          */
  21         void handle_accept_channel(byte[] their_node_id, AcceptChannel msg);
  22         /**Handle an incoming `accept_channel2` message from the given peer.
  23          */
  24         void handle_accept_channel_v2(byte[] their_node_id, AcceptChannelV2 msg);
  25         /**Handle an incoming `funding_created` message from the given peer.
  26          */
  27         void handle_funding_created(byte[] their_node_id, FundingCreated msg);
  28         /**Handle an incoming `funding_signed` message from the given peer.
  29          */
  30         void handle_funding_signed(byte[] their_node_id, FundingSigned msg);
  31         /**Handle an incoming `channel_ready` message from the given peer.
  32          */
  33         void handle_channel_ready(byte[] their_node_id, ChannelReady msg);
  34         /**Handle an incoming `shutdown` message from the given peer.
  35          */
  36         void handle_shutdown(byte[] their_node_id, Shutdown msg);
  37         /**Handle an incoming `closing_signed` message from the given peer.
  38          */
  39         void handle_closing_signed(byte[] their_node_id, ClosingSigned msg);
  40         /**Handle an incoming `tx_add_input message` from the given peer.
  41          */
  42         void handle_tx_add_input(byte[] their_node_id, TxAddInput msg);
  43         /**Handle an incoming `tx_add_output` message from the given peer.
  44          */
  45         void handle_tx_add_output(byte[] their_node_id, TxAddOutput msg);
  46         /**Handle an incoming `tx_remove_input` message from the given peer.
  47          */
  48         void handle_tx_remove_input(byte[] their_node_id, TxRemoveInput msg);
  49         /**Handle an incoming `tx_remove_output` message from the given peer.
  50          */
  51         void handle_tx_remove_output(byte[] their_node_id, TxRemoveOutput msg);
  52         /**Handle an incoming `tx_complete message` from the given peer.
  53          */
  54         void handle_tx_complete(byte[] their_node_id, TxComplete msg);
  55         /**Handle an incoming `tx_signatures` message from the given peer.
  56          */
  57         void handle_tx_signatures(byte[] their_node_id, TxSignatures msg);
  58         /**Handle an incoming `tx_init_rbf` message from the given peer.
  59          */
  60         void handle_tx_init_rbf(byte[] their_node_id, TxInitRbf msg);
  61         /**Handle an incoming `tx_ack_rbf` message from the given peer.
  62          */
  63         void handle_tx_ack_rbf(byte[] their_node_id, TxAckRbf msg);
  64         /**Handle an incoming `tx_abort message` from the given peer.
  65          */
  66         void handle_tx_abort(byte[] their_node_id, TxAbort msg);
  67         /**Handle an incoming `update_add_htlc` message from the given peer.
  68          */
  69         void handle_update_add_htlc(byte[] their_node_id, UpdateAddHTLC msg);
  70         /**Handle an incoming `update_fulfill_htlc` message from the given peer.
  71          */
  72         void handle_update_fulfill_htlc(byte[] their_node_id, UpdateFulfillHTLC msg);
  73         /**Handle an incoming `update_fail_htlc` message from the given peer.
  74          */
  75         void handle_update_fail_htlc(byte[] their_node_id, UpdateFailHTLC msg);
  76         /**Handle an incoming `update_fail_malformed_htlc` message from the given peer.
  77          */
  78         void handle_update_fail_malformed_htlc(byte[] their_node_id, UpdateFailMalformedHTLC msg);
  79         /**Handle an incoming `commitment_signed` message from the given peer.
  80          */
  81         void handle_commitment_signed(byte[] their_node_id, CommitmentSigned msg);
  82         /**Handle an incoming `revoke_and_ack` message from the given peer.
  83          */
  84         void handle_revoke_and_ack(byte[] their_node_id, RevokeAndACK msg);
  85         /**Handle an incoming `update_fee` message from the given peer.
  86          */
  87         void handle_update_fee(byte[] their_node_id, UpdateFee msg);
  88         /**Handle an incoming `announcement_signatures` message from the given peer.
  89          */
  90         void handle_announcement_signatures(byte[] their_node_id, AnnouncementSignatures msg);
  91         /**Indicates a connection to the peer failed/an existing connection was lost.
  92          */
  93         void peer_disconnected(byte[] their_node_id);
  94         /**Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
  95          *
  96          * May return an `Err(())` if the features the peer supports are not sufficient to communicate
  97          * with us. Implementors should be somewhat conservative about doing so, however, as other
  98          * message handlers may still wish to communicate with this peer.
  99          */
 100         Result_NoneNoneZ peer_connected(byte[] their_node_id, Init msg, bool inbound);
 101         /**Handle an incoming `channel_reestablish` message from the given peer.
 102          */
 103         void handle_channel_reestablish(byte[] their_node_id, ChannelReestablish msg);
 104         /**Handle an incoming `channel_update` message from the given peer.
 105          */
 106         void handle_channel_update(byte[] their_node_id, ChannelUpdate msg);
 107         /**Handle an incoming `error` message from the given peer.
 108          */
 109         void handle_error(byte[] their_node_id, ErrorMessage msg);
 110         /**Gets the node feature flags which this handler itself supports. All available handlers are
 111          * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
 112          * which are broadcasted in our [`NodeAnnouncement`] message.
 113          */
 114         NodeFeatures provided_node_features();
 115         /**Gets the init feature flags which should be sent to the given peer. All available handlers
 116          * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
 117          * which are sent in our [`Init`] message.
 118          *
 119          * Note that this method is called before [`Self::peer_connected`].
 120          */
 121         InitFeatures provided_init_features(byte[] their_node_id);
 122         /**Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
 123          *
 124          * If it's `None`, then no particular network chain hash compatibility will be enforced when
 125          * connecting to peers.
 126          */
 127         Option_CVec_ThirtyTwoBytesZZ get_chain_hashes();
 128 }
 129
 130 /**
 131  * A trait to describe an object which can receive channel messages.
 132  *
 133  * Messages MAY be called in parallel when they originate from different `their_node_ids`, however
 134  * they MUST NOT be called in parallel when the two calls have the same `their_node_id`.
 135  */
 136 public class ChannelMessageHandler : CommonBase {
 137         internal bindings.LDKChannelMessageHandler bindings_instance;
 138         internal long instance_idx;
 139
 140         internal ChannelMessageHandler(object _dummy, long ptr) : base(ptr) { bindings_instance = null; }
 141         ~ChannelMessageHandler() {
 142                 if (ptr != 0) { bindings.ChannelMessageHandler_free(ptr); }
 143         }
 144
 145         private class LDKChannelMessageHandlerHolder { internal ChannelMessageHandler held; }
 146         private class LDKChannelMessageHandlerImpl : bindings.LDKChannelMessageHandler {
 147                 internal LDKChannelMessageHandlerImpl(ChannelMessageHandlerInterface arg, LDKChannelMessageHandlerHolder impl_holder) { this.arg = arg; this.impl_holder = impl_holder; }
 148                 private ChannelMessageHandlerInterface arg;
 149                 private LDKChannelMessageHandlerHolder impl_holder;
 150                 public void handle_open_channel(long _their_node_id, long _msg) {
 151                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 152                         org.ldk.structs.OpenChannel _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.OpenChannel(null, _msg); }
 153                         arg.handle_open_channel(_their_node_id_conv, _msg_hu_conv);
 154                                 GC.KeepAlive(arg);
 155                 }
 156                 public void handle_open_channel_v2(long _their_node_id, long _msg) {
 157                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 158                         org.ldk.structs.OpenChannelV2 _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.OpenChannelV2(null, _msg); }
 159                         arg.handle_open_channel_v2(_their_node_id_conv, _msg_hu_conv);
 160                                 GC.KeepAlive(arg);
 161                 }
 162                 public void handle_accept_channel(long _their_node_id, long _msg) {
 163                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 164                         org.ldk.structs.AcceptChannel _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.AcceptChannel(null, _msg); }
 165                         arg.handle_accept_channel(_their_node_id_conv, _msg_hu_conv);
 166                                 GC.KeepAlive(arg);
 167                 }
 168                 public void handle_accept_channel_v2(long _their_node_id, long _msg) {
 169                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 170                         org.ldk.structs.AcceptChannelV2 _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.AcceptChannelV2(null, _msg); }
 171                         arg.handle_accept_channel_v2(_their_node_id_conv, _msg_hu_conv);
 172                                 GC.KeepAlive(arg);
 173                 }
 174                 public void handle_funding_created(long _their_node_id, long _msg) {
 175                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 176                         org.ldk.structs.FundingCreated _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.FundingCreated(null, _msg); }
 177                         arg.handle_funding_created(_their_node_id_conv, _msg_hu_conv);
 178                                 GC.KeepAlive(arg);
 179                 }
 180                 public void handle_funding_signed(long _their_node_id, long _msg) {
 181                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 182                         org.ldk.structs.FundingSigned _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.FundingSigned(null, _msg); }
 183                         arg.handle_funding_signed(_their_node_id_conv, _msg_hu_conv);
 184                                 GC.KeepAlive(arg);
 185                 }
 186                 public void handle_channel_ready(long _their_node_id, long _msg) {
 187                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 188                         org.ldk.structs.ChannelReady _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.ChannelReady(null, _msg); }
 189                         arg.handle_channel_ready(_their_node_id_conv, _msg_hu_conv);
 190                                 GC.KeepAlive(arg);
 191                 }
 192                 public void handle_shutdown(long _their_node_id, long _msg) {
 193                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 194                         org.ldk.structs.Shutdown _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.Shutdown(null, _msg); }
 195                         arg.handle_shutdown(_their_node_id_conv, _msg_hu_conv);
 196                                 GC.KeepAlive(arg);
 197                 }
 198                 public void handle_closing_signed(long _their_node_id, long _msg) {
 199                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 200                         org.ldk.structs.ClosingSigned _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.ClosingSigned(null, _msg); }
 201                         arg.handle_closing_signed(_their_node_id_conv, _msg_hu_conv);
 202                                 GC.KeepAlive(arg);
 203                 }
 204                 public void handle_tx_add_input(long _their_node_id, long _msg) {
 205                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 206                         org.ldk.structs.TxAddInput _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxAddInput(null, _msg); }
 207                         arg.handle_tx_add_input(_their_node_id_conv, _msg_hu_conv);
 208                                 GC.KeepAlive(arg);
 209                 }
 210                 public void handle_tx_add_output(long _their_node_id, long _msg) {
 211                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 212                         org.ldk.structs.TxAddOutput _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxAddOutput(null, _msg); }
 213                         arg.handle_tx_add_output(_their_node_id_conv, _msg_hu_conv);
 214                                 GC.KeepAlive(arg);
 215                 }
 216                 public void handle_tx_remove_input(long _their_node_id, long _msg) {
 217                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 218                         org.ldk.structs.TxRemoveInput _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxRemoveInput(null, _msg); }
 219                         arg.handle_tx_remove_input(_their_node_id_conv, _msg_hu_conv);
 220                                 GC.KeepAlive(arg);
 221                 }
 222                 public void handle_tx_remove_output(long _their_node_id, long _msg) {
 223                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 224                         org.ldk.structs.TxRemoveOutput _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxRemoveOutput(null, _msg); }
 225                         arg.handle_tx_remove_output(_their_node_id_conv, _msg_hu_conv);
 226                                 GC.KeepAlive(arg);
 227                 }
 228                 public void handle_tx_complete(long _their_node_id, long _msg) {
 229                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 230                         org.ldk.structs.TxComplete _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxComplete(null, _msg); }
 231                         arg.handle_tx_complete(_their_node_id_conv, _msg_hu_conv);
 232                                 GC.KeepAlive(arg);
 233                 }
 234                 public void handle_tx_signatures(long _their_node_id, long _msg) {
 235                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 236                         org.ldk.structs.TxSignatures _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxSignatures(null, _msg); }
 237                         arg.handle_tx_signatures(_their_node_id_conv, _msg_hu_conv);
 238                                 GC.KeepAlive(arg);
 239                 }
 240                 public void handle_tx_init_rbf(long _their_node_id, long _msg) {
 241                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 242                         org.ldk.structs.TxInitRbf _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxInitRbf(null, _msg); }
 243                         arg.handle_tx_init_rbf(_their_node_id_conv, _msg_hu_conv);
 244                                 GC.KeepAlive(arg);
 245                 }
 246                 public void handle_tx_ack_rbf(long _their_node_id, long _msg) {
 247                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 248                         org.ldk.structs.TxAckRbf _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxAckRbf(null, _msg); }
 249                         arg.handle_tx_ack_rbf(_their_node_id_conv, _msg_hu_conv);
 250                                 GC.KeepAlive(arg);
 251                 }
 252                 public void handle_tx_abort(long _their_node_id, long _msg) {
 253                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 254                         org.ldk.structs.TxAbort _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.TxAbort(null, _msg); }
 255                         arg.handle_tx_abort(_their_node_id_conv, _msg_hu_conv);
 256                                 GC.KeepAlive(arg);
 257                 }
 258                 public void handle_update_add_htlc(long _their_node_id, long _msg) {
 259                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 260                         org.ldk.structs.UpdateAddHTLC _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.UpdateAddHTLC(null, _msg); }
 261                         arg.handle_update_add_htlc(_their_node_id_conv, _msg_hu_conv);
 262                                 GC.KeepAlive(arg);
 263                 }
 264                 public void handle_update_fulfill_htlc(long _their_node_id, long _msg) {
 265                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 266                         org.ldk.structs.UpdateFulfillHTLC _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.UpdateFulfillHTLC(null, _msg); }
 267                         arg.handle_update_fulfill_htlc(_their_node_id_conv, _msg_hu_conv);
 268                                 GC.KeepAlive(arg);
 269                 }
 270                 public void handle_update_fail_htlc(long _their_node_id, long _msg) {
 271                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 272                         org.ldk.structs.UpdateFailHTLC _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.UpdateFailHTLC(null, _msg); }
 273                         arg.handle_update_fail_htlc(_their_node_id_conv, _msg_hu_conv);
 274                                 GC.KeepAlive(arg);
 275                 }
 276                 public void handle_update_fail_malformed_htlc(long _their_node_id, long _msg) {
 277                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 278                         org.ldk.structs.UpdateFailMalformedHTLC _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.UpdateFailMalformedHTLC(null, _msg); }
 279                         arg.handle_update_fail_malformed_htlc(_their_node_id_conv, _msg_hu_conv);
 280                                 GC.KeepAlive(arg);
 281                 }
 282                 public void handle_commitment_signed(long _their_node_id, long _msg) {
 283                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 284                         org.ldk.structs.CommitmentSigned _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.CommitmentSigned(null, _msg); }
 285                         arg.handle_commitment_signed(_their_node_id_conv, _msg_hu_conv);
 286                                 GC.KeepAlive(arg);
 287                 }
 288                 public void handle_revoke_and_ack(long _their_node_id, long _msg) {
 289                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 290                         org.ldk.structs.RevokeAndACK _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.RevokeAndACK(null, _msg); }
 291                         arg.handle_revoke_and_ack(_their_node_id_conv, _msg_hu_conv);
 292                                 GC.KeepAlive(arg);
 293                 }
 294                 public void handle_update_fee(long _their_node_id, long _msg) {
 295                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 296                         org.ldk.structs.UpdateFee _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.UpdateFee(null, _msg); }
 297                         arg.handle_update_fee(_their_node_id_conv, _msg_hu_conv);
 298                                 GC.KeepAlive(arg);
 299                 }
 300                 public void handle_announcement_signatures(long _their_node_id, long _msg) {
 301                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 302                         org.ldk.structs.AnnouncementSignatures _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.AnnouncementSignatures(null, _msg); }
 303                         arg.handle_announcement_signatures(_their_node_id_conv, _msg_hu_conv);
 304                                 GC.KeepAlive(arg);
 305                 }
 306                 public void peer_disconnected(long _their_node_id) {
 307                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 308                         arg.peer_disconnected(_their_node_id_conv);
 309                                 GC.KeepAlive(arg);
 310                 }
 311                 public long peer_connected(long _their_node_id, long _msg, bool _inbound) {
 312                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 313                         org.ldk.structs.Init _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.Init(null, _msg); }
 314                         Result_NoneNoneZ ret = arg.peer_connected(_their_node_id_conv, _msg_hu_conv, _inbound);
 315                                 GC.KeepAlive(arg);
 316                         long result = ret == null ? 0 : ret.clone_ptr();
 317                         return result;
 318                 }
 319                 public void handle_channel_reestablish(long _their_node_id, long _msg) {
 320                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 321                         org.ldk.structs.ChannelReestablish _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.ChannelReestablish(null, _msg); }
 322                         arg.handle_channel_reestablish(_their_node_id_conv, _msg_hu_conv);
 323                                 GC.KeepAlive(arg);
 324                 }
 325                 public void handle_channel_update(long _their_node_id, long _msg) {
 326                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 327                         org.ldk.structs.ChannelUpdate _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, _msg); }
 328                         arg.handle_channel_update(_their_node_id_conv, _msg_hu_conv);
 329                                 GC.KeepAlive(arg);
 330                 }
 331                 public void handle_error(long _their_node_id, long _msg) {
 332                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 333                         org.ldk.structs.ErrorMessage _msg_hu_conv = null; if (_msg < 0 || _msg > 4096) { _msg_hu_conv = new org.ldk.structs.ErrorMessage(null, _msg); }
 334                         arg.handle_error(_their_node_id_conv, _msg_hu_conv);
 335                                 GC.KeepAlive(arg);
 336                 }
 337                 public long provided_node_features() {
 338                         NodeFeatures ret = arg.provided_node_features();
 339                                 GC.KeepAlive(arg);
 340                         long result = ret == null ? 0 : ret.clone_ptr();
 341                         return result;
 342                 }
 343                 public long provided_init_features(long _their_node_id) {
 344                         byte[] _their_node_id_conv = InternalUtils.decodeUint8Array(_their_node_id);
 345                         InitFeatures ret = arg.provided_init_features(_their_node_id_conv);
 346                                 GC.KeepAlive(arg);
 347                         long result = ret == null ? 0 : ret.clone_ptr();
 348                         return result;
 349                 }
 350                 public long get_chain_hashes() {
 351                         Option_CVec_ThirtyTwoBytesZZ ret = arg.get_chain_hashes();
 352                                 GC.KeepAlive(arg);
 353                         long result = ret == null ? 0 : ret.clone_ptr();
 354                         if (impl_holder.held != null) { impl_holder.held.ptrs_to.AddLast(ret); };
 355                         return result;
 356                 }
 357         }
 358
 359         /** Creates a new instance of ChannelMessageHandler from a given implementation */
 360         public static ChannelMessageHandler new_impl(ChannelMessageHandlerInterface arg, MessageSendEventsProviderInterface messageSendEventsProvider_impl) {
 361                 LDKChannelMessageHandlerHolder impl_holder = new LDKChannelMessageHandlerHolder();
 362                 LDKChannelMessageHandlerImpl impl = new LDKChannelMessageHandlerImpl(arg, impl_holder);
 363                 MessageSendEventsProvider messageSendEventsProvider = MessageSendEventsProvider.new_impl(messageSendEventsProvider_impl);
 364                 long[] ptr_idx = bindings.LDKChannelMessageHandler_new(impl, messageSendEventsProvider.instance_idx);
 365
 366                 impl_holder.held = new ChannelMessageHandler(null, ptr_idx[0]);
 367                 impl_holder.held.instance_idx = ptr_idx[1];
 368                 impl_holder.held.bindings_instance = impl;
 369                 impl_holder.held.ptrs_to.AddLast(messageSendEventsProvider);
 370                 return impl_holder.held;
 371         }
 372
 373         /**
 374          * Handle an incoming `open_channel` message from the given peer.
 375          */
 376         public void handle_open_channel(byte[] their_node_id, org.ldk.structs.OpenChannel msg) {
 377                 bindings.ChannelMessageHandler_handle_open_channel(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 378                 GC.KeepAlive(this);
 379                 GC.KeepAlive(their_node_id);
 380                 GC.KeepAlive(msg);
 381                 if (this != null) { this.ptrs_to.AddLast(msg); };
 382         }
 383
 384         /**
 385          * Handle an incoming `open_channel2` message from the given peer.
 386          */
 387         public void handle_open_channel_v2(byte[] their_node_id, org.ldk.structs.OpenChannelV2 msg) {
 388                 bindings.ChannelMessageHandler_handle_open_channel_v2(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 389                 GC.KeepAlive(this);
 390                 GC.KeepAlive(their_node_id);
 391                 GC.KeepAlive(msg);
 392                 if (this != null) { this.ptrs_to.AddLast(msg); };
 393         }
 394
 395         /**
 396          * Handle an incoming `accept_channel` message from the given peer.
 397          */
 398         public void handle_accept_channel(byte[] their_node_id, org.ldk.structs.AcceptChannel msg) {
 399                 bindings.ChannelMessageHandler_handle_accept_channel(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 400                 GC.KeepAlive(this);
 401                 GC.KeepAlive(their_node_id);
 402                 GC.KeepAlive(msg);
 403                 if (this != null) { this.ptrs_to.AddLast(msg); };
 404         }
 405
 406         /**
 407          * Handle an incoming `accept_channel2` message from the given peer.
 408          */
 409         public void handle_accept_channel_v2(byte[] their_node_id, org.ldk.structs.AcceptChannelV2 msg) {
 410                 bindings.ChannelMessageHandler_handle_accept_channel_v2(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 411                 GC.KeepAlive(this);
 412                 GC.KeepAlive(their_node_id);
 413                 GC.KeepAlive(msg);
 414                 if (this != null) { this.ptrs_to.AddLast(msg); };
 415         }
 416
 417         /**
 418          * Handle an incoming `funding_created` message from the given peer.
 419          */
 420         public void handle_funding_created(byte[] their_node_id, org.ldk.structs.FundingCreated msg) {
 421                 bindings.ChannelMessageHandler_handle_funding_created(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 422                 GC.KeepAlive(this);
 423                 GC.KeepAlive(their_node_id);
 424                 GC.KeepAlive(msg);
 425                 if (this != null) { this.ptrs_to.AddLast(msg); };
 426         }
 427
 428         /**
 429          * Handle an incoming `funding_signed` message from the given peer.
 430          */
 431         public void handle_funding_signed(byte[] their_node_id, org.ldk.structs.FundingSigned msg) {
 432                 bindings.ChannelMessageHandler_handle_funding_signed(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 433                 GC.KeepAlive(this);
 434                 GC.KeepAlive(their_node_id);
 435                 GC.KeepAlive(msg);
 436                 if (this != null) { this.ptrs_to.AddLast(msg); };
 437         }
 438
 439         /**
 440          * Handle an incoming `channel_ready` message from the given peer.
 441          */
 442         public void handle_channel_ready(byte[] their_node_id, org.ldk.structs.ChannelReady msg) {
 443                 bindings.ChannelMessageHandler_handle_channel_ready(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 444                 GC.KeepAlive(this);
 445                 GC.KeepAlive(their_node_id);
 446                 GC.KeepAlive(msg);
 447                 if (this != null) { this.ptrs_to.AddLast(msg); };
 448         }
 449
 450         /**
 451          * Handle an incoming `shutdown` message from the given peer.
 452          */
 453         public void handle_shutdown(byte[] their_node_id, org.ldk.structs.Shutdown msg) {
 454                 bindings.ChannelMessageHandler_handle_shutdown(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 455                 GC.KeepAlive(this);
 456                 GC.KeepAlive(their_node_id);
 457                 GC.KeepAlive(msg);
 458                 if (this != null) { this.ptrs_to.AddLast(msg); };
 459         }
 460
 461         /**
 462          * Handle an incoming `closing_signed` message from the given peer.
 463          */
 464         public void handle_closing_signed(byte[] their_node_id, org.ldk.structs.ClosingSigned msg) {
 465                 bindings.ChannelMessageHandler_handle_closing_signed(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 466                 GC.KeepAlive(this);
 467                 GC.KeepAlive(their_node_id);
 468                 GC.KeepAlive(msg);
 469                 if (this != null) { this.ptrs_to.AddLast(msg); };
 470         }
 471
 472         /**
 473          * Handle an incoming `tx_add_input message` from the given peer.
 474          */
 475         public void handle_tx_add_input(byte[] their_node_id, org.ldk.structs.TxAddInput msg) {
 476                 bindings.ChannelMessageHandler_handle_tx_add_input(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 477                 GC.KeepAlive(this);
 478                 GC.KeepAlive(their_node_id);
 479                 GC.KeepAlive(msg);
 480                 if (this != null) { this.ptrs_to.AddLast(msg); };
 481         }
 482
 483         /**
 484          * Handle an incoming `tx_add_output` message from the given peer.
 485          */
 486         public void handle_tx_add_output(byte[] their_node_id, org.ldk.structs.TxAddOutput msg) {
 487                 bindings.ChannelMessageHandler_handle_tx_add_output(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 488                 GC.KeepAlive(this);
 489                 GC.KeepAlive(their_node_id);
 490                 GC.KeepAlive(msg);
 491                 if (this != null) { this.ptrs_to.AddLast(msg); };
 492         }
 493
 494         /**
 495          * Handle an incoming `tx_remove_input` message from the given peer.
 496          */
 497         public void handle_tx_remove_input(byte[] their_node_id, org.ldk.structs.TxRemoveInput msg) {
 498                 bindings.ChannelMessageHandler_handle_tx_remove_input(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 499                 GC.KeepAlive(this);
 500                 GC.KeepAlive(their_node_id);
 501                 GC.KeepAlive(msg);
 502                 if (this != null) { this.ptrs_to.AddLast(msg); };
 503         }
 504
 505         /**
 506          * Handle an incoming `tx_remove_output` message from the given peer.
 507          */
 508         public void handle_tx_remove_output(byte[] their_node_id, org.ldk.structs.TxRemoveOutput msg) {
 509                 bindings.ChannelMessageHandler_handle_tx_remove_output(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 510                 GC.KeepAlive(this);
 511                 GC.KeepAlive(their_node_id);
 512                 GC.KeepAlive(msg);
 513                 if (this != null) { this.ptrs_to.AddLast(msg); };
 514         }
 515
 516         /**
 517          * Handle an incoming `tx_complete message` from the given peer.
 518          */
 519         public void handle_tx_complete(byte[] their_node_id, org.ldk.structs.TxComplete msg) {
 520                 bindings.ChannelMessageHandler_handle_tx_complete(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 521                 GC.KeepAlive(this);
 522                 GC.KeepAlive(their_node_id);
 523                 GC.KeepAlive(msg);
 524                 if (this != null) { this.ptrs_to.AddLast(msg); };
 525         }
 526
 527         /**
 528          * Handle an incoming `tx_signatures` message from the given peer.
 529          */
 530         public void handle_tx_signatures(byte[] their_node_id, org.ldk.structs.TxSignatures msg) {
 531                 bindings.ChannelMessageHandler_handle_tx_signatures(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 532                 GC.KeepAlive(this);
 533                 GC.KeepAlive(their_node_id);
 534                 GC.KeepAlive(msg);
 535                 if (this != null) { this.ptrs_to.AddLast(msg); };
 536         }
 537
 538         /**
 539          * Handle an incoming `tx_init_rbf` message from the given peer.
 540          */
 541         public void handle_tx_init_rbf(byte[] their_node_id, org.ldk.structs.TxInitRbf msg) {
 542                 bindings.ChannelMessageHandler_handle_tx_init_rbf(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 543                 GC.KeepAlive(this);
 544                 GC.KeepAlive(their_node_id);
 545                 GC.KeepAlive(msg);
 546                 if (this != null) { this.ptrs_to.AddLast(msg); };
 547         }
 548
 549         /**
 550          * Handle an incoming `tx_ack_rbf` message from the given peer.
 551          */
 552         public void handle_tx_ack_rbf(byte[] their_node_id, org.ldk.structs.TxAckRbf msg) {
 553                 bindings.ChannelMessageHandler_handle_tx_ack_rbf(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 554                 GC.KeepAlive(this);
 555                 GC.KeepAlive(their_node_id);
 556                 GC.KeepAlive(msg);
 557                 if (this != null) { this.ptrs_to.AddLast(msg); };
 558         }
 559
 560         /**
 561          * Handle an incoming `tx_abort message` from the given peer.
 562          */
 563         public void handle_tx_abort(byte[] their_node_id, org.ldk.structs.TxAbort msg) {
 564                 bindings.ChannelMessageHandler_handle_tx_abort(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 565                 GC.KeepAlive(this);
 566                 GC.KeepAlive(their_node_id);
 567                 GC.KeepAlive(msg);
 568                 if (this != null) { this.ptrs_to.AddLast(msg); };
 569         }
 570
 571         /**
 572          * Handle an incoming `update_add_htlc` message from the given peer.
 573          */
 574         public void handle_update_add_htlc(byte[] their_node_id, org.ldk.structs.UpdateAddHTLC msg) {
 575                 bindings.ChannelMessageHandler_handle_update_add_htlc(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 576                 GC.KeepAlive(this);
 577                 GC.KeepAlive(their_node_id);
 578                 GC.KeepAlive(msg);
 579                 if (this != null) { this.ptrs_to.AddLast(msg); };
 580         }
 581
 582         /**
 583          * Handle an incoming `update_fulfill_htlc` message from the given peer.
 584          */
 585         public void handle_update_fulfill_htlc(byte[] their_node_id, org.ldk.structs.UpdateFulfillHTLC msg) {
 586                 bindings.ChannelMessageHandler_handle_update_fulfill_htlc(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 587                 GC.KeepAlive(this);
 588                 GC.KeepAlive(their_node_id);
 589                 GC.KeepAlive(msg);
 590                 if (this != null) { this.ptrs_to.AddLast(msg); };
 591         }
 592
 593         /**
 594          * Handle an incoming `update_fail_htlc` message from the given peer.
 595          */
 596         public void handle_update_fail_htlc(byte[] their_node_id, org.ldk.structs.UpdateFailHTLC msg) {
 597                 bindings.ChannelMessageHandler_handle_update_fail_htlc(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 598                 GC.KeepAlive(this);
 599                 GC.KeepAlive(their_node_id);
 600                 GC.KeepAlive(msg);
 601                 if (this != null) { this.ptrs_to.AddLast(msg); };
 602         }
 603
 604         /**
 605          * Handle an incoming `update_fail_malformed_htlc` message from the given peer.
 606          */
 607         public void handle_update_fail_malformed_htlc(byte[] their_node_id, org.ldk.structs.UpdateFailMalformedHTLC msg) {
 608                 bindings.ChannelMessageHandler_handle_update_fail_malformed_htlc(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 609                 GC.KeepAlive(this);
 610                 GC.KeepAlive(their_node_id);
 611                 GC.KeepAlive(msg);
 612                 if (this != null) { this.ptrs_to.AddLast(msg); };
 613         }
 614
 615         /**
 616          * Handle an incoming `commitment_signed` message from the given peer.
 617          */
 618         public void handle_commitment_signed(byte[] their_node_id, org.ldk.structs.CommitmentSigned msg) {
 619                 bindings.ChannelMessageHandler_handle_commitment_signed(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 620                 GC.KeepAlive(this);
 621                 GC.KeepAlive(their_node_id);
 622                 GC.KeepAlive(msg);
 623                 if (this != null) { this.ptrs_to.AddLast(msg); };
 624         }
 625
 626         /**
 627          * Handle an incoming `revoke_and_ack` message from the given peer.
 628          */
 629         public void handle_revoke_and_ack(byte[] their_node_id, org.ldk.structs.RevokeAndACK msg) {
 630                 bindings.ChannelMessageHandler_handle_revoke_and_ack(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 631                 GC.KeepAlive(this);
 632                 GC.KeepAlive(their_node_id);
 633                 GC.KeepAlive(msg);
 634                 if (this != null) { this.ptrs_to.AddLast(msg); };
 635         }
 636
 637         /**
 638          * Handle an incoming `update_fee` message from the given peer.
 639          */
 640         public void handle_update_fee(byte[] their_node_id, org.ldk.structs.UpdateFee msg) {
 641                 bindings.ChannelMessageHandler_handle_update_fee(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 642                 GC.KeepAlive(this);
 643                 GC.KeepAlive(their_node_id);
 644                 GC.KeepAlive(msg);
 645                 if (this != null) { this.ptrs_to.AddLast(msg); };
 646         }
 647
 648         /**
 649          * Handle an incoming `announcement_signatures` message from the given peer.
 650          */
 651         public void handle_announcement_signatures(byte[] their_node_id, org.ldk.structs.AnnouncementSignatures msg) {
 652                 bindings.ChannelMessageHandler_handle_announcement_signatures(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 653                 GC.KeepAlive(this);
 654                 GC.KeepAlive(their_node_id);
 655                 GC.KeepAlive(msg);
 656                 if (this != null) { this.ptrs_to.AddLast(msg); };
 657         }
 658
 659         /**
 660          * Indicates a connection to the peer failed/an existing connection was lost.
 661          */
 662         public void peer_disconnected(byte[] their_node_id) {
 663                 bindings.ChannelMessageHandler_peer_disconnected(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)));
 664                 GC.KeepAlive(this);
 665                 GC.KeepAlive(their_node_id);
 666         }
 667
 668         /**
 669          * Handle a peer reconnecting, possibly generating `channel_reestablish` message(s).
 670          *
 671          * May return an `Err(())` if the features the peer supports are not sufficient to communicate
 672          * with us. Implementors should be somewhat conservative about doing so, however, as other
 673          * message handlers may still wish to communicate with this peer.
 674          */
 675         public Result_NoneNoneZ peer_connected(byte[] their_node_id, org.ldk.structs.Init msg, bool inbound) {
 676                 long ret = bindings.ChannelMessageHandler_peer_connected(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr, inbound);
 677                 GC.KeepAlive(this);
 678                 GC.KeepAlive(their_node_id);
 679                 GC.KeepAlive(msg);
 680                 GC.KeepAlive(inbound);
 681                 if (ret >= 0 && ret <= 4096) { return null; }
 682                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 683                 if (this != null) { this.ptrs_to.AddLast(msg); };
 684                 return ret_hu_conv;
 685         }
 686
 687         /**
 688          * Handle an incoming `channel_reestablish` message from the given peer.
 689          */
 690         public void handle_channel_reestablish(byte[] their_node_id, org.ldk.structs.ChannelReestablish msg) {
 691                 bindings.ChannelMessageHandler_handle_channel_reestablish(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 692                 GC.KeepAlive(this);
 693                 GC.KeepAlive(their_node_id);
 694                 GC.KeepAlive(msg);
 695                 if (this != null) { this.ptrs_to.AddLast(msg); };
 696         }
 697
 698         /**
 699          * Handle an incoming `channel_update` message from the given peer.
 700          */
 701         public void handle_channel_update(byte[] their_node_id, org.ldk.structs.ChannelUpdate msg) {
 702                 bindings.ChannelMessageHandler_handle_channel_update(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 703                 GC.KeepAlive(this);
 704                 GC.KeepAlive(their_node_id);
 705                 GC.KeepAlive(msg);
 706                 if (this != null) { this.ptrs_to.AddLast(msg); };
 707         }
 708
 709         /**
 710          * Handle an incoming `error` message from the given peer.
 711          */
 712         public void handle_error(byte[] their_node_id, org.ldk.structs.ErrorMessage msg) {
 713                 bindings.ChannelMessageHandler_handle_error(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)), msg == null ? 0 : msg.ptr);
 714                 GC.KeepAlive(this);
 715                 GC.KeepAlive(their_node_id);
 716                 GC.KeepAlive(msg);
 717                 if (this != null) { this.ptrs_to.AddLast(msg); };
 718         }
 719
 720         /**
 721          * Gets the node feature flags which this handler itself supports. All available handlers are
 722          * queried similarly and their feature flags are OR'd together to form the [`NodeFeatures`]
 723          * which are broadcasted in our [`NodeAnnouncement`] message.
 724          */
 725         public NodeFeatures provided_node_features() {
 726                 long ret = bindings.ChannelMessageHandler_provided_node_features(this.ptr);
 727                 GC.KeepAlive(this);
 728                 if (ret >= 0 && ret <= 4096) { return null; }
 729                 org.ldk.structs.NodeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.NodeFeatures(null, ret); }
 730                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
 731                 return ret_hu_conv;
 732         }
 733
 734         /**
 735          * Gets the init feature flags which should be sent to the given peer. All available handlers
 736          * are queried similarly and their feature flags are OR'd together to form the [`InitFeatures`]
 737          * which are sent in our [`Init`] message.
 738          *
 739          * Note that this method is called before [`Self::peer_connected`].
 740          */
 741         public InitFeatures provided_init_features(byte[] their_node_id) {
 742                 long ret = bindings.ChannelMessageHandler_provided_init_features(this.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(their_node_id, 33)));
 743                 GC.KeepAlive(this);
 744                 GC.KeepAlive(their_node_id);
 745                 if (ret >= 0 && ret <= 4096) { return null; }
 746                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
 747                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
 748                 return ret_hu_conv;
 749         }
 750
 751         /**
 752          * Gets the chain hashes for this `ChannelMessageHandler` indicating which chains it supports.
 753          *
 754          * If it's `None`, then no particular network chain hash compatibility will be enforced when
 755          * connecting to peers.
 756          */
 757         public Option_CVec_ThirtyTwoBytesZZ get_chain_hashes() {
 758                 long ret = bindings.ChannelMessageHandler_get_chain_hashes(this.ptr);
 759                 GC.KeepAlive(this);
 760                 if (ret >= 0 && ret <= 4096) { return null; }
 761                 org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ ret_hu_conv = org.ldk.structs.Option_CVec_ThirtyTwoBytesZZ.constr_from_ptr(ret);
 762                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
 763                 return ret_hu_conv;
 764         }
 765
 766 }
 767 } } }