_ Git - ldk-java/blob - src/main/java/org/ldk/structs/MessageSendEvent.java

   1 package org.ldk.structs;
   2
   3 import org.ldk.impl.bindings;
   4 import org.ldk.enums.*;
   5 import org.ldk.util.*;
   6 import java.util.Arrays;
   7 import java.lang.ref.Reference;
   8 import javax.annotation.Nullable;
   9
  10
  11 /**
  12  * An event generated by ChannelManager which indicates a message should be sent to a peer (or
  13  * broadcast to most peers).
  14  * These events are handled by PeerManager::process_events if you are using a PeerManager.
  15  */
  16 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  17 public class MessageSendEvent extends CommonBase {
  18         private MessageSendEvent(Object _dummy, long ptr) { super(ptr); }
  19         @Override @SuppressWarnings("deprecation")
  20         protected void finalize() throws Throwable {
  21                 super.finalize();
  22                 if (ptr != 0) { bindings.MessageSendEvent_free(ptr); }
  23         }
  24         static MessageSendEvent constr_from_ptr(long ptr) {
  25                 bindings.LDKMessageSendEvent raw_val = bindings.LDKMessageSendEvent_ref_from_ptr(ptr);
  26                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendAcceptChannel.class) {
  27                         return new SendAcceptChannel(ptr, (bindings.LDKMessageSendEvent.SendAcceptChannel)raw_val);
  28                 }
  29                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendOpenChannel.class) {
  30                         return new SendOpenChannel(ptr, (bindings.LDKMessageSendEvent.SendOpenChannel)raw_val);
  31                 }
  32                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendFundingCreated.class) {
  33                         return new SendFundingCreated(ptr, (bindings.LDKMessageSendEvent.SendFundingCreated)raw_val);
  34                 }
  35                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendFundingSigned.class) {
  36                         return new SendFundingSigned(ptr, (bindings.LDKMessageSendEvent.SendFundingSigned)raw_val);
  37                 }
  38                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelReady.class) {
  39                         return new SendChannelReady(ptr, (bindings.LDKMessageSendEvent.SendChannelReady)raw_val);
  40                 }
  41                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendAnnouncementSignatures.class) {
  42                         return new SendAnnouncementSignatures(ptr, (bindings.LDKMessageSendEvent.SendAnnouncementSignatures)raw_val);
  43                 }
  44                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.UpdateHTLCs.class) {
  45                         return new UpdateHTLCs(ptr, (bindings.LDKMessageSendEvent.UpdateHTLCs)raw_val);
  46                 }
  47                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendRevokeAndACK.class) {
  48                         return new SendRevokeAndACK(ptr, (bindings.LDKMessageSendEvent.SendRevokeAndACK)raw_val);
  49                 }
  50                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendClosingSigned.class) {
  51                         return new SendClosingSigned(ptr, (bindings.LDKMessageSendEvent.SendClosingSigned)raw_val);
  52                 }
  53                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendShutdown.class) {
  54                         return new SendShutdown(ptr, (bindings.LDKMessageSendEvent.SendShutdown)raw_val);
  55                 }
  56                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelReestablish.class) {
  57                         return new SendChannelReestablish(ptr, (bindings.LDKMessageSendEvent.SendChannelReestablish)raw_val);
  58                 }
  59                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelAnnouncement.class) {
  60                         return new SendChannelAnnouncement(ptr, (bindings.LDKMessageSendEvent.SendChannelAnnouncement)raw_val);
  61                 }
  62                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement.class) {
  63                         return new BroadcastChannelAnnouncement(ptr, (bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement)raw_val);
  64                 }
  65                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastChannelUpdate.class) {
  66                         return new BroadcastChannelUpdate(ptr, (bindings.LDKMessageSendEvent.BroadcastChannelUpdate)raw_val);
  67                 }
  68                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement.class) {
  69                         return new BroadcastNodeAnnouncement(ptr, (bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement)raw_val);
  70                 }
  71                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelUpdate.class) {
  72                         return new SendChannelUpdate(ptr, (bindings.LDKMessageSendEvent.SendChannelUpdate)raw_val);
  73                 }
  74                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.HandleError.class) {
  75                         return new HandleError(ptr, (bindings.LDKMessageSendEvent.HandleError)raw_val);
  76                 }
  77                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendChannelRangeQuery.class) {
  78                         return new SendChannelRangeQuery(ptr, (bindings.LDKMessageSendEvent.SendChannelRangeQuery)raw_val);
  79                 }
  80                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendShortIdsQuery.class) {
  81                         return new SendShortIdsQuery(ptr, (bindings.LDKMessageSendEvent.SendShortIdsQuery)raw_val);
  82                 }
  83                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendReplyChannelRange.class) {
  84                         return new SendReplyChannelRange(ptr, (bindings.LDKMessageSendEvent.SendReplyChannelRange)raw_val);
  85                 }
  86                 if (raw_val.getClass() == bindings.LDKMessageSendEvent.SendGossipTimestampFilter.class) {
  87                         return new SendGossipTimestampFilter(ptr, (bindings.LDKMessageSendEvent.SendGossipTimestampFilter)raw_val);
  88                 }
  89                 assert false; return null; // Unreachable without extending the (internal) bindings interface
  90         }
  91
  92         /**
  93          * Used to indicate that we've accepted a channel open and should send the accept_channel
  94          * message provided to the given peer.
  95          */
  96         public final static class SendAcceptChannel extends MessageSendEvent {
  97                 /**
  98                  * The node_id of the node which should receive this message
  99                 */
 100                 public final byte[] node_id;
 101                 /**
 102                  * The message which should be sent.
 103                 */
 104                 public final org.ldk.structs.AcceptChannel msg;
 105                 private SendAcceptChannel(long ptr, bindings.LDKMessageSendEvent.SendAcceptChannel obj) {
 106                         super(null, ptr);
 107                         this.node_id = obj.node_id;
 108                         long msg = obj.msg;
 109                         org.ldk.structs.AcceptChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AcceptChannel(null, msg); }
 110                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 111                         this.msg = msg_hu_conv;
 112                 }
 113         }
 114         /**
 115          * Used to indicate that we've initiated a channel open and should send the open_channel
 116          * message provided to the given peer.
 117          */
 118         public final static class SendOpenChannel extends MessageSendEvent {
 119                 /**
 120                  * The node_id of the node which should receive this message
 121                 */
 122                 public final byte[] node_id;
 123                 /**
 124                  * The message which should be sent.
 125                 */
 126                 public final org.ldk.structs.OpenChannel msg;
 127                 private SendOpenChannel(long ptr, bindings.LDKMessageSendEvent.SendOpenChannel obj) {
 128                         super(null, ptr);
 129                         this.node_id = obj.node_id;
 130                         long msg = obj.msg;
 131                         org.ldk.structs.OpenChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.OpenChannel(null, msg); }
 132                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 133                         this.msg = msg_hu_conv;
 134                 }
 135         }
 136         /**
 137          * Used to indicate that a funding_created message should be sent to the peer with the given node_id.
 138          */
 139         public final static class SendFundingCreated extends MessageSendEvent {
 140                 /**
 141                  * The node_id of the node which should receive this message
 142                 */
 143                 public final byte[] node_id;
 144                 /**
 145                  * The message which should be sent.
 146                 */
 147                 public final org.ldk.structs.FundingCreated msg;
 148                 private SendFundingCreated(long ptr, bindings.LDKMessageSendEvent.SendFundingCreated obj) {
 149                         super(null, ptr);
 150                         this.node_id = obj.node_id;
 151                         long msg = obj.msg;
 152                         org.ldk.structs.FundingCreated msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.FundingCreated(null, msg); }
 153                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 154                         this.msg = msg_hu_conv;
 155                 }
 156         }
 157         /**
 158          * Used to indicate that a funding_signed message should be sent to the peer with the given node_id.
 159          */
 160         public final static class SendFundingSigned extends MessageSendEvent {
 161                 /**
 162                  * The node_id of the node which should receive this message
 163                 */
 164                 public final byte[] node_id;
 165                 /**
 166                  * The message which should be sent.
 167                 */
 168                 public final org.ldk.structs.FundingSigned msg;
 169                 private SendFundingSigned(long ptr, bindings.LDKMessageSendEvent.SendFundingSigned obj) {
 170                         super(null, ptr);
 171                         this.node_id = obj.node_id;
 172                         long msg = obj.msg;
 173                         org.ldk.structs.FundingSigned msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.FundingSigned(null, msg); }
 174                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 175                         this.msg = msg_hu_conv;
 176                 }
 177         }
 178         /**
 179          * Used to indicate that a channel_ready message should be sent to the peer with the given node_id.
 180          */
 181         public final static class SendChannelReady extends MessageSendEvent {
 182                 /**
 183                  * The node_id of the node which should receive these message(s)
 184                 */
 185                 public final byte[] node_id;
 186                 /**
 187                  * The channel_ready message which should be sent.
 188                 */
 189                 public final org.ldk.structs.ChannelReady msg;
 190                 private SendChannelReady(long ptr, bindings.LDKMessageSendEvent.SendChannelReady obj) {
 191                         super(null, ptr);
 192                         this.node_id = obj.node_id;
 193                         long msg = obj.msg;
 194                         org.ldk.structs.ChannelReady msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelReady(null, msg); }
 195                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 196                         this.msg = msg_hu_conv;
 197                 }
 198         }
 199         /**
 200          * Used to indicate that an announcement_signatures message should be sent to the peer with the given node_id.
 201          */
 202         public final static class SendAnnouncementSignatures extends MessageSendEvent {
 203                 /**
 204                  * The node_id of the node which should receive these message(s)
 205                 */
 206                 public final byte[] node_id;
 207                 /**
 208                  * The announcement_signatures message which should be sent.
 209                 */
 210                 public final org.ldk.structs.AnnouncementSignatures msg;
 211                 private SendAnnouncementSignatures(long ptr, bindings.LDKMessageSendEvent.SendAnnouncementSignatures obj) {
 212                         super(null, ptr);
 213                         this.node_id = obj.node_id;
 214                         long msg = obj.msg;
 215                         org.ldk.structs.AnnouncementSignatures msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AnnouncementSignatures(null, msg); }
 216                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 217                         this.msg = msg_hu_conv;
 218                 }
 219         }
 220         /**
 221          * Used to indicate that a series of HTLC update messages, as well as a commitment_signed
 222          * message should be sent to the peer with the given node_id.
 223          */
 224         public final static class UpdateHTLCs extends MessageSendEvent {
 225                 /**
 226                  * The node_id of the node which should receive these message(s)
 227                 */
 228                 public final byte[] node_id;
 229                 /**
 230                  * The update messages which should be sent. ALL messages in the struct should be sent!
 231                 */
 232                 public final org.ldk.structs.CommitmentUpdate updates;
 233                 private UpdateHTLCs(long ptr, bindings.LDKMessageSendEvent.UpdateHTLCs obj) {
 234                         super(null, ptr);
 235                         this.node_id = obj.node_id;
 236                         long updates = obj.updates;
 237                         org.ldk.structs.CommitmentUpdate updates_hu_conv = null; if (updates < 0 || updates > 4096) { updates_hu_conv = new org.ldk.structs.CommitmentUpdate(null, updates); }
 238                         if (updates_hu_conv != null) { updates_hu_conv.ptrs_to.add(this); };
 239                         this.updates = updates_hu_conv;
 240                 }
 241         }
 242         /**
 243          * Used to indicate that a revoke_and_ack message should be sent to the peer with the given node_id.
 244          */
 245         public final static class SendRevokeAndACK extends MessageSendEvent {
 246                 /**
 247                  * The node_id of the node which should receive this message
 248                 */
 249                 public final byte[] node_id;
 250                 /**
 251                  * The message which should be sent.
 252                 */
 253                 public final org.ldk.structs.RevokeAndACK msg;
 254                 private SendRevokeAndACK(long ptr, bindings.LDKMessageSendEvent.SendRevokeAndACK obj) {
 255                         super(null, ptr);
 256                         this.node_id = obj.node_id;
 257                         long msg = obj.msg;
 258                         org.ldk.structs.RevokeAndACK msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.RevokeAndACK(null, msg); }
 259                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 260                         this.msg = msg_hu_conv;
 261                 }
 262         }
 263         /**
 264          * Used to indicate that a closing_signed message should be sent to the peer with the given node_id.
 265          */
 266         public final static class SendClosingSigned extends MessageSendEvent {
 267                 /**
 268                  * The node_id of the node which should receive this message
 269                 */
 270                 public final byte[] node_id;
 271                 /**
 272                  * The message which should be sent.
 273                 */
 274                 public final org.ldk.structs.ClosingSigned msg;
 275                 private SendClosingSigned(long ptr, bindings.LDKMessageSendEvent.SendClosingSigned obj) {
 276                         super(null, ptr);
 277                         this.node_id = obj.node_id;
 278                         long msg = obj.msg;
 279                         org.ldk.structs.ClosingSigned msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ClosingSigned(null, msg); }
 280                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 281                         this.msg = msg_hu_conv;
 282                 }
 283         }
 284         /**
 285          * Used to indicate that a shutdown message should be sent to the peer with the given node_id.
 286          */
 287         public final static class SendShutdown extends MessageSendEvent {
 288                 /**
 289                  * The node_id of the node which should receive this message
 290                 */
 291                 public final byte[] node_id;
 292                 /**
 293                  * The message which should be sent.
 294                 */
 295                 public final org.ldk.structs.Shutdown msg;
 296                 private SendShutdown(long ptr, bindings.LDKMessageSendEvent.SendShutdown obj) {
 297                         super(null, ptr);
 298                         this.node_id = obj.node_id;
 299                         long msg = obj.msg;
 300                         org.ldk.structs.Shutdown msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.Shutdown(null, msg); }
 301                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 302                         this.msg = msg_hu_conv;
 303                 }
 304         }
 305         /**
 306          * Used to indicate that a channel_reestablish message should be sent to the peer with the given node_id.
 307          */
 308         public final static class SendChannelReestablish extends MessageSendEvent {
 309                 /**
 310                  * The node_id of the node which should receive this message
 311                 */
 312                 public final byte[] node_id;
 313                 /**
 314                  * The message which should be sent.
 315                 */
 316                 public final org.ldk.structs.ChannelReestablish msg;
 317                 private SendChannelReestablish(long ptr, bindings.LDKMessageSendEvent.SendChannelReestablish obj) {
 318                         super(null, ptr);
 319                         this.node_id = obj.node_id;
 320                         long msg = obj.msg;
 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                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 323                         this.msg = msg_hu_conv;
 324                 }
 325         }
 326         /**
 327          * Used to send a channel_announcement and channel_update to a specific peer, likely on
 328          * initial connection to ensure our peers know about our channels.
 329          */
 330         public final static class SendChannelAnnouncement extends MessageSendEvent {
 331                 /**
 332                  * The node_id of the node which should receive this message
 333                 */
 334                 public final byte[] node_id;
 335                 /**
 336                  * The channel_announcement which should be sent.
 337                 */
 338                 public final org.ldk.structs.ChannelAnnouncement msg;
 339                 /**
 340                  * The followup channel_update which should be sent.
 341                 */
 342                 public final org.ldk.structs.ChannelUpdate update_msg;
 343                 private SendChannelAnnouncement(long ptr, bindings.LDKMessageSendEvent.SendChannelAnnouncement obj) {
 344                         super(null, ptr);
 345                         this.node_id = obj.node_id;
 346                         long msg = obj.msg;
 347                         org.ldk.structs.ChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelAnnouncement(null, msg); }
 348                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 349                         this.msg = msg_hu_conv;
 350                         long update_msg = obj.update_msg;
 351                         org.ldk.structs.ChannelUpdate update_msg_hu_conv = null; if (update_msg < 0 || update_msg > 4096) { update_msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, update_msg); }
 352                         if (update_msg_hu_conv != null) { update_msg_hu_conv.ptrs_to.add(this); };
 353                         this.update_msg = update_msg_hu_conv;
 354                 }
 355         }
 356         /**
 357          * Used to indicate that a channel_announcement and channel_update should be broadcast to all
 358          * peers (except the peer with node_id either msg.contents.node_id_1 or msg.contents.node_id_2).
 359          *
 360          * Note that after doing so, you very likely (unless you did so very recently) want to
 361          * broadcast a node_announcement (e.g. via [`PeerManager::broadcast_node_announcement`]). This
 362          * ensures that any nodes which see our channel_announcement also have a relevant
 363          * node_announcement, including relevant feature flags which may be important for routing
 364          * through or to us.
 365          *
 366          * [`PeerManager::broadcast_node_announcement`]: crate::ln::peer_handler::PeerManager::broadcast_node_announcement
 367          */
 368         public final static class BroadcastChannelAnnouncement extends MessageSendEvent {
 369                 /**
 370                  * The channel_announcement which should be sent.
 371                 */
 372                 public final org.ldk.structs.ChannelAnnouncement msg;
 373                 /**
 374                  * The followup channel_update which should be sent.
 375                  *
 376                  * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
 377                 */
 378                 @Nullable public final org.ldk.structs.ChannelUpdate update_msg;
 379                 private BroadcastChannelAnnouncement(long ptr, bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement obj) {
 380                         super(null, ptr);
 381                         long msg = obj.msg;
 382                         org.ldk.structs.ChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelAnnouncement(null, msg); }
 383                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 384                         this.msg = msg_hu_conv;
 385                         long update_msg = obj.update_msg;
 386                         org.ldk.structs.ChannelUpdate update_msg_hu_conv = null; if (update_msg < 0 || update_msg > 4096) { update_msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, update_msg); }
 387                         if (update_msg_hu_conv != null) { update_msg_hu_conv.ptrs_to.add(this); };
 388                         this.update_msg = update_msg_hu_conv;
 389                 }
 390         }
 391         /**
 392          * Used to indicate that a channel_update should be broadcast to all peers.
 393          */
 394         public final static class BroadcastChannelUpdate extends MessageSendEvent {
 395                 /**
 396                  * The channel_update which should be sent.
 397                 */
 398                 public final org.ldk.structs.ChannelUpdate msg;
 399                 private BroadcastChannelUpdate(long ptr, bindings.LDKMessageSendEvent.BroadcastChannelUpdate obj) {
 400                         super(null, ptr);
 401                         long msg = obj.msg;
 402                         org.ldk.structs.ChannelUpdate msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, msg); }
 403                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 404                         this.msg = msg_hu_conv;
 405                 }
 406         }
 407         /**
 408          * Used to indicate that a node_announcement should be broadcast to all peers.
 409          */
 410         public final static class BroadcastNodeAnnouncement extends MessageSendEvent {
 411                 /**
 412                  * The node_announcement which should be sent.
 413                 */
 414                 public final org.ldk.structs.NodeAnnouncement msg;
 415                 private BroadcastNodeAnnouncement(long ptr, bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement obj) {
 416                         super(null, ptr);
 417                         long msg = obj.msg;
 418                         org.ldk.structs.NodeAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.NodeAnnouncement(null, msg); }
 419                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 420                         this.msg = msg_hu_conv;
 421                 }
 422         }
 423         /**
 424          * Used to indicate that a channel_update should be sent to a single peer.
 425          * In contrast to [`Self::BroadcastChannelUpdate`], this is used when the channel is a
 426          * private channel and we shouldn't be informing all of our peers of channel parameters.
 427          */
 428         public final static class SendChannelUpdate extends MessageSendEvent {
 429                 /**
 430                  * The node_id of the node which should receive this message
 431                 */
 432                 public final byte[] node_id;
 433                 /**
 434                  * The channel_update which should be sent.
 435                 */
 436                 public final org.ldk.structs.ChannelUpdate msg;
 437                 private SendChannelUpdate(long ptr, bindings.LDKMessageSendEvent.SendChannelUpdate obj) {
 438                         super(null, ptr);
 439                         this.node_id = obj.node_id;
 440                         long msg = obj.msg;
 441                         org.ldk.structs.ChannelUpdate msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, msg); }
 442                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 443                         this.msg = msg_hu_conv;
 444                 }
 445         }
 446         /**
 447          * Broadcast an error downstream to be handled
 448          */
 449         public final static class HandleError extends MessageSendEvent {
 450                 /**
 451                  * The node_id of the node which should receive this message
 452                 */
 453                 public final byte[] node_id;
 454                 /**
 455                  * The action which should be taken.
 456                 */
 457                 public final org.ldk.structs.ErrorAction action;
 458                 private HandleError(long ptr, bindings.LDKMessageSendEvent.HandleError obj) {
 459                         super(null, ptr);
 460                         this.node_id = obj.node_id;
 461                         long action = obj.action;
 462                         org.ldk.structs.ErrorAction action_hu_conv = org.ldk.structs.ErrorAction.constr_from_ptr(action);
 463                         if (action_hu_conv != null) { action_hu_conv.ptrs_to.add(this); };
 464                         this.action = action_hu_conv;
 465                 }
 466         }
 467         /**
 468          * Query a peer for channels with funding transaction UTXOs in a block range.
 469          */
 470         public final static class SendChannelRangeQuery extends MessageSendEvent {
 471                 /**
 472                  * The node_id of this message recipient
 473                 */
 474                 public final byte[] node_id;
 475                 /**
 476                  * The query_channel_range which should be sent.
 477                 */
 478                 public final org.ldk.structs.QueryChannelRange msg;
 479                 private SendChannelRangeQuery(long ptr, bindings.LDKMessageSendEvent.SendChannelRangeQuery obj) {
 480                         super(null, ptr);
 481                         this.node_id = obj.node_id;
 482                         long msg = obj.msg;
 483                         org.ldk.structs.QueryChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.QueryChannelRange(null, msg); }
 484                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 485                         this.msg = msg_hu_conv;
 486                 }
 487         }
 488         /**
 489          * Request routing gossip messages from a peer for a list of channels identified by
 490          * their short_channel_ids.
 491          */
 492         public final static class SendShortIdsQuery extends MessageSendEvent {
 493                 /**
 494                  * The node_id of this message recipient
 495                 */
 496                 public final byte[] node_id;
 497                 /**
 498                  * The query_short_channel_ids which should be sent.
 499                 */
 500                 public final org.ldk.structs.QueryShortChannelIds msg;
 501                 private SendShortIdsQuery(long ptr, bindings.LDKMessageSendEvent.SendShortIdsQuery obj) {
 502                         super(null, ptr);
 503                         this.node_id = obj.node_id;
 504                         long msg = obj.msg;
 505                         org.ldk.structs.QueryShortChannelIds msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.QueryShortChannelIds(null, msg); }
 506                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 507                         this.msg = msg_hu_conv;
 508                 }
 509         }
 510         /**
 511          * Sends a reply to a channel range query. This may be one of several SendReplyChannelRange events
 512          * emitted during processing of the query.
 513          */
 514         public final static class SendReplyChannelRange extends MessageSendEvent {
 515                 /**
 516                  * The node_id of this message recipient
 517                 */
 518                 public final byte[] node_id;
 519                 /**
 520                  * The reply_channel_range which should be sent.
 521                 */
 522                 public final org.ldk.structs.ReplyChannelRange msg;
 523                 private SendReplyChannelRange(long ptr, bindings.LDKMessageSendEvent.SendReplyChannelRange obj) {
 524                         super(null, ptr);
 525                         this.node_id = obj.node_id;
 526                         long msg = obj.msg;
 527                         org.ldk.structs.ReplyChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ReplyChannelRange(null, msg); }
 528                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 529                         this.msg = msg_hu_conv;
 530                 }
 531         }
 532         /**
 533          * Sends a timestamp filter for inbound gossip. This should be sent on each new connection to
 534          * enable receiving gossip messages from the peer.
 535          */
 536         public final static class SendGossipTimestampFilter extends MessageSendEvent {
 537                 /**
 538                  * The node_id of this message recipient
 539                 */
 540                 public final byte[] node_id;
 541                 /**
 542                  * The gossip_timestamp_filter which should be sent.
 543                 */
 544                 public final org.ldk.structs.GossipTimestampFilter msg;
 545                 private SendGossipTimestampFilter(long ptr, bindings.LDKMessageSendEvent.SendGossipTimestampFilter obj) {
 546                         super(null, ptr);
 547                         this.node_id = obj.node_id;
 548                         long msg = obj.msg;
 549                         org.ldk.structs.GossipTimestampFilter msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.GossipTimestampFilter(null, msg); }
 550                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.add(this); };
 551                         this.msg = msg_hu_conv;
 552                 }
 553         }
 554         long clone_ptr() {
 555                 long ret = bindings.MessageSendEvent_clone_ptr(this.ptr);
 556                 Reference.reachabilityFence(this);
 557                 return ret;
 558         }
 559
 560         /**
 561          * Creates a copy of the MessageSendEvent
 562          */
 563         public MessageSendEvent clone() {
 564                 long ret = bindings.MessageSendEvent_clone(this.ptr);
 565                 Reference.reachabilityFence(this);
 566                 if (ret >= 0 && ret <= 4096) { return null; }
 567                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 568                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 569                 return ret_hu_conv;
 570         }
 571
 572         /**
 573          * Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent
 574          */
 575         public static MessageSendEvent send_accept_channel(byte[] node_id, org.ldk.structs.AcceptChannel msg) {
 576                 long ret = bindings.MessageSendEvent_send_accept_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 577                 Reference.reachabilityFence(node_id);
 578                 Reference.reachabilityFence(msg);
 579                 if (ret >= 0 && ret <= 4096) { return null; }
 580                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 581                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 582                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 583                 return ret_hu_conv;
 584         }
 585
 586         /**
 587          * Utility method to constructs a new SendOpenChannel-variant MessageSendEvent
 588          */
 589         public static MessageSendEvent send_open_channel(byte[] node_id, org.ldk.structs.OpenChannel msg) {
 590                 long ret = bindings.MessageSendEvent_send_open_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 591                 Reference.reachabilityFence(node_id);
 592                 Reference.reachabilityFence(msg);
 593                 if (ret >= 0 && ret <= 4096) { return null; }
 594                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 595                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 596                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 597                 return ret_hu_conv;
 598         }
 599
 600         /**
 601          * Utility method to constructs a new SendFundingCreated-variant MessageSendEvent
 602          */
 603         public static MessageSendEvent send_funding_created(byte[] node_id, org.ldk.structs.FundingCreated msg) {
 604                 long ret = bindings.MessageSendEvent_send_funding_created(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 605                 Reference.reachabilityFence(node_id);
 606                 Reference.reachabilityFence(msg);
 607                 if (ret >= 0 && ret <= 4096) { return null; }
 608                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 609                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 610                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 611                 return ret_hu_conv;
 612         }
 613
 614         /**
 615          * Utility method to constructs a new SendFundingSigned-variant MessageSendEvent
 616          */
 617         public static MessageSendEvent send_funding_signed(byte[] node_id, org.ldk.structs.FundingSigned msg) {
 618                 long ret = bindings.MessageSendEvent_send_funding_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 619                 Reference.reachabilityFence(node_id);
 620                 Reference.reachabilityFence(msg);
 621                 if (ret >= 0 && ret <= 4096) { return null; }
 622                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 623                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 624                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 625                 return ret_hu_conv;
 626         }
 627
 628         /**
 629          * Utility method to constructs a new SendChannelReady-variant MessageSendEvent
 630          */
 631         public static MessageSendEvent send_channel_ready(byte[] node_id, org.ldk.structs.ChannelReady msg) {
 632                 long ret = bindings.MessageSendEvent_send_channel_ready(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 633                 Reference.reachabilityFence(node_id);
 634                 Reference.reachabilityFence(msg);
 635                 if (ret >= 0 && ret <= 4096) { return null; }
 636                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 637                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 638                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 639                 return ret_hu_conv;
 640         }
 641
 642         /**
 643          * Utility method to constructs a new SendAnnouncementSignatures-variant MessageSendEvent
 644          */
 645         public static MessageSendEvent send_announcement_signatures(byte[] node_id, org.ldk.structs.AnnouncementSignatures msg) {
 646                 long ret = bindings.MessageSendEvent_send_announcement_signatures(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 647                 Reference.reachabilityFence(node_id);
 648                 Reference.reachabilityFence(msg);
 649                 if (ret >= 0 && ret <= 4096) { return null; }
 650                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 651                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 652                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 653                 return ret_hu_conv;
 654         }
 655
 656         /**
 657          * Utility method to constructs a new UpdateHTLCs-variant MessageSendEvent
 658          */
 659         public static MessageSendEvent update_htlcs(byte[] node_id, org.ldk.structs.CommitmentUpdate updates) {
 660                 long ret = bindings.MessageSendEvent_update_htlcs(InternalUtils.check_arr_len(node_id, 33), updates == null ? 0 : updates.ptr);
 661                 Reference.reachabilityFence(node_id);
 662                 Reference.reachabilityFence(updates);
 663                 if (ret >= 0 && ret <= 4096) { return null; }
 664                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 665                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 666                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(updates); };
 667                 return ret_hu_conv;
 668         }
 669
 670         /**
 671          * Utility method to constructs a new SendRevokeAndACK-variant MessageSendEvent
 672          */
 673         public static MessageSendEvent send_revoke_and_ack(byte[] node_id, org.ldk.structs.RevokeAndACK msg) {
 674                 long ret = bindings.MessageSendEvent_send_revoke_and_ack(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 675                 Reference.reachabilityFence(node_id);
 676                 Reference.reachabilityFence(msg);
 677                 if (ret >= 0 && ret <= 4096) { return null; }
 678                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 679                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 680                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 681                 return ret_hu_conv;
 682         }
 683
 684         /**
 685          * Utility method to constructs a new SendClosingSigned-variant MessageSendEvent
 686          */
 687         public static MessageSendEvent send_closing_signed(byte[] node_id, org.ldk.structs.ClosingSigned msg) {
 688                 long ret = bindings.MessageSendEvent_send_closing_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 689                 Reference.reachabilityFence(node_id);
 690                 Reference.reachabilityFence(msg);
 691                 if (ret >= 0 && ret <= 4096) { return null; }
 692                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 693                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 694                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 695                 return ret_hu_conv;
 696         }
 697
 698         /**
 699          * Utility method to constructs a new SendShutdown-variant MessageSendEvent
 700          */
 701         public static MessageSendEvent send_shutdown(byte[] node_id, org.ldk.structs.Shutdown msg) {
 702                 long ret = bindings.MessageSendEvent_send_shutdown(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 703                 Reference.reachabilityFence(node_id);
 704                 Reference.reachabilityFence(msg);
 705                 if (ret >= 0 && ret <= 4096) { return null; }
 706                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 707                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 708                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 709                 return ret_hu_conv;
 710         }
 711
 712         /**
 713          * Utility method to constructs a new SendChannelReestablish-variant MessageSendEvent
 714          */
 715         public static MessageSendEvent send_channel_reestablish(byte[] node_id, org.ldk.structs.ChannelReestablish msg) {
 716                 long ret = bindings.MessageSendEvent_send_channel_reestablish(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 717                 Reference.reachabilityFence(node_id);
 718                 Reference.reachabilityFence(msg);
 719                 if (ret >= 0 && ret <= 4096) { return null; }
 720                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 721                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 722                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 723                 return ret_hu_conv;
 724         }
 725
 726         /**
 727          * Utility method to constructs a new SendChannelAnnouncement-variant MessageSendEvent
 728          */
 729         public static MessageSendEvent send_channel_announcement(byte[] node_id, org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.ChannelUpdate update_msg) {
 730                 long ret = bindings.MessageSendEvent_send_channel_announcement(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr, update_msg == null ? 0 : update_msg.ptr);
 731                 Reference.reachabilityFence(node_id);
 732                 Reference.reachabilityFence(msg);
 733                 Reference.reachabilityFence(update_msg);
 734                 if (ret >= 0 && ret <= 4096) { return null; }
 735                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 736                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 737                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 738                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(update_msg); };
 739                 return ret_hu_conv;
 740         }
 741
 742         /**
 743          * Utility method to constructs a new BroadcastChannelAnnouncement-variant MessageSendEvent
 744          */
 745         public static MessageSendEvent broadcast_channel_announcement(org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.ChannelUpdate update_msg) {
 746                 long ret = bindings.MessageSendEvent_broadcast_channel_announcement(msg == null ? 0 : msg.ptr, update_msg == null ? 0 : update_msg.ptr);
 747                 Reference.reachabilityFence(msg);
 748                 Reference.reachabilityFence(update_msg);
 749                 if (ret >= 0 && ret <= 4096) { return null; }
 750                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 751                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 752                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 753                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(update_msg); };
 754                 return ret_hu_conv;
 755         }
 756
 757         /**
 758          * Utility method to constructs a new BroadcastChannelUpdate-variant MessageSendEvent
 759          */
 760         public static MessageSendEvent broadcast_channel_update(org.ldk.structs.ChannelUpdate msg) {
 761                 long ret = bindings.MessageSendEvent_broadcast_channel_update(msg == null ? 0 : msg.ptr);
 762                 Reference.reachabilityFence(msg);
 763                 if (ret >= 0 && ret <= 4096) { return null; }
 764                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 765                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 766                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 767                 return ret_hu_conv;
 768         }
 769
 770         /**
 771          * Utility method to constructs a new BroadcastNodeAnnouncement-variant MessageSendEvent
 772          */
 773         public static MessageSendEvent broadcast_node_announcement(org.ldk.structs.NodeAnnouncement msg) {
 774                 long ret = bindings.MessageSendEvent_broadcast_node_announcement(msg == null ? 0 : msg.ptr);
 775                 Reference.reachabilityFence(msg);
 776                 if (ret >= 0 && ret <= 4096) { return null; }
 777                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 778                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 779                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 780                 return ret_hu_conv;
 781         }
 782
 783         /**
 784          * Utility method to constructs a new SendChannelUpdate-variant MessageSendEvent
 785          */
 786         public static MessageSendEvent send_channel_update(byte[] node_id, org.ldk.structs.ChannelUpdate msg) {
 787                 long ret = bindings.MessageSendEvent_send_channel_update(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 788                 Reference.reachabilityFence(node_id);
 789                 Reference.reachabilityFence(msg);
 790                 if (ret >= 0 && ret <= 4096) { return null; }
 791                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 792                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 793                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 794                 return ret_hu_conv;
 795         }
 796
 797         /**
 798          * Utility method to constructs a new HandleError-variant MessageSendEvent
 799          */
 800         public static MessageSendEvent handle_error(byte[] node_id, org.ldk.structs.ErrorAction action) {
 801                 long ret = bindings.MessageSendEvent_handle_error(InternalUtils.check_arr_len(node_id, 33), action.ptr);
 802                 Reference.reachabilityFence(node_id);
 803                 Reference.reachabilityFence(action);
 804                 if (ret >= 0 && ret <= 4096) { return null; }
 805                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 806                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 807                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(action); };
 808                 return ret_hu_conv;
 809         }
 810
 811         /**
 812          * Utility method to constructs a new SendChannelRangeQuery-variant MessageSendEvent
 813          */
 814         public static MessageSendEvent send_channel_range_query(byte[] node_id, org.ldk.structs.QueryChannelRange msg) {
 815                 long ret = bindings.MessageSendEvent_send_channel_range_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 816                 Reference.reachabilityFence(node_id);
 817                 Reference.reachabilityFence(msg);
 818                 if (ret >= 0 && ret <= 4096) { return null; }
 819                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 820                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 821                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 822                 return ret_hu_conv;
 823         }
 824
 825         /**
 826          * Utility method to constructs a new SendShortIdsQuery-variant MessageSendEvent
 827          */
 828         public static MessageSendEvent send_short_ids_query(byte[] node_id, org.ldk.structs.QueryShortChannelIds msg) {
 829                 long ret = bindings.MessageSendEvent_send_short_ids_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 830                 Reference.reachabilityFence(node_id);
 831                 Reference.reachabilityFence(msg);
 832                 if (ret >= 0 && ret <= 4096) { return null; }
 833                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 834                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 835                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 836                 return ret_hu_conv;
 837         }
 838
 839         /**
 840          * Utility method to constructs a new SendReplyChannelRange-variant MessageSendEvent
 841          */
 842         public static MessageSendEvent send_reply_channel_range(byte[] node_id, org.ldk.structs.ReplyChannelRange msg) {
 843                 long ret = bindings.MessageSendEvent_send_reply_channel_range(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 844                 Reference.reachabilityFence(node_id);
 845                 Reference.reachabilityFence(msg);
 846                 if (ret >= 0 && ret <= 4096) { return null; }
 847                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 848                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 849                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 850                 return ret_hu_conv;
 851         }
 852
 853         /**
 854          * Utility method to constructs a new SendGossipTimestampFilter-variant MessageSendEvent
 855          */
 856         public static MessageSendEvent send_gossip_timestamp_filter(byte[] node_id, org.ldk.structs.GossipTimestampFilter msg) {
 857                 long ret = bindings.MessageSendEvent_send_gossip_timestamp_filter(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr);
 858                 Reference.reachabilityFence(node_id);
 859                 Reference.reachabilityFence(msg);
 860                 if (ret >= 0 && ret <= 4096) { return null; }
 861                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 862                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 863                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(msg); };
 864                 return ret_hu_conv;
 865         }
 866
 867 }