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

   1
   2 import CommonBase from './CommonBase';
   3 import * as bindings from '../bindings' // TODO: figure out location
   4
   5 export default class Event extends CommonBase {
   6         protected constructor(_dummy: object, ptr: number) { super(ptr); }
   7         protected finalize() {
   8                 super.finalize();
   9                 if (this.ptr != 0) { bindings.Event_free(this.ptr); }
  10         }
  11         static constr_from_ptr(ptr: number): Event {
  12                 const raw_val: bindings.LDKEvent = bindings.LDKEvent_ref_from_ptr(ptr);
  13                 if (raw_val instanceof bindings.LDKEvent.FundingGenerationReady) {
  14                         return new FundingGenerationReady(this.ptr, raw_val);
  15                 }
  16                 if (raw_val instanceof bindings.LDKEvent.PaymentReceived) {
  17                         return new PaymentReceived(this.ptr, raw_val);
  18                 }
  19                 if (raw_val instanceof bindings.LDKEvent.PaymentSent) {
  20                         return new PaymentSent(this.ptr, raw_val);
  21                 }
  22                 if (raw_val instanceof bindings.LDKEvent.PaymentPathFailed) {
  23                         return new PaymentPathFailed(this.ptr, raw_val);
  24                 }
  25                 if (raw_val instanceof bindings.LDKEvent.PaymentFailed) {
  26                         return new PaymentFailed(this.ptr, raw_val);
  27                 }
  28                 if (raw_val instanceof bindings.LDKEvent.PendingHTLCsForwardable) {
  29                         return new PendingHTLCsForwardable(this.ptr, raw_val);
  30                 }
  31                 if (raw_val instanceof bindings.LDKEvent.SpendableOutputs) {
  32                         return new SpendableOutputs(this.ptr, raw_val);
  33                 }
  34                 if (raw_val instanceof bindings.LDKEvent.PaymentForwarded) {
  35                         return new PaymentForwarded(this.ptr, raw_val);
  36                 }
  37                 if (raw_val instanceof bindings.LDKEvent.ChannelClosed) {
  38                         return new ChannelClosed(this.ptr, raw_val);
  39                 }
  40                 if (raw_val instanceof bindings.LDKEvent.DiscardFunding) {
  41                         return new DiscardFunding(this.ptr, raw_val);
  42                 }
  43                 if (raw_val instanceof bindings.LDKEvent.PaymentPathSuccessful) {
  44                         return new PaymentPathSuccessful(this.ptr, raw_val);
  45                 }
  46                 throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
  47         }
  48
  49 }
  50 export class FundingGenerationReady extends Event {
  51         public temporary_channel_id: Uint8Array;
  52         public channel_value_satoshis: number;
  53         public output_script: Uint8Array;
  54         public user_channel_id: number;
  55         private constructor(ptr: number, obj: bindings.LDKEvent.FundingGenerationReady) {
  56                 super(null, ptr);
  57                 this.temporary_channel_id = obj.temporary_channel_id;
  58                 this.channel_value_satoshis = obj.channel_value_satoshis;
  59                 this.output_script = obj.output_script;
  60                 this.user_channel_id = obj.user_channel_id;
  61         }
  62 }
  63 export class PaymentReceived extends Event {
  64         public payment_hash: Uint8Array;
  65         public amt: number;
  66         public purpose: PaymentPurpose;
  67         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentReceived) {
  68                 super(null, ptr);
  69                 this.payment_hash = obj.payment_hash;
  70                 this.amt = obj.amt;
  71                 const purpose: number = obj.purpose;
  72                 PaymentPurpose purpose_hu_conv = PaymentPurpose.constr_from_ptr(purpose);
  73                         purpose_hu_conv.ptrs_to.add(this);
  74                 this.purpose = purpose_hu_conv;
  75         }
  76 }
  77 export class PaymentSent extends Event {
  78         public payment_id: Uint8Array;
  79         public payment_preimage: Uint8Array;
  80         public payment_hash: Uint8Array;
  81         public fee_paid_msat: Option_u64Z;
  82         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentSent) {
  83                 super(null, ptr);
  84                 this.payment_id = obj.payment_id;
  85                 this.payment_preimage = obj.payment_preimage;
  86                 this.payment_hash = obj.payment_hash;
  87                 const fee_paid_msat: number = obj.fee_paid_msat;
  88                 Option_u64Z fee_paid_msat_hu_conv = Option_u64Z.constr_from_ptr(fee_paid_msat);
  89                         fee_paid_msat_hu_conv.ptrs_to.add(this);
  90                 this.fee_paid_msat = fee_paid_msat_hu_conv;
  91         }
  92 }
  93 export class PaymentPathFailed extends Event {
  94         public payment_id: Uint8Array;
  95         public payment_hash: Uint8Array;
  96         public rejected_by_dest: boolean;
  97         public network_update: Option_NetworkUpdateZ;
  98         public all_paths_failed: boolean;
  99         public path: RouteHop[];
 100         public short_channel_id: Option_u64Z;
 101         public retry: RouteParameters;
 102         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentPathFailed) {
 103                 super(null, ptr);
 104                 this.payment_id = obj.payment_id;
 105                 this.payment_hash = obj.payment_hash;
 106                 this.rejected_by_dest = obj.rejected_by_dest;
 107                 const network_update: number = obj.network_update;
 108                 Option_NetworkUpdateZ network_update_hu_conv = Option_NetworkUpdateZ.constr_from_ptr(network_update);
 109                         network_update_hu_conv.ptrs_to.add(this);
 110                 this.network_update = network_update_hu_conv;
 111                 this.all_paths_failed = obj.all_paths_failed;
 112                 const path: number[] = obj.path;
 113                 RouteHop[] path_conv_10_arr = new RouteHop[path.length];
 114                         for (int k = 0; k < path.length; k++) {
 115                                 number path_conv_10 = path[k];
 116                                 const path_conv_10_hu_conv: RouteHop = new RouteHop(null, path_conv_10);
 117                                 path_conv_10_hu_conv.ptrs_to.add(this);
 118                                 path_conv_10_arr[k] = path_conv_10_hu_conv;
 119                         }
 120                 this.path = path_conv_10_arr;
 121                 const short_channel_id: number = obj.short_channel_id;
 122                 Option_u64Z short_channel_id_hu_conv = Option_u64Z.constr_from_ptr(short_channel_id);
 123                         short_channel_id_hu_conv.ptrs_to.add(this);
 124                 this.short_channel_id = short_channel_id_hu_conv;
 125                 const retry: number = obj.retry;
 126                 const retry_hu_conv: RouteParameters = new RouteParameters(null, retry);
 127                         retry_hu_conv.ptrs_to.add(this);
 128                 this.retry = retry_hu_conv;
 129         }
 130 }
 131 export class PaymentFailed extends Event {
 132         public payment_id: Uint8Array;
 133         public payment_hash: Uint8Array;
 134         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentFailed) {
 135                 super(null, ptr);
 136                 this.payment_id = obj.payment_id;
 137                 this.payment_hash = obj.payment_hash;
 138         }
 139 }
 140 export class PendingHTLCsForwardable extends Event {
 141         public time_forwardable: number;
 142         private constructor(ptr: number, obj: bindings.LDKEvent.PendingHTLCsForwardable) {
 143                 super(null, ptr);
 144                 this.time_forwardable = obj.time_forwardable;
 145         }
 146 }
 147 export class SpendableOutputs extends Event {
 148         public outputs: SpendableOutputDescriptor[];
 149         private constructor(ptr: number, obj: bindings.LDKEvent.SpendableOutputs) {
 150                 super(null, ptr);
 151                 const outputs: number[] = obj.outputs;
 152                 SpendableOutputDescriptor[] outputs_conv_27_arr = new SpendableOutputDescriptor[outputs.length];
 153                         for (int b = 0; b < outputs.length; b++) {
 154                                 number outputs_conv_27 = outputs[b];
 155                                 SpendableOutputDescriptor outputs_conv_27_hu_conv = SpendableOutputDescriptor.constr_from_ptr(outputs_conv_27);
 156                                 outputs_conv_27_hu_conv.ptrs_to.add(this);
 157                                 outputs_conv_27_arr[b] = outputs_conv_27_hu_conv;
 158                         }
 159                 this.outputs = outputs_conv_27_arr;
 160         }
 161 }
 162 export class PaymentForwarded extends Event {
 163         public fee_earned_msat: Option_u64Z;
 164         public claim_from_onchain_tx: boolean;
 165         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentForwarded) {
 166                 super(null, ptr);
 167                 const fee_earned_msat: number = obj.fee_earned_msat;
 168                 Option_u64Z fee_earned_msat_hu_conv = Option_u64Z.constr_from_ptr(fee_earned_msat);
 169                         fee_earned_msat_hu_conv.ptrs_to.add(this);
 170                 this.fee_earned_msat = fee_earned_msat_hu_conv;
 171                 this.claim_from_onchain_tx = obj.claim_from_onchain_tx;
 172         }
 173 }
 174 export class ChannelClosed extends Event {
 175         public channel_id: Uint8Array;
 176         public user_channel_id: number;
 177         public reason: ClosureReason;
 178         private constructor(ptr: number, obj: bindings.LDKEvent.ChannelClosed) {
 179                 super(null, ptr);
 180                 this.channel_id = obj.channel_id;
 181                 this.user_channel_id = obj.user_channel_id;
 182                 const reason: number = obj.reason;
 183                 ClosureReason reason_hu_conv = ClosureReason.constr_from_ptr(reason);
 184                         reason_hu_conv.ptrs_to.add(this);
 185                 this.reason = reason_hu_conv;
 186         }
 187 }
 188 export class DiscardFunding extends Event {
 189         public channel_id: Uint8Array;
 190         public transaction: Uint8Array;
 191         private constructor(ptr: number, obj: bindings.LDKEvent.DiscardFunding) {
 192                 super(null, ptr);
 193                 this.channel_id = obj.channel_id;
 194                 this.transaction = obj.transaction;
 195         }
 196 }
 197 export class PaymentPathSuccessful extends Event {
 198         public payment_id: Uint8Array;
 199         public payment_hash: Uint8Array;
 200         public path: RouteHop[];
 201         private constructor(ptr: number, obj: bindings.LDKEvent.PaymentPathSuccessful) {
 202                 super(null, ptr);
 203                 this.payment_id = obj.payment_id;
 204                 this.payment_hash = obj.payment_hash;
 205                 const path: number[] = obj.path;
 206                 RouteHop[] path_conv_10_arr = new RouteHop[path.length];
 207                         for (int k = 0; k < path.length; k++) {
 208                                 number path_conv_10 = path[k];
 209                                 const path_conv_10_hu_conv: RouteHop = new RouteHop(null, path_conv_10);
 210                                 path_conv_10_hu_conv.ptrs_to.add(this);
 211                                 path_conv_10_arr[k] = path_conv_10_hu_conv;
 212                         }
 213                 this.path = path_conv_10_arr;
 214         }
 215 }
 216         public number clone_ptr() {
 217                 number ret = bindings.Event_clone_ptr(this.ptr);
 218                 return ret;
 219         }
 220
 221         public Event clone() {
 222                 number ret = bindings.Event_clone(this.ptr);
 223                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 224                 ret_hu_conv.ptrs_to.add(this);
 225                 return ret_hu_conv;
 226         }
 227
 228         public static Event constructor_funding_generation_ready(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) {
 229                 number ret = bindings.Event_funding_generation_ready(InternalUtils.check_arr_len(temporary_channel_id, 32), channel_value_satoshis, output_script, user_channel_id);
 230                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 231                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 232                 return ret_hu_conv;
 233         }
 234
 235         public static Event constructor_payment_received(Uint8Array payment_hash, number amt, PaymentPurpose purpose) {
 236                 number ret = bindings.Event_payment_received(InternalUtils.check_arr_len(payment_hash, 32), amt, purpose.ptr);
 237                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 238                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 239                 return ret_hu_conv;
 240         }
 241
 242         public static Event constructor_payment_sent(Uint8Array payment_id, Uint8Array payment_preimage, Uint8Array payment_hash, Option_u64Z fee_paid_msat) {
 243                 number ret = bindings.Event_payment_sent(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_preimage, 32), InternalUtils.check_arr_len(payment_hash, 32), fee_paid_msat.ptr);
 244                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 245                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 246                 return ret_hu_conv;
 247         }
 248
 249         public static Event constructor_payment_path_failed(Uint8Array payment_id, Uint8Array payment_hash, boolean rejected_by_dest, Option_NetworkUpdateZ network_update, boolean all_paths_failed, RouteHop[] path, Option_u64Z short_channel_id, RouteParameters retry) {
 250                 number ret = bindings.Event_payment_path_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), rejected_by_dest, network_update.ptr, all_paths_failed, path != null ? Arrays.stream(path).map(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray(number[]::new) : null, short_channel_id.ptr, retry == null ? 0 : retry.ptr & ~1);
 251                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 252                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 253                 return ret_hu_conv;
 254         }
 255
 256         public static Event constructor_payment_failed(Uint8Array payment_id, Uint8Array payment_hash) {
 257                 number ret = bindings.Event_payment_failed(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32));
 258                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 259                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 260                 return ret_hu_conv;
 261         }
 262
 263         public static Event constructor_pending_htlcs_forwardable(number time_forwardable) {
 264                 number ret = bindings.Event_pending_htlcs_forwardable(time_forwardable);
 265                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 266                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 267                 return ret_hu_conv;
 268         }
 269
 270         public static Event constructor_spendable_outputs(SpendableOutputDescriptor[] outputs) {
 271                 number ret = bindings.Event_spendable_outputs(outputs != null ? Arrays.stream(outputs).map(outputs_conv_27 -> outputs_conv_27.ptr).toArray(number[]::new) : null);
 272                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 273                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 274                 return ret_hu_conv;
 275         }
 276
 277         public static Event constructor_payment_forwarded(Option_u64Z fee_earned_msat, boolean claim_from_onchain_tx) {
 278                 number ret = bindings.Event_payment_forwarded(fee_earned_msat.ptr, claim_from_onchain_tx);
 279                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 280                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 281                 return ret_hu_conv;
 282         }
 283
 284         public static Event constructor_channel_closed(Uint8Array channel_id, number user_channel_id, ClosureReason reason) {
 285                 number ret = bindings.Event_channel_closed(InternalUtils.check_arr_len(channel_id, 32), user_channel_id, reason.ptr);
 286                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 287                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 288                 return ret_hu_conv;
 289         }
 290
 291         public static Event constructor_discard_funding(Uint8Array channel_id, Uint8Array transaction) {
 292                 number ret = bindings.Event_discard_funding(InternalUtils.check_arr_len(channel_id, 32), transaction);
 293                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 294                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 295                 return ret_hu_conv;
 296         }
 297
 298         public static Event constructor_payment_path_successful(Uint8Array payment_id, Uint8Array payment_hash, RouteHop[] path) {
 299                 number ret = bindings.Event_payment_path_successful(InternalUtils.check_arr_len(payment_id, 32), InternalUtils.check_arr_len(payment_hash, 32), path != null ? Arrays.stream(path).map(path_conv_10 -> path_conv_10 == null ? 0 : path_conv_10.ptr & ~1).toArray(number[]::new) : null);
 300                 Event ret_hu_conv = Event.constr_from_ptr(ret);
 301                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 302                 return ret_hu_conv;
 303         }
 304
 305         public Uint8Array write() {
 306                 Uint8Array ret = bindings.Event_write(this.ptr);
 307                 return ret;
 308         }
 309
 310 }