]> git.bitcoin.ninja Git - ldk-java/blob - c_sharp/src/org/ldk/structs/MessageSendEvent.cs
Update CI references to LDK 0.0.124 drop stale memchr pins
[ldk-java] / 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 } } }