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