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

   1
   2
   3 import CommonBase from './CommonBase';
   4 import * as bindings from '../bindings' // TODO: figure out location
   5
   6
   7
   8             export class Payer extends CommonBase {
   9
  10                 bindings_instance?: bindings.LDKPayer;
  11
  12                 constructor(ptr?: number, arg?: bindings.LDKPayer) {
  13                     if (Number.isFinite(ptr)) {
  14                                         super(ptr);
  15                                         this.bindings_instance = null;
  16                                     } else {
  17                                         // TODO: private constructor instantiation
  18                                         super(bindings.LDKPayer_new(arg));
  19                                         this.ptrs_to.push(arg);
  20
  21                                     }
  22                 }
  23
  24                 protected finalize() {
  25                     if (this.ptr != 0) {
  26                         bindings.Payer_free(this.ptr);
  27                     }
  28                     super.finalize();
  29                 }
  30
  31                 static new_impl(arg: PayerInterface): Payer {
  32                     const impl_holder: LDKPayerHolder = new LDKPayerHolder();
  33                     let structImplementation = <bindings.LDKPayer>{
  34                         // todo: in-line interface filling
  35                         node_id (): Uint8Array {
  36                                                         Uint8Array ret = arg.node_id();
  37                                 return ret;
  38                                                 },
  39
  40                                                 first_hops (): number[] {
  41                                                         ChannelDetails[] ret = arg.first_hops();
  42                                 result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.ptr & ~1).toArray(number[]::new) : null;
  43                                 return result;
  44                                                 },
  45
  46                                                 send_payment (route: number, payment_hash: Uint8Array, payment_secret: Uint8Array): number {
  47                                                         const route_hu_conv: Route = new Route(null, route);
  48                                                         Result_PaymentIdPaymentSendFailureZ ret = arg.send_payment(route_hu_conv, payment_hash, payment_secret);
  49                                 result: number = ret != null ? ret.ptr : 0;
  50                                 return result;
  51                                                 },
  52
  53                                                 retry_payment (route: number, payment_id: Uint8Array): number {
  54                                                         const route_hu_conv: Route = new Route(null, route);
  55                                                         Result_NonePaymentSendFailureZ ret = arg.retry_payment(route_hu_conv, payment_id);
  56                                 result: number = ret != null ? ret.ptr : 0;
  57                                 return result;
  58                                                 },
  59
  60
  61                     };
  62                     impl_holder.held = new Payer (null, structImplementation);
  63                 }
  64             }
  65
  66             export interface PayerInterface {
  67                 node_id(): Uint8Array;
  68                                 first_hops(): ChannelDetails[];
  69                                 send_payment(route: Route, payment_hash: Uint8Array, payment_secret: Uint8Array): Result_PaymentIdPaymentSendFailureZ;
  70                                 retry_payment(route: Route, payment_id: Uint8Array): Result_NonePaymentSendFailureZ;
  71
  72             }
  73
  74             class LDKPayerHolder {
  75                 held: Payer;
  76             }
  77         public Uint8Array node_id() {
  78                 Uint8Array ret = bindings.Payer_node_id(this.ptr);
  79                 return ret;
  80         }
  81
  82         public ChannelDetails[] first_hops() {
  83                 number[] ret = bindings.Payer_first_hops(this.ptr);
  84                 ChannelDetails[] ret_conv_16_arr = new ChannelDetails[ret.length];
  85                 for (int q = 0; q < ret.length; q++) {
  86                         number ret_conv_16 = ret[q];
  87                         const ret_conv_16_hu_conv: ChannelDetails = new ChannelDetails(null, ret_conv_16);
  88                         ret_conv_16_hu_conv.ptrs_to.add(this);
  89                         ret_conv_16_arr[q] = ret_conv_16_hu_conv;
  90                 }
  91                 return ret_conv_16_arr;
  92         }
  93
  94         public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, Uint8Array payment_hash, Uint8Array payment_secret) {
  95                 number ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_hash, payment_secret);
  96                 Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
  97                 this.ptrs_to.add(route);
  98                 return ret_hu_conv;
  99         }
 100
 101         public Result_NonePaymentSendFailureZ retry_payment(Route route, Uint8Array payment_id) {
 102                 number ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, payment_id);
 103                 Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
 104                 this.ptrs_to.add(route);
 105                 return ret_hu_conv;
 106         }
 107
 108 }