_ 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 MessageSendEvent clone() {
 302                 number ret = bindings.MessageSendEvent_clone(this.ptr);
 303                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 304                 ret_hu_conv.ptrs_to.add(this);
 305                 return ret_hu_conv;
 306         }
 307
 308         public static MessageSendEvent constructor_send_accept_channel(Uint8Array node_id, AcceptChannel msg) {
 309                 number ret = bindings.MessageSendEvent_send_accept_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
 310                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 311                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 312                 ret_hu_conv.ptrs_to.add(msg);
 313                 return ret_hu_conv;
 314         }
 315
 316         public static MessageSendEvent constructor_send_open_channel(Uint8Array node_id, OpenChannel msg) {
 317                 number ret = bindings.MessageSendEvent_send_open_channel(node_id, msg == null ? 0 : msg.ptr & ~1);
 318                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 319                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 320                 ret_hu_conv.ptrs_to.add(msg);
 321                 return ret_hu_conv;
 322         }
 323
 324         public static MessageSendEvent constructor_send_funding_created(Uint8Array node_id, FundingCreated msg) {
 325                 number ret = bindings.MessageSendEvent_send_funding_created(node_id, msg == null ? 0 : msg.ptr & ~1);
 326                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 327                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 328                 ret_hu_conv.ptrs_to.add(msg);
 329                 return ret_hu_conv;
 330         }
 331
 332         public static MessageSendEvent constructor_send_funding_signed(Uint8Array node_id, FundingSigned msg) {
 333                 number ret = bindings.MessageSendEvent_send_funding_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
 334                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 335                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 336                 ret_hu_conv.ptrs_to.add(msg);
 337                 return ret_hu_conv;
 338         }
 339
 340         public static MessageSendEvent constructor_send_funding_locked(Uint8Array node_id, FundingLocked msg) {
 341                 number ret = bindings.MessageSendEvent_send_funding_locked(node_id, msg == null ? 0 : msg.ptr & ~1);
 342                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 343                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 344                 ret_hu_conv.ptrs_to.add(msg);
 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(node_id, 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                 ret_hu_conv.ptrs_to.add(msg);
 353                 return ret_hu_conv;
 354         }
 355
 356         public static MessageSendEvent constructor_update_htlcs(Uint8Array node_id, CommitmentUpdate updates) {
 357                 number ret = bindings.MessageSendEvent_update_htlcs(node_id, updates == null ? 0 : updates.ptr & ~1);
 358                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 359                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 360                 ret_hu_conv.ptrs_to.add(updates);
 361                 return ret_hu_conv;
 362         }
 363
 364         public static MessageSendEvent constructor_send_revoke_and_ack(Uint8Array node_id, RevokeAndACK msg) {
 365                 number ret = bindings.MessageSendEvent_send_revoke_and_ack(node_id, msg == null ? 0 : msg.ptr & ~1);
 366                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 367                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 368                 ret_hu_conv.ptrs_to.add(msg);
 369                 return ret_hu_conv;
 370         }
 371
 372         public static MessageSendEvent constructor_send_closing_signed(Uint8Array node_id, ClosingSigned msg) {
 373                 number ret = bindings.MessageSendEvent_send_closing_signed(node_id, msg == null ? 0 : msg.ptr & ~1);
 374                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 375                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 376                 ret_hu_conv.ptrs_to.add(msg);
 377                 return ret_hu_conv;
 378         }
 379
 380         public static MessageSendEvent constructor_send_shutdown(Uint8Array node_id, Shutdown msg) {
 381                 number ret = bindings.MessageSendEvent_send_shutdown(node_id, msg == null ? 0 : msg.ptr & ~1);
 382                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 383                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 384                 ret_hu_conv.ptrs_to.add(msg);
 385                 return ret_hu_conv;
 386         }
 387
 388         public static MessageSendEvent constructor_send_channel_reestablish(Uint8Array node_id, ChannelReestablish msg) {
 389                 number ret = bindings.MessageSendEvent_send_channel_reestablish(node_id, msg == null ? 0 : msg.ptr & ~1);
 390                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 391                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 392                 ret_hu_conv.ptrs_to.add(msg);
 393                 return ret_hu_conv;
 394         }
 395
 396         public static MessageSendEvent constructor_broadcast_channel_announcement(ChannelAnnouncement msg, ChannelUpdate update_msg) {
 397                 number ret = bindings.MessageSendEvent_broadcast_channel_announcement(msg == null ? 0 : msg.ptr & ~1, update_msg == null ? 0 : update_msg.ptr & ~1);
 398                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 399                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 400                 ret_hu_conv.ptrs_to.add(msg);
 401                 ret_hu_conv.ptrs_to.add(update_msg);
 402                 return ret_hu_conv;
 403         }
 404
 405         public static MessageSendEvent constructor_broadcast_node_announcement(NodeAnnouncement msg) {
 406                 number ret = bindings.MessageSendEvent_broadcast_node_announcement(msg == null ? 0 : msg.ptr & ~1);
 407                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 408                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 409                 ret_hu_conv.ptrs_to.add(msg);
 410                 return ret_hu_conv;
 411         }
 412
 413         public static MessageSendEvent constructor_broadcast_channel_update(ChannelUpdate msg) {
 414                 number ret = bindings.MessageSendEvent_broadcast_channel_update(msg == null ? 0 : msg.ptr & ~1);
 415                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 416                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 417                 ret_hu_conv.ptrs_to.add(msg);
 418                 return ret_hu_conv;
 419         }
 420
 421         public static MessageSendEvent constructor_send_channel_update(Uint8Array node_id, ChannelUpdate msg) {
 422                 number ret = bindings.MessageSendEvent_send_channel_update(node_id, msg == null ? 0 : msg.ptr & ~1);
 423                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 424                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 425                 ret_hu_conv.ptrs_to.add(msg);
 426                 return ret_hu_conv;
 427         }
 428
 429         public static MessageSendEvent constructor_handle_error(Uint8Array node_id, ErrorAction action) {
 430                 number ret = bindings.MessageSendEvent_handle_error(node_id, action.ptr);
 431                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 432                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 433                 return ret_hu_conv;
 434         }
 435
 436         public static MessageSendEvent constructor_send_channel_range_query(Uint8Array node_id, QueryChannelRange msg) {
 437                 number ret = bindings.MessageSendEvent_send_channel_range_query(node_id, msg == null ? 0 : msg.ptr & ~1);
 438                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 439                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 440                 ret_hu_conv.ptrs_to.add(msg);
 441                 return ret_hu_conv;
 442         }
 443
 444         public static MessageSendEvent constructor_send_short_ids_query(Uint8Array node_id, QueryShortChannelIds msg) {
 445                 number ret = bindings.MessageSendEvent_send_short_ids_query(node_id, msg == null ? 0 : msg.ptr & ~1);
 446                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 447                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 448                 ret_hu_conv.ptrs_to.add(msg);
 449                 return ret_hu_conv;
 450         }
 451
 452         public static MessageSendEvent constructor_send_reply_channel_range(Uint8Array node_id, ReplyChannelRange msg) {
 453                 number ret = bindings.MessageSendEvent_send_reply_channel_range(node_id, msg == null ? 0 : msg.ptr & ~1);
 454                 MessageSendEvent ret_hu_conv = MessageSendEvent.constr_from_ptr(ret);
 455                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 456                 ret_hu_conv.ptrs_to.add(msg);
 457                 return ret_hu_conv;
 458         }
 459
 460 }