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

   1
   2
   3 import CommonBase from './CommonBase';
   4 import * as bindings from '../bindings' // TODO: figure out location
   5
   6
   7
   8             export class Watch extends CommonBase {
   9
  10                 bindings_instance?: bindings.LDKWatch;
  11
  12                 constructor(ptr?: number, arg?: bindings.LDKWatch) {
  13                     if (Number.isFinite(ptr)) {
  14                                         super(ptr);
  15                                         this.bindings_instance = null;
  16                                     } else {
  17                                         // TODO: private constructor instantiation
  18                                         super(bindings.LDKWatch_new(arg));
  19                                         this.ptrs_to.push(arg);
  20
  21                                     }
  22                 }
  23
  24                 protected finalize() {
  25                     if (this.ptr != 0) {
  26                         bindings.Watch_free(this.ptr);
  27                     }
  28                     super.finalize();
  29                 }
  30
  31                 static new_impl(arg: WatchInterface): Watch {
  32                     const impl_holder: LDKWatchHolder = new LDKWatchHolder();
  33                     let structImplementation = <bindings.LDKWatch>{
  34                         // todo: in-line interface filling
  35                         watch_channel (funding_txo: number, monitor: number): number {
  36                                                         const funding_txo_hu_conv: OutPoint = new OutPoint(null, funding_txo);
  37                                                         const monitor_hu_conv: ChannelMonitor = new ChannelMonitor(null, monitor);
  38                                                         Result_NoneChannelMonitorUpdateErrZ ret = arg.watch_channel(funding_txo_hu_conv, monitor_hu_conv);
  39                                 result: number = ret != null ? ret.ptr : 0;
  40                                 return result;
  41                                                 },
  42
  43                                                 update_channel (funding_txo: number, update: number): number {
  44                                                         const funding_txo_hu_conv: OutPoint = new OutPoint(null, funding_txo);
  45                                                         const update_hu_conv: ChannelMonitorUpdate = new ChannelMonitorUpdate(null, update);
  46                                                         Result_NoneChannelMonitorUpdateErrZ ret = arg.update_channel(funding_txo_hu_conv, update_hu_conv);
  47                                 result: number = ret != null ? ret.ptr : 0;
  48                                 return result;
  49                                                 },
  50
  51                                                 release_pending_monitor_events (): number[] {
  52                                                         MonitorEvent[] ret = arg.release_pending_monitor_events();
  53                                 result: number[] = (number[])Arrays.stream(ret).map(arr_conv_14 -> arr_conv_14 == null ? 0 : arr_conv_14.ptr & ~1).toArray();
  54                                 /* TODO 2 MonitorEvent  */;
  55                                 return result;
  56                                                 },
  57
  58
  59                     };
  60                     impl_holder.held = new Watch (null, structImplementation);
  61                 }
  62             }
  63
  64             export interface WatchInterface {
  65                 watch_channel(funding_txo: OutPoint, monitor: ChannelMonitor): Result_NoneChannelMonitorUpdateErrZ;
  66                                 update_channel(funding_txo: OutPoint, update: ChannelMonitorUpdate): Result_NoneChannelMonitorUpdateErrZ;
  67                                 release_pending_monitor_events(): MonitorEvent[];
  68
  69             }
  70
  71             class LDKWatchHolder {
  72                 held: Watch;
  73             }
  74         public Result_NoneChannelMonitorUpdateErrZ watch_channel(OutPoint funding_txo, ChannelMonitor monitor) {
  75                 number ret = bindings.Watch_watch_channel(this.ptr, funding_txo == null ? 0 : funding_txo.ptr & ~1, monitor == null ? 0 : monitor.ptr & ~1);
  76                 Result_NoneChannelMonitorUpdateErrZ ret_hu_conv = Result_NoneChannelMonitorUpdateErrZ.constr_from_ptr(ret);
  77                 this.ptrs_to.add(funding_txo);
  78                 this.ptrs_to.add(monitor);
  79                 return ret_hu_conv;
  80         }
  81
  82         public Result_NoneChannelMonitorUpdateErrZ update_channel(OutPoint funding_txo, ChannelMonitorUpdate update) {
  83                 number ret = bindings.Watch_update_channel(this.ptr, funding_txo == null ? 0 : funding_txo.ptr & ~1, update == null ? 0 : update.ptr & ~1);
  84                 Result_NoneChannelMonitorUpdateErrZ ret_hu_conv = Result_NoneChannelMonitorUpdateErrZ.constr_from_ptr(ret);
  85                 this.ptrs_to.add(funding_txo);
  86                 this.ptrs_to.add(update);
  87                 return ret_hu_conv;
  88         }
  89
  90         public MonitorEvent[] release_pending_monitor_events() {
  91                 number[] ret = bindings.Watch_release_pending_monitor_events(this.ptr);
  92                 MonitorEvent[] arr_conv_14_arr = new MonitorEvent[ret.length];
  93                 for (int o = 0; o < ret.length; o++) {
  94                         number arr_conv_14 = ret[o];
  95                         const arr_conv_14_hu_conv: MonitorEvent = new MonitorEvent(null, arr_conv_14);
  96                         arr_conv_14_arr[o] = arr_conv_14_hu_conv;
  97                 }
  98                 return arr_conv_14_arr;
  99         }
 100
 101 }