_ Git - ldk-java/blob - c_sharp/src/org/ldk/structs/RecentPaymentDetails.cs

   1 using org.ldk.impl;
   2 using org.ldk.enums;
   3 using org.ldk.util;
   4 using System;
   5
   6 namespace org { namespace ldk { namespace structs {
   7
   8 /**
   9  * Used by [`ChannelManager::list_recent_payments`] to express the status of recent payments.
  10  * These include payments that have yet to find a successful path, or have unresolved HTLCs.
  11  */
  12 public class RecentPaymentDetails : CommonBase {
  13         protected RecentPaymentDetails(object _dummy, long ptr) : base(ptr) { }
  14         ~RecentPaymentDetails() {
  15                 if (ptr != 0) { bindings.RecentPaymentDetails_free(ptr); }
  16         }
  17
  18         internal static RecentPaymentDetails constr_from_ptr(long ptr) {
  19                 long raw_ty = bindings.LDKRecentPaymentDetails_ty_from_ptr(ptr);
  20                 switch (raw_ty) {
  21                         case 0: return new RecentPaymentDetails_AwaitingInvoice(ptr);
  22                         case 1: return new RecentPaymentDetails_Pending(ptr);
  23                         case 2: return new RecentPaymentDetails_Fulfilled(ptr);
  24                         case 3: return new RecentPaymentDetails_Abandoned(ptr);
  25                         default:
  26                                 throw new ArgumentException("Impossible enum variant");
  27                 }
  28         }
  29
  30         /** A RecentPaymentDetails of type AwaitingInvoice */
  31         public class RecentPaymentDetails_AwaitingInvoice : RecentPaymentDetails {
  32                 /**
  33                  * A user-provided identifier in [`ChannelManager::send_payment`] used to uniquely identify
  34                  * a payment and ensure idempotency in LDK.
  35                  */
  36                 public byte[] payment_id;
  37                 internal RecentPaymentDetails_AwaitingInvoice(long ptr) : base(null, ptr) {
  38                         long payment_id = bindings.LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(ptr);
  39                         byte[] payment_id_conv = InternalUtils.decodeUint8Array(payment_id);
  40                         this.payment_id = payment_id_conv;
  41                 }
  42         }
  43         /** A RecentPaymentDetails of type Pending */
  44         public class RecentPaymentDetails_Pending : RecentPaymentDetails {
  45                 /**
  46                  * A user-provided identifier in [`ChannelManager::send_payment`] used to uniquely identify
  47                  * a payment and ensure idempotency in LDK.
  48                  */
  49                 public byte[] payment_id;
  50                 /**
  51                  * Hash of the payment that is currently being sent but has yet to be fulfilled or
  52                  * abandoned.
  53                  */
  54                 public byte[] payment_hash;
  55                 /**
  56                  * Total amount (in msat, excluding fees) across all paths for this payment,
  57                  * not just the amount currently inflight.
  58                  */
  59                 public long total_msat;
  60                 internal RecentPaymentDetails_Pending(long ptr) : base(null, ptr) {
  61                         long payment_id = bindings.LDKRecentPaymentDetails_Pending_get_payment_id(ptr);
  62                         byte[] payment_id_conv = InternalUtils.decodeUint8Array(payment_id);
  63                         this.payment_id = payment_id_conv;
  64                         long payment_hash = bindings.LDKRecentPaymentDetails_Pending_get_payment_hash(ptr);
  65                         byte[] payment_hash_conv = InternalUtils.decodeUint8Array(payment_hash);
  66                         this.payment_hash = payment_hash_conv;
  67                         this.total_msat = bindings.LDKRecentPaymentDetails_Pending_get_total_msat(ptr);
  68                 }
  69         }
  70         /** A RecentPaymentDetails of type Fulfilled */
  71         public class RecentPaymentDetails_Fulfilled : RecentPaymentDetails {
  72                 /**
  73                  * A user-provided identifier in [`ChannelManager::send_payment`] used to uniquely identify
  74                  * a payment and ensure idempotency in LDK.
  75                  */
  76                 public byte[] payment_id;
  77                 /**
  78                  * Hash of the payment that was claimed. `None` for serializations of [`ChannelManager`]
  79                  * made before LDK version 0.0.104.
  80                  */
  81                 public Option_ThirtyTwoBytesZ payment_hash;
  82                 internal RecentPaymentDetails_Fulfilled(long ptr) : base(null, ptr) {
  83                         long payment_id = bindings.LDKRecentPaymentDetails_Fulfilled_get_payment_id(ptr);
  84                         byte[] payment_id_conv = InternalUtils.decodeUint8Array(payment_id);
  85                         this.payment_id = payment_id_conv;
  86                         long payment_hash = bindings.LDKRecentPaymentDetails_Fulfilled_get_payment_hash(ptr);
  87                         org.ldk.structs.Option_ThirtyTwoBytesZ payment_hash_hu_conv = org.ldk.structs.Option_ThirtyTwoBytesZ.constr_from_ptr(payment_hash);
  88                         if (payment_hash_hu_conv != null) { payment_hash_hu_conv.ptrs_to.AddLast(this); };
  89                         this.payment_hash = payment_hash_hu_conv;
  90                 }
  91         }
  92         /** A RecentPaymentDetails of type Abandoned */
  93         public class RecentPaymentDetails_Abandoned : RecentPaymentDetails {
  94                 /**
  95                  * A user-provided identifier in [`ChannelManager::send_payment`] used to uniquely identify
  96                  * a payment and ensure idempotency in LDK.
  97                  */
  98                 public byte[] payment_id;
  99                 /**
 100                  * Hash of the payment that we have given up trying to send.
 101                  */
 102                 public byte[] payment_hash;
 103                 internal RecentPaymentDetails_Abandoned(long ptr) : base(null, ptr) {
 104                         long payment_id = bindings.LDKRecentPaymentDetails_Abandoned_get_payment_id(ptr);
 105                         byte[] payment_id_conv = InternalUtils.decodeUint8Array(payment_id);
 106                         this.payment_id = payment_id_conv;
 107                         long payment_hash = bindings.LDKRecentPaymentDetails_Abandoned_get_payment_hash(ptr);
 108                         byte[] payment_hash_conv = InternalUtils.decodeUint8Array(payment_hash);
 109                         this.payment_hash = payment_hash_conv;
 110                 }
 111         }
 112         internal long clone_ptr() {
 113                 long ret = bindings.RecentPaymentDetails_clone_ptr(this.ptr);
 114                 GC.KeepAlive(this);
 115                 return ret;
 116         }
 117
 118         /**
 119          * Creates a copy of the RecentPaymentDetails
 120          */
 121         public RecentPaymentDetails clone() {
 122                 long ret = bindings.RecentPaymentDetails_clone(this.ptr);
 123                 GC.KeepAlive(this);
 124                 if (ret >= 0 && ret <= 4096) { return null; }
 125                 org.ldk.structs.RecentPaymentDetails ret_hu_conv = org.ldk.structs.RecentPaymentDetails.constr_from_ptr(ret);
 126                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
 127                 return ret_hu_conv;
 128         }
 129
 130         /**
 131          * Utility method to constructs a new AwaitingInvoice-variant RecentPaymentDetails
 132          */
 133         public static RecentPaymentDetails awaiting_invoice(byte[] payment_id) {
 134                 long ret = bindings.RecentPaymentDetails_awaiting_invoice(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_id, 32)));
 135                 GC.KeepAlive(payment_id);
 136                 if (ret >= 0 && ret <= 4096) { return null; }
 137                 org.ldk.structs.RecentPaymentDetails ret_hu_conv = org.ldk.structs.RecentPaymentDetails.constr_from_ptr(ret);
 138                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 139                 return ret_hu_conv;
 140         }
 141
 142         /**
 143          * Utility method to constructs a new Pending-variant RecentPaymentDetails
 144          */
 145         public static RecentPaymentDetails pending(byte[] payment_id, byte[] payment_hash, long total_msat) {
 146                 long ret = bindings.RecentPaymentDetails_pending(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_id, 32)), InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_hash, 32)), total_msat);
 147                 GC.KeepAlive(payment_id);
 148                 GC.KeepAlive(payment_hash);
 149                 GC.KeepAlive(total_msat);
 150                 if (ret >= 0 && ret <= 4096) { return null; }
 151                 org.ldk.structs.RecentPaymentDetails ret_hu_conv = org.ldk.structs.RecentPaymentDetails.constr_from_ptr(ret);
 152                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 153                 return ret_hu_conv;
 154         }
 155
 156         /**
 157          * Utility method to constructs a new Fulfilled-variant RecentPaymentDetails
 158          */
 159         public static RecentPaymentDetails fulfilled(byte[] payment_id, org.ldk.structs.Option_ThirtyTwoBytesZ payment_hash) {
 160                 long ret = bindings.RecentPaymentDetails_fulfilled(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_id, 32)), payment_hash.ptr);
 161                 GC.KeepAlive(payment_id);
 162                 GC.KeepAlive(payment_hash);
 163                 if (ret >= 0 && ret <= 4096) { return null; }
 164                 org.ldk.structs.RecentPaymentDetails ret_hu_conv = org.ldk.structs.RecentPaymentDetails.constr_from_ptr(ret);
 165                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 166                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(payment_hash); };
 167                 return ret_hu_conv;
 168         }
 169
 170         /**
 171          * Utility method to constructs a new Abandoned-variant RecentPaymentDetails
 172          */
 173         public static RecentPaymentDetails abandoned(byte[] payment_id, byte[] payment_hash) {
 174                 long ret = bindings.RecentPaymentDetails_abandoned(InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_id, 32)), InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(payment_hash, 32)));
 175                 GC.KeepAlive(payment_id);
 176                 GC.KeepAlive(payment_hash);
 177                 if (ret >= 0 && ret <= 4096) { return null; }
 178                 org.ldk.structs.RecentPaymentDetails ret_hu_conv = org.ldk.structs.RecentPaymentDetails.constr_from_ptr(ret);
 179                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
 180                 return ret_hu_conv;
 181         }
 182
 183 }
 184 } } }