6 namespace org { namespace ldk { namespace structs {
9 * The reason the channel was closed. See individual variants for more details.
11 public class ClosureReason : CommonBase {
12 protected ClosureReason(object _dummy, long ptr) : base(ptr) { }
14 if (ptr != 0) { bindings.ClosureReason_free(ptr); }
17 internal static ClosureReason constr_from_ptr(long ptr) {
18 long raw_ty = bindings.LDKClosureReason_ty_from_ptr(ptr);
20 case 0: return new ClosureReason_CounterpartyForceClosed(ptr);
21 case 1: return new ClosureReason_HolderForceClosed(ptr);
22 case 2: return new ClosureReason_LegacyCooperativeClosure(ptr);
23 case 3: return new ClosureReason_CounterpartyInitiatedCooperativeClosure(ptr);
24 case 4: return new ClosureReason_LocallyInitiatedCooperativeClosure(ptr);
25 case 5: return new ClosureReason_CommitmentTxConfirmed(ptr);
26 case 6: return new ClosureReason_FundingTimedOut(ptr);
27 case 7: return new ClosureReason_ProcessingError(ptr);
28 case 8: return new ClosureReason_DisconnectedPeer(ptr);
29 case 9: return new ClosureReason_OutdatedChannelManager(ptr);
30 case 10: return new ClosureReason_CounterpartyCoopClosedUnfundedChannel(ptr);
31 case 11: return new ClosureReason_FundingBatchClosure(ptr);
32 case 12: return new ClosureReason_HTLCsTimedOut(ptr);
34 throw new ArgumentException("Impossible enum variant");
38 /** A ClosureReason of type CounterpartyForceClosed */
39 public class ClosureReason_CounterpartyForceClosed : ClosureReason {
41 * The error which the peer sent us.
43 * Be careful about printing the peer_msg, a well-crafted message could exploit
44 * a security vulnerability in the terminal emulator or the logging subsystem.
45 * To be safe, use `Display` on `UntrustedString`
47 * [`UntrustedString`]: crate::util::string::UntrustedString
49 public UntrustedString peer_msg;
50 internal ClosureReason_CounterpartyForceClosed(long ptr) : base(null, ptr) {
51 long peer_msg = bindings.LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
52 org.ldk.structs.UntrustedString peer_msg_hu_conv = null; if (peer_msg < 0 || peer_msg > 4096) { peer_msg_hu_conv = new org.ldk.structs.UntrustedString(null, peer_msg); }
53 if (peer_msg_hu_conv != null) { peer_msg_hu_conv.ptrs_to.AddLast(this); };
54 this.peer_msg = peer_msg_hu_conv;
57 /** A ClosureReason of type HolderForceClosed */
58 public class ClosureReason_HolderForceClosed : ClosureReason {
59 internal ClosureReason_HolderForceClosed(long ptr) : base(null, ptr) {
62 /** A ClosureReason of type LegacyCooperativeClosure */
63 public class ClosureReason_LegacyCooperativeClosure : ClosureReason {
64 internal ClosureReason_LegacyCooperativeClosure(long ptr) : base(null, ptr) {
67 /** A ClosureReason of type CounterpartyInitiatedCooperativeClosure */
68 public class ClosureReason_CounterpartyInitiatedCooperativeClosure : ClosureReason {
69 internal ClosureReason_CounterpartyInitiatedCooperativeClosure(long ptr) : base(null, ptr) {
72 /** A ClosureReason of type LocallyInitiatedCooperativeClosure */
73 public class ClosureReason_LocallyInitiatedCooperativeClosure : ClosureReason {
74 internal ClosureReason_LocallyInitiatedCooperativeClosure(long ptr) : base(null, ptr) {
77 /** A ClosureReason of type CommitmentTxConfirmed */
78 public class ClosureReason_CommitmentTxConfirmed : ClosureReason {
79 internal ClosureReason_CommitmentTxConfirmed(long ptr) : base(null, ptr) {
82 /** A ClosureReason of type FundingTimedOut */
83 public class ClosureReason_FundingTimedOut : ClosureReason {
84 internal ClosureReason_FundingTimedOut(long ptr) : base(null, ptr) {
87 /** A ClosureReason of type ProcessingError */
88 public class ClosureReason_ProcessingError : ClosureReason {
90 * A developer-readable error message which we generated.
93 internal ClosureReason_ProcessingError(long ptr) : base(null, ptr) {
94 long err = bindings.LDKClosureReason_ProcessingError_get_err(ptr);
95 string err_conv = InternalUtils.decodeString(err);
99 /** A ClosureReason of type DisconnectedPeer */
100 public class ClosureReason_DisconnectedPeer : ClosureReason {
101 internal ClosureReason_DisconnectedPeer(long ptr) : base(null, ptr) {
104 /** A ClosureReason of type OutdatedChannelManager */
105 public class ClosureReason_OutdatedChannelManager : ClosureReason {
106 internal ClosureReason_OutdatedChannelManager(long ptr) : base(null, ptr) {
109 /** A ClosureReason of type CounterpartyCoopClosedUnfundedChannel */
110 public class ClosureReason_CounterpartyCoopClosedUnfundedChannel : ClosureReason {
111 internal ClosureReason_CounterpartyCoopClosedUnfundedChannel(long ptr) : base(null, ptr) {
114 /** A ClosureReason of type FundingBatchClosure */
115 public class ClosureReason_FundingBatchClosure : ClosureReason {
116 internal ClosureReason_FundingBatchClosure(long ptr) : base(null, ptr) {
119 /** A ClosureReason of type HTLCsTimedOut */
120 public class ClosureReason_HTLCsTimedOut : ClosureReason {
121 internal ClosureReason_HTLCsTimedOut(long ptr) : base(null, ptr) {
124 internal long clone_ptr() {
125 long ret = bindings.ClosureReason_clone_ptr(this.ptr);
131 * Creates a copy of the ClosureReason
133 public ClosureReason clone() {
134 long ret = bindings.ClosureReason_clone(this.ptr);
136 if (ret >= 0 && ret <= 4096) { return null; }
137 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
138 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
143 * Utility method to constructs a new CounterpartyForceClosed-variant ClosureReason
145 public static ClosureReason counterparty_force_closed(org.ldk.structs.UntrustedString peer_msg) {
146 long ret = bindings.ClosureReason_counterparty_force_closed(peer_msg.ptr);
147 GC.KeepAlive(peer_msg);
148 if (ret >= 0 && ret <= 4096) { return null; }
149 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
150 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
151 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(peer_msg); };
156 * Utility method to constructs a new HolderForceClosed-variant ClosureReason
158 public static ClosureReason holder_force_closed() {
159 long ret = bindings.ClosureReason_holder_force_closed();
160 if (ret >= 0 && ret <= 4096) { return null; }
161 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
162 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
167 * Utility method to constructs a new LegacyCooperativeClosure-variant ClosureReason
169 public static ClosureReason legacy_cooperative_closure() {
170 long ret = bindings.ClosureReason_legacy_cooperative_closure();
171 if (ret >= 0 && ret <= 4096) { return null; }
172 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
173 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
178 * Utility method to constructs a new CounterpartyInitiatedCooperativeClosure-variant ClosureReason
180 public static ClosureReason counterparty_initiated_cooperative_closure() {
181 long ret = bindings.ClosureReason_counterparty_initiated_cooperative_closure();
182 if (ret >= 0 && ret <= 4096) { return null; }
183 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
184 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
189 * Utility method to constructs a new LocallyInitiatedCooperativeClosure-variant ClosureReason
191 public static ClosureReason locally_initiated_cooperative_closure() {
192 long ret = bindings.ClosureReason_locally_initiated_cooperative_closure();
193 if (ret >= 0 && ret <= 4096) { return null; }
194 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
195 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
200 * Utility method to constructs a new CommitmentTxConfirmed-variant ClosureReason
202 public static ClosureReason commitment_tx_confirmed() {
203 long ret = bindings.ClosureReason_commitment_tx_confirmed();
204 if (ret >= 0 && ret <= 4096) { return null; }
205 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
206 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
211 * Utility method to constructs a new FundingTimedOut-variant ClosureReason
213 public static ClosureReason funding_timed_out() {
214 long ret = bindings.ClosureReason_funding_timed_out();
215 if (ret >= 0 && ret <= 4096) { return null; }
216 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
217 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
222 * Utility method to constructs a new ProcessingError-variant ClosureReason
224 public static ClosureReason processing_error(string err) {
225 long ret = bindings.ClosureReason_processing_error(InternalUtils.encodeString(err));
227 if (ret >= 0 && ret <= 4096) { return null; }
228 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
229 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
234 * Utility method to constructs a new DisconnectedPeer-variant ClosureReason
236 public static ClosureReason disconnected_peer() {
237 long ret = bindings.ClosureReason_disconnected_peer();
238 if (ret >= 0 && ret <= 4096) { return null; }
239 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
240 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
245 * Utility method to constructs a new OutdatedChannelManager-variant ClosureReason
247 public static ClosureReason outdated_channel_manager() {
248 long ret = bindings.ClosureReason_outdated_channel_manager();
249 if (ret >= 0 && ret <= 4096) { return null; }
250 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
251 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
256 * Utility method to constructs a new CounterpartyCoopClosedUnfundedChannel-variant ClosureReason
258 public static ClosureReason counterparty_coop_closed_unfunded_channel() {
259 long ret = bindings.ClosureReason_counterparty_coop_closed_unfunded_channel();
260 if (ret >= 0 && ret <= 4096) { return null; }
261 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
262 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
267 * Utility method to constructs a new FundingBatchClosure-variant ClosureReason
269 public static ClosureReason funding_batch_closure() {
270 long ret = bindings.ClosureReason_funding_batch_closure();
271 if (ret >= 0 && ret <= 4096) { return null; }
272 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
273 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
278 * Utility method to constructs a new HTLCsTimedOut-variant ClosureReason
280 public static ClosureReason htlcs_timed_out() {
281 long ret = bindings.ClosureReason_htlcs_timed_out();
282 if (ret >= 0 && ret <= 4096) { return null; }
283 org.ldk.structs.ClosureReason ret_hu_conv = org.ldk.structs.ClosureReason.constr_from_ptr(ret);
284 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
289 * Checks if two ClosureReasons contain equal inner contents.
290 * This ignores pointers and is_owned flags and looks at the values in fields.
292 public bool eq(org.ldk.structs.ClosureReason b) {
293 bool ret = bindings.ClosureReason_eq(this.ptr, b.ptr);
299 public override bool Equals(object o) {
300 if (!(o is ClosureReason)) return false;
301 return this.eq((ClosureReason)o);
304 * Serialize the ClosureReason object into a byte array which can be read by ClosureReason_read
306 public byte[] write() {
307 long ret = bindings.ClosureReason_write(this.ptr);
309 if (ret >= 0 && ret <= 4096) { return null; }
310 byte[] ret_conv = InternalUtils.decodeUint8Array(ret);