_ Git - ldk-java/blob - ts/structs/MessageSendEvent.ts

   1
   2 import CommonBase from './CommonBase';
   3 import * as bindings from '../bindings' // TODO: figure out location
   4
   5 export default class MessageSendEvent extends CommonBase {
   6         protected constructor(_dummy: object, ptr: number) { super(ptr); }
   7         protected finalize() {
   8                 super.finalize();
   9                 if (this.ptr != 0) { bindings.MessageSendEvent_free(this.ptr); }
  10         }
  11         static constr_from_ptr(ptr: number): MessageSendEvent {
  12                 const raw_val: bindings.LDKMessageSendEvent = bindings.LDKMessageSendEvent_ref_from_ptr(ptr);
  13                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendAcceptChannel) {
  14                         return new SendAcceptChannel(this.ptr, raw_val);
  15                 }
  16                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendOpenChannel) {
  17                         return new SendOpenChannel(this.ptr, raw_val);
  18                 }
  19                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendFundingCreated) {
  20                         return new SendFundingCreated(this.ptr, raw_val);
  21                 }
  22                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendFundingSigned) {
  23                         return new SendFundingSigned(this.ptr, raw_val);
  24                 }
  25                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendFundingLocked) {
  26                         return new SendFundingLocked(this.ptr, raw_val);
  27                 }
  28                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendAnnouncementSignatures) {
  29                         return new SendAnnouncementSignatures(this.ptr, raw_val);
  30                 }
  31                 if (raw_val instanceof bindings.LDKMessageSendEvent.UpdateHTLCs) {
  32                         return new UpdateHTLCs(this.ptr, raw_val);
  33                 }
  34                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendRevokeAndACK) {
  35                         return new SendRevokeAndACK(this.ptr, raw_val);
  36                 }
  37                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendClosingSigned) {
  38                         return new SendClosingSigned(this.ptr, raw_val);
  39                 }
  40                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendShutdown) {
  41                         return new SendShutdown(this.ptr, raw_val);
  42                 }
  43                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendChannelReestablish) {
  44                         return new SendChannelReestablish(this.ptr, raw_val);
  45                 }
  46                 if (raw_val instanceof bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement) {
  47                         return new BroadcastChannelAnnouncement(this.ptr, raw_val);
  48                 }
  49                 if (raw_val instanceof bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement) {
  50                         return new BroadcastNodeAnnouncement(this.ptr, raw_val);
  51                 }
  52                 if (raw_val instanceof bindings.LDKMessageSendEvent.BroadcastChannelUpdate) {
  53                         return new BroadcastChannelUpdate(this.ptr, raw_val);
  54                 }
  55                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendChannelUpdate) {
  56                         return new SendChannelUpdate(this.ptr, raw_val);
  57                 }
  58                 if (raw_val instanceof bindings.LDKMessageSendEvent.HandleError) {
  59                         return new HandleError(this.ptr, raw_val);
  60                 }
  61                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendChannelRangeQuery) {
  62                         return new SendChannelRangeQuery(this.ptr, raw_val);
  63                 }
  64                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendShortIdsQuery) {
  65                         return new SendShortIdsQuery(this.ptr, raw_val);
  66                 }
  67                 if (raw_val instanceof bindings.LDKMessageSendEvent.SendReplyChannelRange) {
  68                         return new SendReplyChannelRange(this.ptr, raw_val);
  69                 }
  70                 throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
  71         }
  72
  73 }
  74 export class SendAcceptChannel extends MessageSendEvent {
  75         public node_id: Uint8Array;
  76         public msg: AcceptChannel;
  77         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendAcceptChannel) {
  78                 super(null, ptr);
  79                 this.node_id = obj.node_id;
  80                 const msg: number = obj.msg;
  81                 const msg_hu_conv: AcceptChannel = new AcceptChannel(null, msg);
  82                         msg_hu_conv.ptrs_to.add(this);
  83                 this.msg = msg_hu_conv;
  84         }
  85 }
  86 export class SendOpenChannel extends MessageSendEvent {
  87         public node_id: Uint8Array;
  88         public msg: OpenChannel;
  89         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendOpenChannel) {
  90                 super(null, ptr);
  91                 this.node_id = obj.node_id;
  92                 const msg: number = obj.msg;
  93                 const msg_hu_conv: OpenChannel = new OpenChannel(null, msg);
  94                         msg_hu_conv.ptrs_to.add(this);
  95                 this.msg = msg_hu_conv;
  96         }
  97 }
  98 export class SendFundingCreated extends MessageSendEvent {
  99         public node_id: Uint8Array;
 100         public msg: FundingCreated;
 101         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendFundingCreated) {
 102                 super(null, ptr);
 103                 this.node_id = obj.node_id;
 104                 const msg: number = obj.msg;
 105                 const msg_hu_conv: FundingCreated = new FundingCreated(null, msg);
 106                         msg_hu_conv.ptrs_to.add(this);
 107                 this.msg = msg_hu_conv;
 108         }
 109 }
 110 export class SendFundingSigned extends MessageSendEvent {
 111         public node_id: Uint8Array;
 112         public msg: FundingSigned;
 113         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendFundingSigned) {
 114                 super(null, ptr);
 115                 this.node_id = obj.node_id;
 116                 const msg: number = obj.msg;
 117                 const msg_hu_conv: FundingSigned = new FundingSigned(null, msg);
 118                         msg_hu_conv.ptrs_to.add(this);
 119                 this.msg = msg_hu_conv;
 120         }
 121 }
 122 export class SendFundingLocked extends MessageSendEvent {
 123         public node_id: Uint8Array;
 124         public msg: FundingLocked;
 125         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendFundingLocked) {
 126                 super(null, ptr);
 127                 this.node_id = obj.node_id;
 128                 const msg: number = obj.msg;
 129                 const msg_hu_conv: FundingLocked = new FundingLocked(null, msg);
 130                         msg_hu_conv.ptrs_to.add(this);
 131                 this.msg = msg_hu_conv;
 132         }
 133 }
 134 export class SendAnnouncementSignatures extends MessageSendEvent {
 135         public node_id: Uint8Array;
 136         public msg: AnnouncementSignatures;
 137         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendAnnouncementSignatures) {
 138                 super(null, ptr);
 139                 this.node_id = obj.node_id;
 140                 const msg: number = obj.msg;
 141                 const msg_hu_conv: AnnouncementSignatures = new AnnouncementSignatures(null, msg);
 142                         msg_hu_conv.ptrs_to.add(this);
 143                 this.msg = msg_hu_conv;
 144         }
 145 }
 146 export class UpdateHTLCs extends MessageSendEvent {
 147         public node_id: Uint8Array;
 148         public updates: CommitmentUpdate;
 149         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.UpdateHTLCs) {
 150                 super(null, ptr);
 151                 this.node_id = obj.node_id;
 152                 const updates: number = obj.updates;
 153                 const updates_hu_conv: CommitmentUpdate = new CommitmentUpdate(null, updates);
 154                         updates_hu_conv.ptrs_to.add(this);
 155                 this.updates = updates_hu_conv;
 156         }
 157 }
 158 export class SendRevokeAndACK extends MessageSendEvent {
 159         public node_id: Uint8Array;
 160         public msg: RevokeAndACK;
 161         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendRevokeAndACK) {
 162                 super(null, ptr);
 163                 this.node_id = obj.node_id;
 164                 const msg: number = obj.msg;
 165                 const msg_hu_conv: RevokeAndACK = new RevokeAndACK(null, msg);
 166                         msg_hu_conv.ptrs_to.add(this);
 167                 this.msg = msg_hu_conv;
 168         }
 169 }
 170 export class SendClosingSigned extends MessageSendEvent {
 171         public node_id: Uint8Array;
 172         public msg: ClosingSigned;
 173         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendClosingSigned) {
 174                 super(null, ptr);
 175                 this.node_id = obj.node_id;
 176                 const msg: number = obj.msg;
 177                 const msg_hu_conv: ClosingSigned = new ClosingSigned(null, msg);
 178                         msg_hu_conv.ptrs_to.add(this);
 179                 this.msg = msg_hu_conv;
 180         }
 181 }
 182 export class SendShutdown extends MessageSendEvent {
 183         public node_id: Uint8Array;
 184         public msg: Shutdown;
 185         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendShutdown) {
 186                 super(null, ptr);
 187                 this.node_id = obj.node_id;
 188                 const msg: number = obj.msg;
 189                 const msg_hu_conv: Shutdown = new Shutdown(null, msg);
 190                         msg_hu_conv.ptrs_to.add(this);
 191                 this.msg = msg_hu_conv;
 192         }
 193 }
 194 export class SendChannelReestablish extends MessageSendEvent {
 195         public node_id: Uint8Array;
 196         public msg: ChannelReestablish;
 197         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendChannelReestablish) {
 198                 super(null, ptr);
 199                 this.node_id = obj.node_id;
 200                 const msg: number = obj.msg;
 201                 const msg_hu_conv: ChannelReestablish = new ChannelReestablish(null, msg);
 202                         msg_hu_conv.ptrs_to.add(this);
 203                 this.msg = msg_hu_conv;
 204         }
 205 }
 206 export class BroadcastChannelAnnouncement extends MessageSendEvent {
 207         public msg: ChannelAnnouncement;
 208         public update_msg: ChannelUpdate;
 209         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.BroadcastChannelAnnouncement) {
 210                 super(null, ptr);
 211                 const msg: number = obj.msg;
 212                 const msg_hu_conv: ChannelAnnouncement = new ChannelAnnouncement(null, msg);
 213                         msg_hu_conv.ptrs_to.add(this);
 214                 this.msg = msg_hu_conv;
 215                 const update_msg: number = obj.update_msg;
 216                 const update_msg_hu_conv: ChannelUpdate = new ChannelUpdate(null, update_msg);
 217                         update_msg_hu_conv.ptrs_to.add(this);
 218                 this.update_msg = update_msg_hu_conv;
 219         }
 220 }
 221 export class BroadcastNodeAnnouncement extends MessageSendEvent {
 222         public msg: NodeAnnouncement;
 223         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.BroadcastNodeAnnouncement) {
 224                 super(null, ptr);
 225                 const msg: number = obj.msg;
 226                 const msg_hu_conv: NodeAnnouncement = new NodeAnnouncement(null, msg);
 227                         msg_hu_conv.ptrs_to.add(this);
 228                 this.msg = msg_hu_conv;
 229         }
 230 }
 231 export class BroadcastChannelUpdate extends MessageSendEvent {
 232         public msg: ChannelUpdate;
 233         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.BroadcastChannelUpdate) {
 234                 super(null, ptr);
 235                 const msg: number = obj.msg;
 236                 const msg_hu_conv: ChannelUpdate = new ChannelUpdate(null, msg);
 237                         msg_hu_conv.ptrs_to.add(this);
 238                 this.msg = msg_hu_conv;
 239         }
 240 }
 241 export class SendChannelUpdate extends MessageSendEvent {
 242         public node_id: Uint8Array;
 243         public msg: ChannelUpdate;
 244         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendChannelUpdate) {
 245                 super(null, ptr);
 246                 this.node_id = obj.node_id;
 247                 const msg: number = obj.msg;
 248                 const msg_hu_conv: ChannelUpdate = new ChannelUpdate(null, msg);
 249                         msg_hu_conv.ptrs_to.add(this);
 250                 this.msg = msg_hu_conv;
 251         }
 252 }
 253 export class HandleError extends MessageSendEvent {
 254         public node_id: Uint8Array;
 255         public action: ErrorAction;
 256         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.HandleError) {
 257                 super(null, ptr);
 258                 this.node_id = obj.node_id;
 259                 const action: number = obj.action;
 260                 ErrorAction action_hu_conv = ErrorAction.constr_from_ptr(action);
 261                         action_hu_conv.ptrs_to.add(this);
 262                 this.action = action_hu_conv;
 263         }
 264 }
 265 export class SendChannelRangeQuery extends MessageSendEvent {
 266         public node_id: Uint8Array;
 267         public msg: QueryChannelRange;
 268         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendChannelRangeQuery) {
 269                 super(null, ptr);
 270                 this.node_id = obj.node_id;
 271                 const msg: number = obj.msg;
 272                 const msg_hu_conv: QueryChannelRange = new QueryChannelRange(null, msg);
 273                         msg_hu_conv.ptrs_to.add(this);
 274                 this.msg = msg_hu_conv;
 275         }
 276 }
 277 export class SendShortIdsQuery extends MessageSendEvent {
 278         public node_id: Uint8Array;
 279         public msg: QueryShortChannelIds;
 280         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendShortIdsQuery) {
 281                 super(null, ptr);
 282                 this.node_id = obj.node_id;
 283                 const msg: number = obj.msg;
 284                 const msg_hu_conv: QueryShortChannelIds = new QueryShortChannelIds(null, msg);
 285                         msg_hu_conv.ptrs_to.add(this);
 286                 this.msg = msg_hu_conv;
 287         }
 288 }
 289 export class SendReplyChannelRange extends MessageSendEvent {
 290         public node_id: Uint8Array;
 291         public msg: ReplyChannelRange;
 292         private constructor(ptr: number, obj: bindings.LDKMessageSendEvent.SendReplyChannelRange) {
 293                 super(null, ptr);
 294                 this.node_id = obj.node_id;
 295                 const msg: number = obj.msg;
 296                 const msg_hu_conv: ReplyChannelRange = new ReplyChannelRange(null, msg);
 297                         msg_hu_conv.ptrs_to.add(this);
 298                 this.msg = msg_hu_conv;
 299         }
 300 }
 301         public number clone_ptr() {
 302                 number ret = bindings.MessageSendEvent_clone_ptr(this.ptr);
 303                 return ret;
 304         }
 305
 306         public MessageSendEvent clone() {
 307                 number ret = bindings.MessageSendEvent_clone(this.ptr);
 308                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 309                 ret_hu_conv.ptrs_to.add(this);
 310                 return ret_hu_conv;
 311         }
 312
 313         public static MessageSendEvent constructor_send_accept_channel(Uint8Array node_id, AcceptChannel msg) {
 314                 number ret = bindings.MessageSendEvent_send_accept_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 315                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 316                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 317                 return ret_hu_conv;
 318         }
 319
 320         public static MessageSendEvent constructor_send_open_channel(Uint8Array node_id, OpenChannel msg) {
 321                 number ret = bindings.MessageSendEvent_send_open_channel(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 322                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 323                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 324                 return ret_hu_conv;
 325         }
 326
 327         public static MessageSendEvent constructor_send_funding_created(Uint8Array node_id, FundingCreated msg) {
 328                 number ret = bindings.MessageSendEvent_send_funding_created(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 329                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 330                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 331                 return ret_hu_conv;
 332         }
 333
 334         public static MessageSendEvent constructor_send_funding_signed(Uint8Array node_id, FundingSigned msg) {
 335                 number ret = bindings.MessageSendEvent_send_funding_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 336                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 337                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 338                 return ret_hu_conv;
 339         }
 340
 341         public static MessageSendEvent constructor_send_funding_locked(Uint8Array node_id, FundingLocked msg) {
 342                 number ret = bindings.MessageSendEvent_send_funding_locked(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 343                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 344                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 345                 return ret_hu_conv;
 346         }
 347
 348         public static MessageSendEvent constructor_send_announcement_signatures(Uint8Array node_id, AnnouncementSignatures msg) {
 349                 number ret = bindings.MessageSendEvent_send_announcement_signatures(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 350                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 351                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 352                 return ret_hu_conv;
 353         }
 354
 355         public static MessageSendEvent constructor_update_htlcs(Uint8Array node_id, CommitmentUpdate updates) {
 356                 number ret = bindings.MessageSendEvent_update_htlcs(InternalUtils.check_arr_len(node_id, 33), updates == null ? 0 : updates.ptr & ~1);
 357                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 358                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 359                 return ret_hu_conv;
 360         }
 361
 362         public static MessageSendEvent constructor_send_revoke_and_ack(Uint8Array node_id, RevokeAndACK msg) {
 363                 number ret = bindings.MessageSendEvent_send_revoke_and_ack(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 364                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 365                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 366                 return ret_hu_conv;
 367         }
 368
 369         public static MessageSendEvent constructor_send_closing_signed(Uint8Array node_id, ClosingSigned msg) {
 370                 number ret = bindings.MessageSendEvent_send_closing_signed(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 371                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 372                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 373                 return ret_hu_conv;
 374         }
 375
 376         public static MessageSendEvent constructor_send_shutdown(Uint8Array node_id, Shutdown msg) {
 377                 number ret = bindings.MessageSendEvent_send_shutdown(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 378                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 379                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 380                 return ret_hu_conv;
 381         }
 382
 383         public static MessageSendEvent constructor_send_channel_reestablish(Uint8Array node_id, ChannelReestablish msg) {
 384                 number ret = bindings.MessageSendEvent_send_channel_reestablish(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 385                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 386                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 387                 return ret_hu_conv;
 388         }
 389
 390         public static MessageSendEvent constructor_broadcast_channel_announcement(ChannelAnnouncement msg, ChannelUpdate update_msg) {
 391                 number ret = bindings.MessageSendEvent_broadcast_channel_announcement(msg == null ? 0 : msg.ptr & ~1, update_msg == null ? 0 : update_msg.ptr & ~1);
 392                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 393                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 394                 return ret_hu_conv;
 395         }
 396
 397         public static MessageSendEvent constructor_broadcast_node_announcement(NodeAnnouncement msg) {
 398                 number ret = bindings.MessageSendEvent_broadcast_node_announcement(msg == null ? 0 : msg.ptr & ~1);
 399                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 400                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 401                 return ret_hu_conv;
 402         }
 403
 404         public static MessageSendEvent constructor_broadcast_channel_update(ChannelUpdate msg) {
 405                 number ret = bindings.MessageSendEvent_broadcast_channel_update(msg == null ? 0 : msg.ptr & ~1);
 406                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 407                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 408                 return ret_hu_conv;
 409         }
 410
 411         public static MessageSendEvent constructor_send_channel_update(Uint8Array node_id, ChannelUpdate msg) {
 412                 number ret = bindings.MessageSendEvent_send_channel_update(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 413                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 414                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 415                 return ret_hu_conv;
 416         }
 417
 418         public static MessageSendEvent constructor_handle_error(Uint8Array node_id, ErrorAction action) {
 419                 number ret = bindings.MessageSendEvent_handle_error(InternalUtils.check_arr_len(node_id, 33), action.ptr);
 420                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 421                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 422                 return ret_hu_conv;
 423         }
 424
 425         public static MessageSendEvent constructor_send_channel_range_query(Uint8Array node_id, QueryChannelRange msg) {
 426                 number ret = bindings.MessageSendEvent_send_channel_range_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 427                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 428                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 429                 return ret_hu_conv;
 430         }
 431
 432         public static MessageSendEvent constructor_send_short_ids_query(Uint8Array node_id, QueryShortChannelIds msg) {
 433                 number ret = bindings.MessageSendEvent_send_short_ids_query(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 434                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 435                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 436                 return ret_hu_conv;
 437         }
 438
 439         public static MessageSendEvent constructor_send_reply_channel_range(Uint8Array node_id, ReplyChannelRange msg) {
 440                 number ret = bindings.MessageSendEvent_send_reply_channel_range(InternalUtils.check_arr_len(node_id, 33), msg == null ? 0 : msg.ptr & ~1);
 441                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 442                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 443                 return ret_hu_conv;
 444         }
 445
 446 }