git.bitcoin.ninja Git - ldk-java/blob - c_sharp/src/org/ldk/structs/MessageSendEvent.cs

   1 using org.ldk.impl;
   2 using org.ldk.enums;
   3 using org.ldk.util;
   4 using System;
   5
   6 namespace org { namespace ldk { namespace structs {
   7
   8 /**
   9  * An event generated by ChannelManager which indicates a message should be sent to a peer (or
  10  * broadcast to most peers).
  11  * These events are handled by PeerManager::process_events if you are using a PeerManager.
  12  */
  13 public class MessageSendEvent : CommonBase {
  14         protected MessageSendEvent(object _dummy, long ptr) : base(ptr) { }
  15         ~MessageSendEvent() {
  16                 if (ptr != 0) { bindings.MessageSendEvent_free(ptr); }
  17         }
  18
  19         internal static MessageSendEvent constr_from_ptr(long ptr) {
  20                 long raw_ty = bindings.LDKMessageSendEvent_ty_from_ptr(ptr);
  21                 switch (raw_ty) {
  22                         case 0: return new MessageSendEvent_SendAcceptChannel(ptr);
  23                         case 1: return new MessageSendEvent_SendAcceptChannelV2(ptr);
  24                         case 2: return new MessageSendEvent_SendOpenChannel(ptr);
  25                         case 3: return new MessageSendEvent_SendOpenChannelV2(ptr);
  26                         case 4: return new MessageSendEvent_SendFundingCreated(ptr);
  27                         case 5: return new MessageSendEvent_SendFundingSigned(ptr);
  28                         case 6: return new MessageSendEvent_SendStfu(ptr);
  29                         case 7: return new MessageSendEvent_SendSpliceInit(ptr);
  30                         case 8: return new MessageSendEvent_SendSpliceAck(ptr);
  31                         case 9: return new MessageSendEvent_SendSpliceLocked(ptr);
  32                         case 10: return new MessageSendEvent_SendTxAddInput(ptr);
  33                         case 11: return new MessageSendEvent_SendTxAddOutput(ptr);
  34                         case 12: return new MessageSendEvent_SendTxRemoveInput(ptr);
  35                         case 13: return new MessageSendEvent_SendTxRemoveOutput(ptr);
  36                         case 14: return new MessageSendEvent_SendTxComplete(ptr);
  37                         case 15: return new MessageSendEvent_SendTxSignatures(ptr);
  38                         case 16: return new MessageSendEvent_SendTxInitRbf(ptr);
  39                         case 17: return new MessageSendEvent_SendTxAckRbf(ptr);
  40                         case 18: return new MessageSendEvent_SendTxAbort(ptr);
  41                         case 19: return new MessageSendEvent_SendChannelReady(ptr);
  42                         case 20: return new MessageSendEvent_SendAnnouncementSignatures(ptr);
  43                         case 21: return new MessageSendEvent_UpdateHTLCs(ptr);
  44                         case 22: return new MessageSendEvent_SendRevokeAndACK(ptr);
  45                         case 23: return new MessageSendEvent_SendClosingSigned(ptr);
  46                         case 24: return new MessageSendEvent_SendShutdown(ptr);
  47                         case 25: return new MessageSendEvent_SendChannelReestablish(ptr);
  48                         case 26: return new MessageSendEvent_SendChannelAnnouncement(ptr);
  49                         case 27: return new MessageSendEvent_BroadcastChannelAnnouncement(ptr);
  50                         case 28: return new MessageSendEvent_BroadcastChannelUpdate(ptr);
  51                         case 29: return new MessageSendEvent_BroadcastNodeAnnouncement(ptr);
  52                         case 30: return new MessageSendEvent_SendChannelUpdate(ptr);
  53                         case 31: return new MessageSendEvent_HandleError(ptr);
  54                         case 32: return new MessageSendEvent_SendChannelRangeQuery(ptr);
  55                         case 33: return new MessageSendEvent_SendShortIdsQuery(ptr);
  56                         case 34: return new MessageSendEvent_SendReplyChannelRange(ptr);
  57                         case 35: return new MessageSendEvent_SendGossipTimestampFilter(ptr);
  58                         default:
  59                                 throw new ArgumentException("Impossible enum variant");
  60                 }
  61         }
  62
  63         /** A MessageSendEvent of type SendAcceptChannel */
  64         public class MessageSendEvent_SendAcceptChannel : MessageSendEvent {
  65                 /**
  66                  * The node_id of the node which should receive this message
  67                  */
  68                 public byte[] node_id;
  69                 /**
  70                  * The message which should be sent.
  71                  */
  72                 public AcceptChannel msg;
  73                 internal MessageSendEvent_SendAcceptChannel(long ptr) : base(null, ptr) {
  74                         long node_id = bindings.LDKMessageSendEvent_SendAcceptChannel_get_node_id(ptr);
  75                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
  76                         this.node_id = node_id_conv;
  77                         long msg = bindings.LDKMessageSendEvent_SendAcceptChannel_get_msg(ptr);
  78                         org.ldk.structs.AcceptChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AcceptChannel(null, msg); }
  79                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
  80                         this.msg = msg_hu_conv;
  81                 }
  82         }
  83         /** A MessageSendEvent of type SendAcceptChannelV2 */
  84         public class MessageSendEvent_SendAcceptChannelV2 : MessageSendEvent {
  85                 /**
  86                  * The node_id of the node which should receive this message
  87                  */
  88                 public byte[] node_id;
  89                 /**
  90                  * The message which should be sent.
  91                  */
  92                 public AcceptChannelV2 msg;
  93                 internal MessageSendEvent_SendAcceptChannelV2(long ptr) : base(null, ptr) {
  94                         long node_id = bindings.LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(ptr);
  95                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
  96                         this.node_id = node_id_conv;
  97                         long msg = bindings.LDKMessageSendEvent_SendAcceptChannelV2_get_msg(ptr);
  98                         org.ldk.structs.AcceptChannelV2 msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AcceptChannelV2(null, msg); }
  99                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 100                         this.msg = msg_hu_conv;
 101                 }
 102         }
 103         /** A MessageSendEvent of type SendOpenChannel */
 104         public class MessageSendEvent_SendOpenChannel : MessageSendEvent {
 105                 /**
 106                  * The node_id of the node which should receive this message
 107                  */
 108                 public byte[] node_id;
 109                 /**
 110                  * The message which should be sent.
 111                  */
 112                 public OpenChannel msg;
 113                 internal MessageSendEvent_SendOpenChannel(long ptr) : base(null, ptr) {
 114                         long node_id = bindings.LDKMessageSendEvent_SendOpenChannel_get_node_id(ptr);
 115                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 116                         this.node_id = node_id_conv;
 117                         long msg = bindings.LDKMessageSendEvent_SendOpenChannel_get_msg(ptr);
 118                         org.ldk.structs.OpenChannel msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.OpenChannel(null, msg); }
 119                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 120                         this.msg = msg_hu_conv;
 121                 }
 122         }
 123         /** A MessageSendEvent of type SendOpenChannelV2 */
 124         public class MessageSendEvent_SendOpenChannelV2 : MessageSendEvent {
 125                 /**
 126                  * The node_id of the node which should receive this message
 127                  */
 128                 public byte[] node_id;
 129                 /**
 130                  * The message which should be sent.
 131                  */
 132                 public OpenChannelV2 msg;
 133                 internal MessageSendEvent_SendOpenChannelV2(long ptr) : base(null, ptr) {
 134                         long node_id = bindings.LDKMessageSendEvent_SendOpenChannelV2_get_node_id(ptr);
 135                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 136                         this.node_id = node_id_conv;
 137                         long msg = bindings.LDKMessageSendEvent_SendOpenChannelV2_get_msg(ptr);
 138                         org.ldk.structs.OpenChannelV2 msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.OpenChannelV2(null, msg); }
 139                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 140                         this.msg = msg_hu_conv;
 141                 }
 142         }
 143         /** A MessageSendEvent of type SendFundingCreated */
 144         public class MessageSendEvent_SendFundingCreated : MessageSendEvent {
 145                 /**
 146                  * The node_id of the node which should receive this message
 147                  */
 148                 public byte[] node_id;
 149                 /**
 150                  * The message which should be sent.
 151                  */
 152                 public FundingCreated msg;
 153                 internal MessageSendEvent_SendFundingCreated(long ptr) : base(null, ptr) {
 154                         long node_id = bindings.LDKMessageSendEvent_SendFundingCreated_get_node_id(ptr);
 155                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 156                         this.node_id = node_id_conv;
 157                         long msg = bindings.LDKMessageSendEvent_SendFundingCreated_get_msg(ptr);
 158                         org.ldk.structs.FundingCreated msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.FundingCreated(null, msg); }
 159                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 160                         this.msg = msg_hu_conv;
 161                 }
 162         }
 163         /** A MessageSendEvent of type SendFundingSigned */
 164         public class MessageSendEvent_SendFundingSigned : MessageSendEvent {
 165                 /**
 166                  * The node_id of the node which should receive this message
 167                  */
 168                 public byte[] node_id;
 169                 /**
 170                  * The message which should be sent.
 171                  */
 172                 public FundingSigned msg;
 173                 internal MessageSendEvent_SendFundingSigned(long ptr) : base(null, ptr) {
 174                         long node_id = bindings.LDKMessageSendEvent_SendFundingSigned_get_node_id(ptr);
 175                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 176                         this.node_id = node_id_conv;
 177                         long msg = bindings.LDKMessageSendEvent_SendFundingSigned_get_msg(ptr);
 178                         org.ldk.structs.FundingSigned msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.FundingSigned(null, msg); }
 179                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 180                         this.msg = msg_hu_conv;
 181                 }
 182         }
 183         /** A MessageSendEvent of type SendStfu */
 184         public class MessageSendEvent_SendStfu : MessageSendEvent {
 185                 /**
 186                  * The node_id of the node which should receive this message
 187                  */
 188                 public byte[] node_id;
 189                 /**
 190                  * The message which should be sent.
 191                  */
 192                 public Stfu msg;
 193                 internal MessageSendEvent_SendStfu(long ptr) : base(null, ptr) {
 194                         long node_id = bindings.LDKMessageSendEvent_SendStfu_get_node_id(ptr);
 195                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 196                         this.node_id = node_id_conv;
 197                         long msg = bindings.LDKMessageSendEvent_SendStfu_get_msg(ptr);
 198                         org.ldk.structs.Stfu msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.Stfu(null, msg); }
 199                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 200                         this.msg = msg_hu_conv;
 201                 }
 202         }
 203         /** A MessageSendEvent of type SendSpliceInit */
 204         public class MessageSendEvent_SendSpliceInit : MessageSendEvent {
 205                 /**
 206                  * The node_id of the node which should receive this message
 207                  */
 208                 public byte[] node_id;
 209                 /**
 210                  * The message which should be sent.
 211                  */
 212                 public SpliceInit msg;
 213                 internal MessageSendEvent_SendSpliceInit(long ptr) : base(null, ptr) {
 214                         long node_id = bindings.LDKMessageSendEvent_SendSpliceInit_get_node_id(ptr);
 215                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 216                         this.node_id = node_id_conv;
 217                         long msg = bindings.LDKMessageSendEvent_SendSpliceInit_get_msg(ptr);
 218                         org.ldk.structs.SpliceInit msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.SpliceInit(null, msg); }
 219                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 220                         this.msg = msg_hu_conv;
 221                 }
 222         }
 223         /** A MessageSendEvent of type SendSpliceAck */
 224         public class MessageSendEvent_SendSpliceAck : MessageSendEvent {
 225                 /**
 226                  * The node_id of the node which should receive this message
 227                  */
 228                 public byte[] node_id;
 229                 /**
 230                  * The message which should be sent.
 231                  */
 232                 public SpliceAck msg;
 233                 internal MessageSendEvent_SendSpliceAck(long ptr) : base(null, ptr) {
 234                         long node_id = bindings.LDKMessageSendEvent_SendSpliceAck_get_node_id(ptr);
 235                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 236                         this.node_id = node_id_conv;
 237                         long msg = bindings.LDKMessageSendEvent_SendSpliceAck_get_msg(ptr);
 238                         org.ldk.structs.SpliceAck msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.SpliceAck(null, msg); }
 239                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 240                         this.msg = msg_hu_conv;
 241                 }
 242         }
 243         /** A MessageSendEvent of type SendSpliceLocked */
 244         public class MessageSendEvent_SendSpliceLocked : MessageSendEvent {
 245                 /**
 246                  * The node_id of the node which should receive this message
 247                  */
 248                 public byte[] node_id;
 249                 /**
 250                  * The message which should be sent.
 251                  */
 252                 public SpliceLocked msg;
 253                 internal MessageSendEvent_SendSpliceLocked(long ptr) : base(null, ptr) {
 254                         long node_id = bindings.LDKMessageSendEvent_SendSpliceLocked_get_node_id(ptr);
 255                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 256                         this.node_id = node_id_conv;
 257                         long msg = bindings.LDKMessageSendEvent_SendSpliceLocked_get_msg(ptr);
 258                         org.ldk.structs.SpliceLocked msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.SpliceLocked(null, msg); }
 259                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 260                         this.msg = msg_hu_conv;
 261                 }
 262         }
 263         /** A MessageSendEvent of type SendTxAddInput */
 264         public class MessageSendEvent_SendTxAddInput : MessageSendEvent {
 265                 /**
 266                  * The node_id of the node which should receive this message
 267                  */
 268                 public byte[] node_id;
 269                 /**
 270                  * The message which should be sent.
 271                  */
 272                 public TxAddInput msg;
 273                 internal MessageSendEvent_SendTxAddInput(long ptr) : base(null, ptr) {
 274                         long node_id = bindings.LDKMessageSendEvent_SendTxAddInput_get_node_id(ptr);
 275                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 276                         this.node_id = node_id_conv;
 277                         long msg = bindings.LDKMessageSendEvent_SendTxAddInput_get_msg(ptr);
 278                         org.ldk.structs.TxAddInput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAddInput(null, msg); }
 279                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 280                         this.msg = msg_hu_conv;
 281                 }
 282         }
 283         /** A MessageSendEvent of type SendTxAddOutput */
 284         public class MessageSendEvent_SendTxAddOutput : MessageSendEvent {
 285                 /**
 286                  * The node_id of the node which should receive this message
 287                  */
 288                 public byte[] node_id;
 289                 /**
 290                  * The message which should be sent.
 291                  */
 292                 public TxAddOutput msg;
 293                 internal MessageSendEvent_SendTxAddOutput(long ptr) : base(null, ptr) {
 294                         long node_id = bindings.LDKMessageSendEvent_SendTxAddOutput_get_node_id(ptr);
 295                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 296                         this.node_id = node_id_conv;
 297                         long msg = bindings.LDKMessageSendEvent_SendTxAddOutput_get_msg(ptr);
 298                         org.ldk.structs.TxAddOutput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAddOutput(null, msg); }
 299                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 300                         this.msg = msg_hu_conv;
 301                 }
 302         }
 303         /** A MessageSendEvent of type SendTxRemoveInput */
 304         public class MessageSendEvent_SendTxRemoveInput : MessageSendEvent {
 305                 /**
 306                  * The node_id of the node which should receive this message
 307                  */
 308                 public byte[] node_id;
 309                 /**
 310                  * The message which should be sent.
 311                  */
 312                 public TxRemoveInput msg;
 313                 internal MessageSendEvent_SendTxRemoveInput(long ptr) : base(null, ptr) {
 314                         long node_id = bindings.LDKMessageSendEvent_SendTxRemoveInput_get_node_id(ptr);
 315                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 316                         this.node_id = node_id_conv;
 317                         long msg = bindings.LDKMessageSendEvent_SendTxRemoveInput_get_msg(ptr);
 318                         org.ldk.structs.TxRemoveInput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxRemoveInput(null, msg); }
 319                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 320                         this.msg = msg_hu_conv;
 321                 }
 322         }
 323         /** A MessageSendEvent of type SendTxRemoveOutput */
 324         public class MessageSendEvent_SendTxRemoveOutput : MessageSendEvent {
 325                 /**
 326                  * The node_id of the node which should receive this message
 327                  */
 328                 public byte[] node_id;
 329                 /**
 330                  * The message which should be sent.
 331                  */
 332                 public TxRemoveOutput msg;
 333                 internal MessageSendEvent_SendTxRemoveOutput(long ptr) : base(null, ptr) {
 334                         long node_id = bindings.LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(ptr);
 335                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 336                         this.node_id = node_id_conv;
 337                         long msg = bindings.LDKMessageSendEvent_SendTxRemoveOutput_get_msg(ptr);
 338                         org.ldk.structs.TxRemoveOutput msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxRemoveOutput(null, msg); }
 339                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 340                         this.msg = msg_hu_conv;
 341                 }
 342         }
 343         /** A MessageSendEvent of type SendTxComplete */
 344         public class MessageSendEvent_SendTxComplete : MessageSendEvent {
 345                 /**
 346                  * The node_id of the node which should receive this message
 347                  */
 348                 public byte[] node_id;
 349                 /**
 350                  * The message which should be sent.
 351                  */
 352                 public TxComplete msg;
 353                 internal MessageSendEvent_SendTxComplete(long ptr) : base(null, ptr) {
 354                         long node_id = bindings.LDKMessageSendEvent_SendTxComplete_get_node_id(ptr);
 355                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 356                         this.node_id = node_id_conv;
 357                         long msg = bindings.LDKMessageSendEvent_SendTxComplete_get_msg(ptr);
 358                         org.ldk.structs.TxComplete msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxComplete(null, msg); }
 359                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 360                         this.msg = msg_hu_conv;
 361                 }
 362         }
 363         /** A MessageSendEvent of type SendTxSignatures */
 364         public class MessageSendEvent_SendTxSignatures : MessageSendEvent {
 365                 /**
 366                  * The node_id of the node which should receive this message
 367                  */
 368                 public byte[] node_id;
 369                 /**
 370                  * The message which should be sent.
 371                  */
 372                 public TxSignatures msg;
 373                 internal MessageSendEvent_SendTxSignatures(long ptr) : base(null, ptr) {
 374                         long node_id = bindings.LDKMessageSendEvent_SendTxSignatures_get_node_id(ptr);
 375                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 376                         this.node_id = node_id_conv;
 377                         long msg = bindings.LDKMessageSendEvent_SendTxSignatures_get_msg(ptr);
 378                         org.ldk.structs.TxSignatures msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxSignatures(null, msg); }
 379                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 380                         this.msg = msg_hu_conv;
 381                 }
 382         }
 383         /** A MessageSendEvent of type SendTxInitRbf */
 384         public class MessageSendEvent_SendTxInitRbf : MessageSendEvent {
 385                 /**
 386                  * The node_id of the node which should receive this message
 387                  */
 388                 public byte[] node_id;
 389                 /**
 390                  * The message which should be sent.
 391                  */
 392                 public TxInitRbf msg;
 393                 internal MessageSendEvent_SendTxInitRbf(long ptr) : base(null, ptr) {
 394                         long node_id = bindings.LDKMessageSendEvent_SendTxInitRbf_get_node_id(ptr);
 395                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 396                         this.node_id = node_id_conv;
 397                         long msg = bindings.LDKMessageSendEvent_SendTxInitRbf_get_msg(ptr);
 398                         org.ldk.structs.TxInitRbf msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxInitRbf(null, msg); }
 399                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 400                         this.msg = msg_hu_conv;
 401                 }
 402         }
 403         /** A MessageSendEvent of type SendTxAckRbf */
 404         public class MessageSendEvent_SendTxAckRbf : MessageSendEvent {
 405                 /**
 406                  * The node_id of the node which should receive this message
 407                  */
 408                 public byte[] node_id;
 409                 /**
 410                  * The message which should be sent.
 411                  */
 412                 public TxAckRbf msg;
 413                 internal MessageSendEvent_SendTxAckRbf(long ptr) : base(null, ptr) {
 414                         long node_id = bindings.LDKMessageSendEvent_SendTxAckRbf_get_node_id(ptr);
 415                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 416                         this.node_id = node_id_conv;
 417                         long msg = bindings.LDKMessageSendEvent_SendTxAckRbf_get_msg(ptr);
 418                         org.ldk.structs.TxAckRbf msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAckRbf(null, msg); }
 419                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 420                         this.msg = msg_hu_conv;
 421                 }
 422         }
 423         /** A MessageSendEvent of type SendTxAbort */
 424         public class MessageSendEvent_SendTxAbort : MessageSendEvent {
 425                 /**
 426                  * The node_id of the node which should receive this message
 427                  */
 428                 public byte[] node_id;
 429                 /**
 430                  * The message which should be sent.
 431                  */
 432                 public TxAbort msg;
 433                 internal MessageSendEvent_SendTxAbort(long ptr) : base(null, ptr) {
 434                         long node_id = bindings.LDKMessageSendEvent_SendTxAbort_get_node_id(ptr);
 435                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 436                         this.node_id = node_id_conv;
 437                         long msg = bindings.LDKMessageSendEvent_SendTxAbort_get_msg(ptr);
 438                         org.ldk.structs.TxAbort msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.TxAbort(null, msg); }
 439                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 440                         this.msg = msg_hu_conv;
 441                 }
 442         }
 443         /** A MessageSendEvent of type SendChannelReady */
 444         public class MessageSendEvent_SendChannelReady : MessageSendEvent {
 445                 /**
 446                  * The node_id of the node which should receive these message(s)
 447                  */
 448                 public byte[] node_id;
 449                 /**
 450                  * The channel_ready message which should be sent.
 451                  */
 452                 public ChannelReady msg;
 453                 internal MessageSendEvent_SendChannelReady(long ptr) : base(null, ptr) {
 454                         long node_id = bindings.LDKMessageSendEvent_SendChannelReady_get_node_id(ptr);
 455                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 456                         this.node_id = node_id_conv;
 457                         long msg = bindings.LDKMessageSendEvent_SendChannelReady_get_msg(ptr);
 458                         org.ldk.structs.ChannelReady msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelReady(null, msg); }
 459                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 460                         this.msg = msg_hu_conv;
 461                 }
 462         }
 463         /** A MessageSendEvent of type SendAnnouncementSignatures */
 464         public class MessageSendEvent_SendAnnouncementSignatures : MessageSendEvent {
 465                 /**
 466                  * The node_id of the node which should receive these message(s)
 467                  */
 468                 public byte[] node_id;
 469                 /**
 470                  * The announcement_signatures message which should be sent.
 471                  */
 472                 public AnnouncementSignatures msg;
 473                 internal MessageSendEvent_SendAnnouncementSignatures(long ptr) : base(null, ptr) {
 474                         long node_id = bindings.LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(ptr);
 475                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 476                         this.node_id = node_id_conv;
 477                         long msg = bindings.LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(ptr);
 478                         org.ldk.structs.AnnouncementSignatures msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.AnnouncementSignatures(null, msg); }
 479                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 480                         this.msg = msg_hu_conv;
 481                 }
 482         }
 483         /** A MessageSendEvent of type UpdateHTLCs */
 484         public class MessageSendEvent_UpdateHTLCs : MessageSendEvent {
 485                 /**
 486                  * The node_id of the node which should receive these message(s)
 487                  */
 488                 public byte[] node_id;
 489                 /**
 490                  * The update messages which should be sent. ALL messages in the struct should be sent!
 491                  */
 492                 public CommitmentUpdate updates;
 493                 internal MessageSendEvent_UpdateHTLCs(long ptr) : base(null, ptr) {
 494                         long node_id = bindings.LDKMessageSendEvent_UpdateHTLCs_get_node_id(ptr);
 495                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 496                         this.node_id = node_id_conv;
 497                         long updates = bindings.LDKMessageSendEvent_UpdateHTLCs_get_updates(ptr);
 498                         org.ldk.structs.CommitmentUpdate updates_hu_conv = null; if (updates < 0 || updates > 4096) { updates_hu_conv = new org.ldk.structs.CommitmentUpdate(null, updates); }
 499                         if (updates_hu_conv != null) { updates_hu_conv.ptrs_to.AddLast(this); };
 500                         this.updates = updates_hu_conv;
 501                 }
 502         }
 503         /** A MessageSendEvent of type SendRevokeAndACK */
 504         public class MessageSendEvent_SendRevokeAndACK : MessageSendEvent {
 505                 /**
 506                  * The node_id of the node which should receive this message
 507                  */
 508                 public byte[] node_id;
 509                 /**
 510                  * The message which should be sent.
 511                  */
 512                 public RevokeAndACK msg;
 513                 internal MessageSendEvent_SendRevokeAndACK(long ptr) : base(null, ptr) {
 514                         long node_id = bindings.LDKMessageSendEvent_SendRevokeAndACK_get_node_id(ptr);
 515                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 516                         this.node_id = node_id_conv;
 517                         long msg = bindings.LDKMessageSendEvent_SendRevokeAndACK_get_msg(ptr);
 518                         org.ldk.structs.RevokeAndACK msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.RevokeAndACK(null, msg); }
 519                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 520                         this.msg = msg_hu_conv;
 521                 }
 522         }
 523         /** A MessageSendEvent of type SendClosingSigned */
 524         public class MessageSendEvent_SendClosingSigned : MessageSendEvent {
 525                 /**
 526                  * The node_id of the node which should receive this message
 527                  */
 528                 public byte[] node_id;
 529                 /**
 530                  * The message which should be sent.
 531                  */
 532                 public ClosingSigned msg;
 533                 internal MessageSendEvent_SendClosingSigned(long ptr) : base(null, ptr) {
 534                         long node_id = bindings.LDKMessageSendEvent_SendClosingSigned_get_node_id(ptr);
 535                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 536                         this.node_id = node_id_conv;
 537                         long msg = bindings.LDKMessageSendEvent_SendClosingSigned_get_msg(ptr);
 538                         org.ldk.structs.ClosingSigned msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ClosingSigned(null, msg); }
 539                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 540                         this.msg = msg_hu_conv;
 541                 }
 542         }
 543         /** A MessageSendEvent of type SendShutdown */
 544         public class MessageSendEvent_SendShutdown : MessageSendEvent {
 545                 /**
 546                  * The node_id of the node which should receive this message
 547                  */
 548                 public byte[] node_id;
 549                 /**
 550                  * The message which should be sent.
 551                  */
 552                 public Shutdown msg;
 553                 internal MessageSendEvent_SendShutdown(long ptr) : base(null, ptr) {
 554                         long node_id = bindings.LDKMessageSendEvent_SendShutdown_get_node_id(ptr);
 555                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 556                         this.node_id = node_id_conv;
 557                         long msg = bindings.LDKMessageSendEvent_SendShutdown_get_msg(ptr);
 558                         org.ldk.structs.Shutdown msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.Shutdown(null, msg); }
 559                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 560                         this.msg = msg_hu_conv;
 561                 }
 562         }
 563         /** A MessageSendEvent of type SendChannelReestablish */
 564         public class MessageSendEvent_SendChannelReestablish : MessageSendEvent {
 565                 /**
 566                  * The node_id of the node which should receive this message
 567                  */
 568                 public byte[] node_id;
 569                 /**
 570                  * The message which should be sent.
 571                  */
 572                 public ChannelReestablish msg;
 573                 internal MessageSendEvent_SendChannelReestablish(long ptr) : base(null, ptr) {
 574                         long node_id = bindings.LDKMessageSendEvent_SendChannelReestablish_get_node_id(ptr);
 575                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 576                         this.node_id = node_id_conv;
 577                         long msg = bindings.LDKMessageSendEvent_SendChannelReestablish_get_msg(ptr);
 578                         org.ldk.structs.ChannelReestablish msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelReestablish(null, msg); }
 579                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 580                         this.msg = msg_hu_conv;
 581                 }
 582         }
 583         /** A MessageSendEvent of type SendChannelAnnouncement */
 584         public class MessageSendEvent_SendChannelAnnouncement : MessageSendEvent {
 585                 /**
 586                  * The node_id of the node which should receive this message
 587                  */
 588                 public byte[] node_id;
 589                 /**
 590                  * The channel_announcement which should be sent.
 591                  */
 592                 public ChannelAnnouncement msg;
 593                 /**
 594                  * The followup channel_update which should be sent.
 595                  */
 596                 public ChannelUpdate update_msg;
 597                 internal MessageSendEvent_SendChannelAnnouncement(long ptr) : base(null, ptr) {
 598                         long node_id = bindings.LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(ptr);
 599                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 600                         this.node_id = node_id_conv;
 601                         long msg = bindings.LDKMessageSendEvent_SendChannelAnnouncement_get_msg(ptr);
 602                         org.ldk.structs.ChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelAnnouncement(null, msg); }
 603                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 604                         this.msg = msg_hu_conv;
 605                         long update_msg = bindings.LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(ptr);
 606                         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); }
 607                         if (update_msg_hu_conv != null) { update_msg_hu_conv.ptrs_to.AddLast(this); };
 608                         this.update_msg = update_msg_hu_conv;
 609                 }
 610         }
 611         /** A MessageSendEvent of type BroadcastChannelAnnouncement */
 612         public class MessageSendEvent_BroadcastChannelAnnouncement : MessageSendEvent {
 613                 /**
 614                  * The channel_announcement which should be sent.
 615                  */
 616                 public ChannelAnnouncement msg;
 617                 /**
 618                  * The followup channel_update which should be sent.
 619                  *
 620                  * Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None
 621                  */
 622                 public ChannelUpdate update_msg;
 623                 internal MessageSendEvent_BroadcastChannelAnnouncement(long ptr) : base(null, ptr) {
 624                         long msg = bindings.LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(ptr);
 625                         org.ldk.structs.ChannelAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelAnnouncement(null, msg); }
 626                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 627                         this.msg = msg_hu_conv;
 628                         long update_msg = bindings.LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(ptr);
 629                         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); }
 630                         if (update_msg_hu_conv != null) { update_msg_hu_conv.ptrs_to.AddLast(this); };
 631                         this.update_msg = update_msg_hu_conv;
 632                 }
 633         }
 634         /** A MessageSendEvent of type BroadcastChannelUpdate */
 635         public class MessageSendEvent_BroadcastChannelUpdate : MessageSendEvent {
 636                 /**
 637                  * The channel_update which should be sent.
 638                  */
 639                 public ChannelUpdate msg;
 640                 internal MessageSendEvent_BroadcastChannelUpdate(long ptr) : base(null, ptr) {
 641                         long msg = bindings.LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(ptr);
 642                         org.ldk.structs.ChannelUpdate msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, msg); }
 643                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 644                         this.msg = msg_hu_conv;
 645                 }
 646         }
 647         /** A MessageSendEvent of type BroadcastNodeAnnouncement */
 648         public class MessageSendEvent_BroadcastNodeAnnouncement : MessageSendEvent {
 649                 /**
 650                  * The node_announcement which should be sent.
 651                  */
 652                 public NodeAnnouncement msg;
 653                 internal MessageSendEvent_BroadcastNodeAnnouncement(long ptr) : base(null, ptr) {
 654                         long msg = bindings.LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(ptr);
 655                         org.ldk.structs.NodeAnnouncement msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.NodeAnnouncement(null, msg); }
 656                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 657                         this.msg = msg_hu_conv;
 658                 }
 659         }
 660         /** A MessageSendEvent of type SendChannelUpdate */
 661         public class MessageSendEvent_SendChannelUpdate : MessageSendEvent {
 662                 /**
 663                  * The node_id of the node which should receive this message
 664                  */
 665                 public byte[] node_id;
 666                 /**
 667                  * The channel_update which should be sent.
 668                  */
 669                 public ChannelUpdate msg;
 670                 internal MessageSendEvent_SendChannelUpdate(long ptr) : base(null, ptr) {
 671                         long node_id = bindings.LDKMessageSendEvent_SendChannelUpdate_get_node_id(ptr);
 672                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 673                         this.node_id = node_id_conv;
 674                         long msg = bindings.LDKMessageSendEvent_SendChannelUpdate_get_msg(ptr);
 675                         org.ldk.structs.ChannelUpdate msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ChannelUpdate(null, msg); }
 676                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 677                         this.msg = msg_hu_conv;
 678                 }
 679         }
 680         /** A MessageSendEvent of type HandleError */
 681         public class MessageSendEvent_HandleError : MessageSendEvent {
 682                 /**
 683                  * The node_id of the node which should receive this message
 684                  */
 685                 public byte[] node_id;
 686                 /**
 687                  * The action which should be taken.
 688                  */
 689                 public ErrorAction action;
 690                 internal MessageSendEvent_HandleError(long ptr) : base(null, ptr) {
 691                         long node_id = bindings.LDKMessageSendEvent_HandleError_get_node_id(ptr);
 692                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 693                         this.node_id = node_id_conv;
 694                         long action = bindings.LDKMessageSendEvent_HandleError_get_action(ptr);
 695                         org.ldk.structs.ErrorAction action_hu_conv = org.ldk.structs.ErrorAction.constr_from_ptr(action);
 696                         if (action_hu_conv != null) { action_hu_conv.ptrs_to.AddLast(this); };
 697                         this.action = action_hu_conv;
 698                 }
 699         }
 700         /** A MessageSendEvent of type SendChannelRangeQuery */
 701         public class MessageSendEvent_SendChannelRangeQuery : MessageSendEvent {
 702                 /**
 703                  * The node_id of this message recipient
 704                  */
 705                 public byte[] node_id;
 706                 /**
 707                  * The query_channel_range which should be sent.
 708                  */
 709                 public QueryChannelRange msg;
 710                 internal MessageSendEvent_SendChannelRangeQuery(long ptr) : base(null, ptr) {
 711                         long node_id = bindings.LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(ptr);
 712                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 713                         this.node_id = node_id_conv;
 714                         long msg = bindings.LDKMessageSendEvent_SendChannelRangeQuery_get_msg(ptr);
 715                         org.ldk.structs.QueryChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.QueryChannelRange(null, msg); }
 716                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 717                         this.msg = msg_hu_conv;
 718                 }
 719         }
 720         /** A MessageSendEvent of type SendShortIdsQuery */
 721         public class MessageSendEvent_SendShortIdsQuery : MessageSendEvent {
 722                 /**
 723                  * The node_id of this message recipient
 724                  */
 725                 public byte[] node_id;
 726                 /**
 727                  * The query_short_channel_ids which should be sent.
 728                  */
 729                 public QueryShortChannelIds msg;
 730                 internal MessageSendEvent_SendShortIdsQuery(long ptr) : base(null, ptr) {
 731                         long node_id = bindings.LDKMessageSendEvent_SendShortIdsQuery_get_node_id(ptr);
 732                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 733                         this.node_id = node_id_conv;
 734                         long msg = bindings.LDKMessageSendEvent_SendShortIdsQuery_get_msg(ptr);
 735                         org.ldk.structs.QueryShortChannelIds msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.QueryShortChannelIds(null, msg); }
 736                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 737                         this.msg = msg_hu_conv;
 738                 }
 739         }
 740         /** A MessageSendEvent of type SendReplyChannelRange */
 741         public class MessageSendEvent_SendReplyChannelRange : MessageSendEvent {
 742                 /**
 743                  * The node_id of this message recipient
 744                  */
 745                 public byte[] node_id;
 746                 /**
 747                  * The reply_channel_range which should be sent.
 748                  */
 749                 public ReplyChannelRange msg;
 750                 internal MessageSendEvent_SendReplyChannelRange(long ptr) : base(null, ptr) {
 751                         long node_id = bindings.LDKMessageSendEvent_SendReplyChannelRange_get_node_id(ptr);
 752                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 753                         this.node_id = node_id_conv;
 754                         long msg = bindings.LDKMessageSendEvent_SendReplyChannelRange_get_msg(ptr);
 755                         org.ldk.structs.ReplyChannelRange msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.ReplyChannelRange(null, msg); }
 756                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 757                         this.msg = msg_hu_conv;
 758                 }
 759         }
 760         /** A MessageSendEvent of type SendGossipTimestampFilter */
 761         public class MessageSendEvent_SendGossipTimestampFilter : MessageSendEvent {
 762                 /**
 763                  * The node_id of this message recipient
 764                  */
 765                 public byte[] node_id;
 766                 /**
 767                  * The gossip_timestamp_filter which should be sent.
 768                  */
 769                 public GossipTimestampFilter msg;
 770                 internal MessageSendEvent_SendGossipTimestampFilter(long ptr) : base(null, ptr) {
 771                         long node_id = bindings.LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(ptr);
 772                         byte[] node_id_conv = InternalUtils.decodeUint8Array(node_id);
 773                         this.node_id = node_id_conv;
 774                         long msg = bindings.LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(ptr);
 775                         org.ldk.structs.GossipTimestampFilter msg_hu_conv = null; if (msg < 0 || msg > 4096) { msg_hu_conv = new org.ldk.structs.GossipTimestampFilter(null, msg); }
 776                         if (msg_hu_conv != null) { msg_hu_conv.ptrs_to.AddLast(this); };
 777                         this.msg = msg_hu_conv;
 778                 }
 779         }
 780         internal long clone_ptr() {
 781                 long ret = bindings.MessageSendEvent_clone_ptr(this.ptr);
 782                 GC.KeepAlive(this);
 783                 return ret;
 784         }
 785
 786         /**
 787          * Creates a copy of the MessageSendEvent
 788          */
 789         public MessageSendEvent clone() {
 790                 long ret = bindings.MessageSendEvent_clone(this.ptr);
 791                 GC.KeepAlive(this);
 792                 if (ret >= 0 && ret <= 4096) { return null; }
 793                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 794                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
 795                 return ret_hu_conv;
 796         }
 797
 798         /**
 799          * Utility method to constructs a new SendAcceptChannel-variant MessageSendEvent
 800          */
 801         public static MessageSendEvent send_accept_channel(byte[] node_id, org.ldk.structs.AcceptChannel msg) {
 802                 long ret = bindings.MessageSendEvent_send_accept_channel(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 803                 GC.KeepAlive(node_id);
 804                 GC.KeepAlive(msg);
 805                 if (ret >= 0 && ret <= 4096) { return null; }
 806                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 807                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 808                 return ret_hu_conv;
 809         }
 810
 811         /**
 812          * Utility method to constructs a new SendAcceptChannelV2-variant MessageSendEvent
 813          */
 814         public static MessageSendEvent send_accept_channel_v2(byte[] node_id, org.ldk.structs.AcceptChannelV2 msg) {
 815                 long ret = bindings.MessageSendEvent_send_accept_channel_v2(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 816                 GC.KeepAlive(node_id);
 817                 GC.KeepAlive(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.AddLast(ret_hu_conv); };
 821                 return ret_hu_conv;
 822         }
 823
 824         /**
 825          * Utility method to constructs a new SendOpenChannel-variant MessageSendEvent
 826          */
 827         public static MessageSendEvent send_open_channel(byte[] node_id, org.ldk.structs.OpenChannel msg) {
 828                 long ret = bindings.MessageSendEvent_send_open_channel(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 829                 GC.KeepAlive(node_id);
 830                 GC.KeepAlive(msg);
 831                 if (ret >= 0 && ret <= 4096) { return null; }
 832                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 833                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 834                 return ret_hu_conv;
 835         }
 836
 837         /**
 838          * Utility method to constructs a new SendOpenChannelV2-variant MessageSendEvent
 839          */
 840         public static MessageSendEvent send_open_channel_v2(byte[] node_id, org.ldk.structs.OpenChannelV2 msg) {
 841                 long ret = bindings.MessageSendEvent_send_open_channel_v2(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 842                 GC.KeepAlive(node_id);
 843                 GC.KeepAlive(msg);
 844                 if (ret >= 0 && ret <= 4096) { return null; }
 845                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 846                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 847                 return ret_hu_conv;
 848         }
 849
 850         /**
 851          * Utility method to constructs a new SendFundingCreated-variant MessageSendEvent
 852          */
 853         public static MessageSendEvent send_funding_created(byte[] node_id, org.ldk.structs.FundingCreated msg) {
 854                 long ret = bindings.MessageSendEvent_send_funding_created(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 855                 GC.KeepAlive(node_id);
 856                 GC.KeepAlive(msg);
 857                 if (ret >= 0 && ret <= 4096) { return null; }
 858                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 859                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 860                 return ret_hu_conv;
 861         }
 862
 863         /**
 864          * Utility method to constructs a new SendFundingSigned-variant MessageSendEvent
 865          */
 866         public static MessageSendEvent send_funding_signed(byte[] node_id, org.ldk.structs.FundingSigned msg) {
 867                 long ret = bindings.MessageSendEvent_send_funding_signed(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 868                 GC.KeepAlive(node_id);
 869                 GC.KeepAlive(msg);
 870                 if (ret >= 0 && ret <= 4096) { return null; }
 871                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 872                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 873                 return ret_hu_conv;
 874         }
 875
 876         /**
 877          * Utility method to constructs a new SendStfu-variant MessageSendEvent
 878          */
 879         public static MessageSendEvent send_stfu(byte[] node_id, org.ldk.structs.Stfu msg) {
 880                 long ret = bindings.MessageSendEvent_send_stfu(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 881                 GC.KeepAlive(node_id);
 882                 GC.KeepAlive(msg);
 883                 if (ret >= 0 && ret <= 4096) { return null; }
 884                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 885                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 886                 return ret_hu_conv;
 887         }
 888
 889         /**
 890          * Utility method to constructs a new SendSpliceInit-variant MessageSendEvent
 891          */
 892         public static MessageSendEvent send_splice_init(byte[] node_id, org.ldk.structs.SpliceInit msg) {
 893                 long ret = bindings.MessageSendEvent_send_splice_init(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 894                 GC.KeepAlive(node_id);
 895                 GC.KeepAlive(msg);
 896                 if (ret >= 0 && ret <= 4096) { return null; }
 897                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 898                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 899                 return ret_hu_conv;
 900         }
 901
 902         /**
 903          * Utility method to constructs a new SendSpliceAck-variant MessageSendEvent
 904          */
 905         public static MessageSendEvent send_splice_ack(byte[] node_id, org.ldk.structs.SpliceAck msg) {
 906                 long ret = bindings.MessageSendEvent_send_splice_ack(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 907                 GC.KeepAlive(node_id);
 908                 GC.KeepAlive(msg);
 909                 if (ret >= 0 && ret <= 4096) { return null; }
 910                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 911                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 912                 return ret_hu_conv;
 913         }
 914
 915         /**
 916          * Utility method to constructs a new SendSpliceLocked-variant MessageSendEvent
 917          */
 918         public static MessageSendEvent send_splice_locked(byte[] node_id, org.ldk.structs.SpliceLocked msg) {
 919                 long ret = bindings.MessageSendEvent_send_splice_locked(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 920                 GC.KeepAlive(node_id);
 921                 GC.KeepAlive(msg);
 922                 if (ret >= 0 && ret <= 4096) { return null; }
 923                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 924                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 925                 return ret_hu_conv;
 926         }
 927
 928         /**
 929          * Utility method to constructs a new SendTxAddInput-variant MessageSendEvent
 930          */
 931         public static MessageSendEvent send_tx_add_input(byte[] node_id, org.ldk.structs.TxAddInput msg) {
 932                 long ret = bindings.MessageSendEvent_send_tx_add_input(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 933                 GC.KeepAlive(node_id);
 934                 GC.KeepAlive(msg);
 935                 if (ret >= 0 && ret <= 4096) { return null; }
 936                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 937                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 938                 return ret_hu_conv;
 939         }
 940
 941         /**
 942          * Utility method to constructs a new SendTxAddOutput-variant MessageSendEvent
 943          */
 944         public static MessageSendEvent send_tx_add_output(byte[] node_id, org.ldk.structs.TxAddOutput msg) {
 945                 long ret = bindings.MessageSendEvent_send_tx_add_output(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 946                 GC.KeepAlive(node_id);
 947                 GC.KeepAlive(msg);
 948                 if (ret >= 0 && ret <= 4096) { return null; }
 949                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 950                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 951                 return ret_hu_conv;
 952         }
 953
 954         /**
 955          * Utility method to constructs a new SendTxRemoveInput-variant MessageSendEvent
 956          */
 957         public static MessageSendEvent send_tx_remove_input(byte[] node_id, org.ldk.structs.TxRemoveInput msg) {
 958                 long ret = bindings.MessageSendEvent_send_tx_remove_input(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 959                 GC.KeepAlive(node_id);
 960                 GC.KeepAlive(msg);
 961                 if (ret >= 0 && ret <= 4096) { return null; }
 962                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 963                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 964                 return ret_hu_conv;
 965         }
 966
 967         /**
 968          * Utility method to constructs a new SendTxRemoveOutput-variant MessageSendEvent
 969          */
 970         public static MessageSendEvent send_tx_remove_output(byte[] node_id, org.ldk.structs.TxRemoveOutput msg) {
 971                 long ret = bindings.MessageSendEvent_send_tx_remove_output(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 972                 GC.KeepAlive(node_id);
 973                 GC.KeepAlive(msg);
 974                 if (ret >= 0 && ret <= 4096) { return null; }
 975                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 976                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 977                 return ret_hu_conv;
 978         }
 979
 980         /**
 981          * Utility method to constructs a new SendTxComplete-variant MessageSendEvent
 982          */
 983         public static MessageSendEvent send_tx_complete(byte[] node_id, org.ldk.structs.TxComplete msg) {
 984                 long ret = bindings.MessageSendEvent_send_tx_complete(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 985                 GC.KeepAlive(node_id);
 986                 GC.KeepAlive(msg);
 987                 if (ret >= 0 && ret <= 4096) { return null; }
 988                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
 989                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 990                 return ret_hu_conv;
 991         }
 992
 993         /**
 994          * Utility method to constructs a new SendTxSignatures-variant MessageSendEvent
 995          */
 996         public static MessageSendEvent send_tx_signatures(byte[] node_id, org.ldk.structs.TxSignatures msg) {
 997                 long ret = bindings.MessageSendEvent_send_tx_signatures(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
 998                 GC.KeepAlive(node_id);
 999                 GC.KeepAlive(msg);
1000                 if (ret >= 0 && ret <= 4096) { return null; }
1001                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1002                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1003                 return ret_hu_conv;
1004         }
1005
1006         /**
1007          * Utility method to constructs a new SendTxInitRbf-variant MessageSendEvent
1008          */
1009         public static MessageSendEvent send_tx_init_rbf(byte[] node_id, org.ldk.structs.TxInitRbf msg) {
1010                 long ret = bindings.MessageSendEvent_send_tx_init_rbf(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1011                 GC.KeepAlive(node_id);
1012                 GC.KeepAlive(msg);
1013                 if (ret >= 0 && ret <= 4096) { return null; }
1014                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1015                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1016                 return ret_hu_conv;
1017         }
1018
1019         /**
1020          * Utility method to constructs a new SendTxAckRbf-variant MessageSendEvent
1021          */
1022         public static MessageSendEvent send_tx_ack_rbf(byte[] node_id, org.ldk.structs.TxAckRbf msg) {
1023                 long ret = bindings.MessageSendEvent_send_tx_ack_rbf(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1024                 GC.KeepAlive(node_id);
1025                 GC.KeepAlive(msg);
1026                 if (ret >= 0 && ret <= 4096) { return null; }
1027                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1028                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1029                 return ret_hu_conv;
1030         }
1031
1032         /**
1033          * Utility method to constructs a new SendTxAbort-variant MessageSendEvent
1034          */
1035         public static MessageSendEvent send_tx_abort(byte[] node_id, org.ldk.structs.TxAbort msg) {
1036                 long ret = bindings.MessageSendEvent_send_tx_abort(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1037                 GC.KeepAlive(node_id);
1038                 GC.KeepAlive(msg);
1039                 if (ret >= 0 && ret <= 4096) { return null; }
1040                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1041                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1042                 return ret_hu_conv;
1043         }
1044
1045         /**
1046          * Utility method to constructs a new SendChannelReady-variant MessageSendEvent
1047          */
1048         public static MessageSendEvent send_channel_ready(byte[] node_id, org.ldk.structs.ChannelReady msg) {
1049                 long ret = bindings.MessageSendEvent_send_channel_ready(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1050                 GC.KeepAlive(node_id);
1051                 GC.KeepAlive(msg);
1052                 if (ret >= 0 && ret <= 4096) { return null; }
1053                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1054                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1055                 return ret_hu_conv;
1056         }
1057
1058         /**
1059          * Utility method to constructs a new SendAnnouncementSignatures-variant MessageSendEvent
1060          */
1061         public static MessageSendEvent send_announcement_signatures(byte[] node_id, org.ldk.structs.AnnouncementSignatures msg) {
1062                 long ret = bindings.MessageSendEvent_send_announcement_signatures(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1063                 GC.KeepAlive(node_id);
1064                 GC.KeepAlive(msg);
1065                 if (ret >= 0 && ret <= 4096) { return null; }
1066                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1067                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1068                 return ret_hu_conv;
1069         }
1070
1071         /**
1072          * Utility method to constructs a new UpdateHTLCs-variant MessageSendEvent
1073          */
1074         public static MessageSendEvent update_htlcs(byte[] node_id, org.ldk.structs.CommitmentUpdate updates) {
1075                 long ret = bindings.MessageSendEvent_update_htlcs(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), updates.ptr);
1076                 GC.KeepAlive(node_id);
1077                 GC.KeepAlive(updates);
1078                 if (ret >= 0 && ret <= 4096) { return null; }
1079                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1080                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1081                 return ret_hu_conv;
1082         }
1083
1084         /**
1085          * Utility method to constructs a new SendRevokeAndACK-variant MessageSendEvent
1086          */
1087         public static MessageSendEvent send_revoke_and_ack(byte[] node_id, org.ldk.structs.RevokeAndACK msg) {
1088                 long ret = bindings.MessageSendEvent_send_revoke_and_ack(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1089                 GC.KeepAlive(node_id);
1090                 GC.KeepAlive(msg);
1091                 if (ret >= 0 && ret <= 4096) { return null; }
1092                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1093                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1094                 return ret_hu_conv;
1095         }
1096
1097         /**
1098          * Utility method to constructs a new SendClosingSigned-variant MessageSendEvent
1099          */
1100         public static MessageSendEvent send_closing_signed(byte[] node_id, org.ldk.structs.ClosingSigned msg) {
1101                 long ret = bindings.MessageSendEvent_send_closing_signed(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1102                 GC.KeepAlive(node_id);
1103                 GC.KeepAlive(msg);
1104                 if (ret >= 0 && ret <= 4096) { return null; }
1105                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1106                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1107                 return ret_hu_conv;
1108         }
1109
1110         /**
1111          * Utility method to constructs a new SendShutdown-variant MessageSendEvent
1112          */
1113         public static MessageSendEvent send_shutdown(byte[] node_id, org.ldk.structs.Shutdown msg) {
1114                 long ret = bindings.MessageSendEvent_send_shutdown(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1115                 GC.KeepAlive(node_id);
1116                 GC.KeepAlive(msg);
1117                 if (ret >= 0 && ret <= 4096) { return null; }
1118                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1119                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1120                 return ret_hu_conv;
1121         }
1122
1123         /**
1124          * Utility method to constructs a new SendChannelReestablish-variant MessageSendEvent
1125          */
1126         public static MessageSendEvent send_channel_reestablish(byte[] node_id, org.ldk.structs.ChannelReestablish msg) {
1127                 long ret = bindings.MessageSendEvent_send_channel_reestablish(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1128                 GC.KeepAlive(node_id);
1129                 GC.KeepAlive(msg);
1130                 if (ret >= 0 && ret <= 4096) { return null; }
1131                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1132                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1133                 return ret_hu_conv;
1134         }
1135
1136         /**
1137          * Utility method to constructs a new SendChannelAnnouncement-variant MessageSendEvent
1138          */
1139         public static MessageSendEvent send_channel_announcement(byte[] node_id, org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.ChannelUpdate update_msg) {
1140                 long ret = bindings.MessageSendEvent_send_channel_announcement(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr, update_msg.ptr);
1141                 GC.KeepAlive(node_id);
1142                 GC.KeepAlive(msg);
1143                 GC.KeepAlive(update_msg);
1144                 if (ret >= 0 && ret <= 4096) { return null; }
1145                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1146                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1147                 return ret_hu_conv;
1148         }
1149
1150         /**
1151          * Utility method to constructs a new BroadcastChannelAnnouncement-variant MessageSendEvent
1152          */
1153         public static MessageSendEvent broadcast_channel_announcement(org.ldk.structs.ChannelAnnouncement msg, org.ldk.structs.ChannelUpdate update_msg) {
1154                 long ret = bindings.MessageSendEvent_broadcast_channel_announcement(msg.ptr, update_msg.ptr);
1155                 GC.KeepAlive(msg);
1156                 GC.KeepAlive(update_msg);
1157                 if (ret >= 0 && ret <= 4096) { return null; }
1158                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1159                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1160                 return ret_hu_conv;
1161         }
1162
1163         /**
1164          * Utility method to constructs a new BroadcastChannelUpdate-variant MessageSendEvent
1165          */
1166         public static MessageSendEvent broadcast_channel_update(org.ldk.structs.ChannelUpdate msg) {
1167                 long ret = bindings.MessageSendEvent_broadcast_channel_update(msg.ptr);
1168                 GC.KeepAlive(msg);
1169                 if (ret >= 0 && ret <= 4096) { return null; }
1170                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1171                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1172                 return ret_hu_conv;
1173         }
1174
1175         /**
1176          * Utility method to constructs a new BroadcastNodeAnnouncement-variant MessageSendEvent
1177          */
1178         public static MessageSendEvent broadcast_node_announcement(org.ldk.structs.NodeAnnouncement msg) {
1179                 long ret = bindings.MessageSendEvent_broadcast_node_announcement(msg.ptr);
1180                 GC.KeepAlive(msg);
1181                 if (ret >= 0 && ret <= 4096) { return null; }
1182                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1183                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1184                 return ret_hu_conv;
1185         }
1186
1187         /**
1188          * Utility method to constructs a new SendChannelUpdate-variant MessageSendEvent
1189          */
1190         public static MessageSendEvent send_channel_update(byte[] node_id, org.ldk.structs.ChannelUpdate msg) {
1191                 long ret = bindings.MessageSendEvent_send_channel_update(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1192                 GC.KeepAlive(node_id);
1193                 GC.KeepAlive(msg);
1194                 if (ret >= 0 && ret <= 4096) { return null; }
1195                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1196                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1197                 return ret_hu_conv;
1198         }
1199
1200         /**
1201          * Utility method to constructs a new HandleError-variant MessageSendEvent
1202          */
1203         public static MessageSendEvent handle_error(byte[] node_id, org.ldk.structs.ErrorAction action) {
1204                 long ret = bindings.MessageSendEvent_handle_error(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), action.ptr);
1205                 GC.KeepAlive(node_id);
1206                 GC.KeepAlive(action);
1207                 if (ret >= 0 && ret <= 4096) { return null; }
1208                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1209                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1210                 return ret_hu_conv;
1211         }
1212
1213         /**
1214          * Utility method to constructs a new SendChannelRangeQuery-variant MessageSendEvent
1215          */
1216         public static MessageSendEvent send_channel_range_query(byte[] node_id, org.ldk.structs.QueryChannelRange msg) {
1217                 long ret = bindings.MessageSendEvent_send_channel_range_query(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1218                 GC.KeepAlive(node_id);
1219                 GC.KeepAlive(msg);
1220                 if (ret >= 0 && ret <= 4096) { return null; }
1221                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1222                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1223                 return ret_hu_conv;
1224         }
1225
1226         /**
1227          * Utility method to constructs a new SendShortIdsQuery-variant MessageSendEvent
1228          */
1229         public static MessageSendEvent send_short_ids_query(byte[] node_id, org.ldk.structs.QueryShortChannelIds msg) {
1230                 long ret = bindings.MessageSendEvent_send_short_ids_query(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1231                 GC.KeepAlive(node_id);
1232                 GC.KeepAlive(msg);
1233                 if (ret >= 0 && ret <= 4096) { return null; }
1234                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1235                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1236                 return ret_hu_conv;
1237         }
1238
1239         /**
1240          * Utility method to constructs a new SendReplyChannelRange-variant MessageSendEvent
1241          */
1242         public static MessageSendEvent send_reply_channel_range(byte[] node_id, org.ldk.structs.ReplyChannelRange msg) {
1243                 long ret = bindings.MessageSendEvent_send_reply_channel_range(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1244                 GC.KeepAlive(node_id);
1245                 GC.KeepAlive(msg);
1246                 if (ret >= 0 && ret <= 4096) { return null; }
1247                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1248                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1249                 return ret_hu_conv;
1250         }
1251
1252         /**
1253          * Utility method to constructs a new SendGossipTimestampFilter-variant MessageSendEvent
1254          */
1255         public static MessageSendEvent send_gossip_timestamp_filter(byte[] node_id, org.ldk.structs.GossipTimestampFilter msg) {
1256                 long ret = bindings.MessageSendEvent_send_gossip_timestamp_filter(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(node_id, 33)), msg.ptr);
1257                 GC.KeepAlive(node_id);
1258                 GC.KeepAlive(msg);
1259                 if (ret >= 0 && ret <= 4096) { return null; }
1260                 org.ldk.structs.MessageSendEvent ret_hu_conv = org.ldk.structs.MessageSendEvent.constr_from_ptr(ret);
1261                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
1262                 return ret_hu_conv;
1263         }
1264
1265 }
1266 } } }