_ 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                                 result: Uint8Array = InternalUtils.check_arr_len(ret, 33);
  38                                 return result;
  39                                                 },
  40
  41                                                 first_hops (): number[] {
  42                                                         ChannelDetails[] ret = arg.first_hops();
  43                                 result: number[] = ret != null ? Arrays.stream(ret).map(ret_conv_16 -> ret_conv_16 == null ? 0 : ret_conv_16.clone_ptr()).toArray(number[]::new) : null;
  44                                 return result;
  45                                                 },
  46
  47                                                 send_payment (route: number, payment_hash: Uint8Array, payment_secret: Uint8Array): number {
  48                                                         const route_hu_conv: Route = new Route(null, route);
  49                                                         Result_PaymentIdPaymentSendFailureZ ret = arg.send_payment(route_hu_conv, payment_hash, payment_secret);
  50                                 result: number = ret == null ? 0 : ret.clone_ptr();
  51                                 return result;
  52                                                 },
  53
  54                                                 retry_payment (route: number, payment_id: Uint8Array): number {
  55                                                         const route_hu_conv: Route = new Route(null, route);
  56                                                         Result_NonePaymentSendFailureZ ret = arg.retry_payment(route_hu_conv, payment_id);
  57                                 result: number = ret == null ? 0 : ret.clone_ptr();
  58                                 return result;
  59                                                 },
  60
  61
  62                     };
  63                     impl_holder.held = new Payer (null, structImplementation);
  64                 }
  65             }
  66
  67             export interface PayerInterface {
  68                 node_id(): Uint8Array;
  69                                 first_hops(): ChannelDetails[];
  70                                 send_payment(route: Route, payment_hash: Uint8Array, payment_secret: Uint8Array): Result_PaymentIdPaymentSendFailureZ;
  71                                 retry_payment(route: Route, payment_id: Uint8Array): Result_NonePaymentSendFailureZ;
  72
  73             }
  74
  75             class LDKPayerHolder {
  76                 held: Payer;
  77             }
  78         public Uint8Array node_id() {
  79                 Uint8Array ret = bindings.Payer_node_id(this.ptr);
  80                 return ret;
  81         }
  82
  83         public ChannelDetails[] first_hops() {
  84                 number[] ret = bindings.Payer_first_hops(this.ptr);
  85                 ChannelDetails[] ret_conv_16_arr = new ChannelDetails[ret.length];
  86                 for (int q = 0; q < ret.length; q++) {
  87                         number ret_conv_16 = ret[q];
  88                         const ret_conv_16_hu_conv: ChannelDetails = new ChannelDetails(null, ret_conv_16);
  89                         ret_conv_16_hu_conv.ptrs_to.add(this);
  90                         ret_conv_16_arr[q] = ret_conv_16_hu_conv;
  91                 }
  92                 return ret_conv_16_arr;
  93         }
  94
  95         public Result_PaymentIdPaymentSendFailureZ send_payment(Route route, Uint8Array payment_hash, Uint8Array payment_secret) {
  96                 number ret = bindings.Payer_send_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_hash, 32), InternalUtils.check_arr_len(payment_secret, 32));
  97                 Result_PaymentIdPaymentSendFailureZ ret_hu_conv = Result_PaymentIdPaymentSendFailureZ.constr_from_ptr(ret);
  98                 this.ptrs_to.add(route);
  99                 return ret_hu_conv;
 100         }
 101
 102         public Result_NonePaymentSendFailureZ retry_payment(Route route, Uint8Array payment_id) {
 103                 number ret = bindings.Payer_retry_payment(this.ptr, route == null ? 0 : route.ptr & ~1, InternalUtils.check_arr_len(payment_id, 32));
 104                 Result_NonePaymentSendFailureZ ret_hu_conv = Result_NonePaymentSendFailureZ.constr_from_ptr(ret);
 105                 this.ptrs_to.add(route);
 106                 return ret_hu_conv;
 107         }
 108
 109 }