6 namespace org { namespace ldk { namespace structs {
9 * Represents the different types of transactions, originating from LDK, to be bumped.
11 public class BumpTransactionEvent : CommonBase {
12 protected BumpTransactionEvent(object _dummy, long ptr) : base(ptr) { }
13 ~BumpTransactionEvent() {
14 if (ptr != 0) { bindings.BumpTransactionEvent_free(ptr); }
17 internal static BumpTransactionEvent constr_from_ptr(long ptr) {
18 long raw_ty = bindings.LDKBumpTransactionEvent_ty_from_ptr(ptr);
20 case 0: return new BumpTransactionEvent_ChannelClose(ptr);
21 case 1: return new BumpTransactionEvent_HTLCResolution(ptr);
23 throw new ArgumentException("Impossible enum variant");
27 /** A BumpTransactionEvent of type ChannelClose */
28 public class BumpTransactionEvent_ChannelClose : BumpTransactionEvent {
30 * The `channel_id` of the channel which has been closed.
32 public ChannelId channel_id;
34 * Counterparty in the closed channel.
36 public byte[] counterparty_node_id;
38 * The unique identifier for the claim of the anchor output in the commitment transaction.
40 * The identifier must map to the set of external UTXOs assigned to the claim, such that
41 * they can be reused when a new claim with the same identifier needs to be made, resulting
42 * in a fee-bumping attempt.
44 public byte[] claim_id;
46 * The target feerate that the transaction package, which consists of the commitment
47 * transaction and the to-be-crafted child anchor transaction, must meet.
49 public int package_target_feerate_sat_per_1000_weight;
51 * The channel's commitment transaction to bump the fee of. This transaction should be
52 * broadcast along with the anchor transaction constructed as a result of consuming this
55 public byte[] commitment_tx;
57 * The absolute fee in satoshis of the commitment transaction. This can be used along the
58 * with weight of the commitment transaction to determine its feerate.
60 public long commitment_tx_fee_satoshis;
62 * The descriptor to sign the anchor input of the anchor transaction constructed as a
63 * result of consuming this event.
65 public AnchorDescriptor anchor_descriptor;
67 * The set of pending HTLCs on the commitment transaction that need to be resolved once the
68 * commitment transaction confirms.
70 public HTLCOutputInCommitment[] pending_htlcs;
71 internal BumpTransactionEvent_ChannelClose(long ptr) : base(null, ptr) {
72 long channel_id = bindings.LDKBumpTransactionEvent_ChannelClose_get_channel_id(ptr);
73 org.ldk.structs.ChannelId channel_id_hu_conv = null; if (channel_id < 0 || channel_id > 4096) { channel_id_hu_conv = new org.ldk.structs.ChannelId(null, channel_id); }
74 if (channel_id_hu_conv != null) { channel_id_hu_conv.ptrs_to.AddLast(this); };
75 this.channel_id = channel_id_hu_conv;
76 long counterparty_node_id = bindings.LDKBumpTransactionEvent_ChannelClose_get_counterparty_node_id(ptr);
77 byte[] counterparty_node_id_conv = InternalUtils.decodeUint8Array(counterparty_node_id);
78 this.counterparty_node_id = counterparty_node_id_conv;
79 long claim_id = bindings.LDKBumpTransactionEvent_ChannelClose_get_claim_id(ptr);
80 byte[] claim_id_conv = InternalUtils.decodeUint8Array(claim_id);
81 this.claim_id = claim_id_conv;
82 this.package_target_feerate_sat_per_1000_weight = bindings.LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(ptr);
83 long commitment_tx = bindings.LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(ptr);
84 byte[] commitment_tx_conv = InternalUtils.decodeUint8Array(commitment_tx);
85 this.commitment_tx = commitment_tx_conv;
86 this.commitment_tx_fee_satoshis = bindings.LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(ptr);
87 long anchor_descriptor = bindings.LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(ptr);
88 org.ldk.structs.AnchorDescriptor anchor_descriptor_hu_conv = null; if (anchor_descriptor < 0 || anchor_descriptor > 4096) { anchor_descriptor_hu_conv = new org.ldk.structs.AnchorDescriptor(null, anchor_descriptor); }
89 if (anchor_descriptor_hu_conv != null) { anchor_descriptor_hu_conv.ptrs_to.AddLast(this); };
90 this.anchor_descriptor = anchor_descriptor_hu_conv;
91 long pending_htlcs = bindings.LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(ptr);
92 int pending_htlcs_conv_24_len = InternalUtils.getArrayLength(pending_htlcs);
93 HTLCOutputInCommitment[] pending_htlcs_conv_24_arr = new HTLCOutputInCommitment[pending_htlcs_conv_24_len];
94 for (int y = 0; y < pending_htlcs_conv_24_len; y++) {
95 long pending_htlcs_conv_24 = InternalUtils.getU64ArrayElem(pending_htlcs, y);
96 org.ldk.structs.HTLCOutputInCommitment pending_htlcs_conv_24_hu_conv = null; if (pending_htlcs_conv_24 < 0 || pending_htlcs_conv_24 > 4096) { pending_htlcs_conv_24_hu_conv = new org.ldk.structs.HTLCOutputInCommitment(null, pending_htlcs_conv_24); }
97 if (pending_htlcs_conv_24_hu_conv != null) { pending_htlcs_conv_24_hu_conv.ptrs_to.AddLast(this); };
98 pending_htlcs_conv_24_arr[y] = pending_htlcs_conv_24_hu_conv;
100 bindings.free_buffer(pending_htlcs);
101 this.pending_htlcs = pending_htlcs_conv_24_arr;
104 /** A BumpTransactionEvent of type HTLCResolution */
105 public class BumpTransactionEvent_HTLCResolution : BumpTransactionEvent {
107 * The `channel_id` of the channel which has been closed.
109 public ChannelId channel_id;
111 * Counterparty in the closed channel.
113 public byte[] counterparty_node_id;
115 * The unique identifier for the claim of the HTLCs in the confirmed commitment
118 * The identifier must map to the set of external UTXOs assigned to the claim, such that
119 * they can be reused when a new claim with the same identifier needs to be made, resulting
120 * in a fee-bumping attempt.
122 public byte[] claim_id;
124 * The target feerate that the resulting HTLC transaction must meet.
126 public int target_feerate_sat_per_1000_weight;
128 * The set of pending HTLCs on the confirmed commitment that need to be claimed, preferably
129 * by the same transaction.
131 public HTLCDescriptor[] htlc_descriptors;
133 * The locktime required for the resulting HTLC transaction.
135 public int tx_lock_time;
136 internal BumpTransactionEvent_HTLCResolution(long ptr) : base(null, ptr) {
137 long channel_id = bindings.LDKBumpTransactionEvent_HTLCResolution_get_channel_id(ptr);
138 org.ldk.structs.ChannelId channel_id_hu_conv = null; if (channel_id < 0 || channel_id > 4096) { channel_id_hu_conv = new org.ldk.structs.ChannelId(null, channel_id); }
139 if (channel_id_hu_conv != null) { channel_id_hu_conv.ptrs_to.AddLast(this); };
140 this.channel_id = channel_id_hu_conv;
141 long counterparty_node_id = bindings.LDKBumpTransactionEvent_HTLCResolution_get_counterparty_node_id(ptr);
142 byte[] counterparty_node_id_conv = InternalUtils.decodeUint8Array(counterparty_node_id);
143 this.counterparty_node_id = counterparty_node_id_conv;
144 long claim_id = bindings.LDKBumpTransactionEvent_HTLCResolution_get_claim_id(ptr);
145 byte[] claim_id_conv = InternalUtils.decodeUint8Array(claim_id);
146 this.claim_id = claim_id_conv;
147 this.target_feerate_sat_per_1000_weight = bindings.LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(ptr);
148 long htlc_descriptors = bindings.LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(ptr);
149 int htlc_descriptors_conv_16_len = InternalUtils.getArrayLength(htlc_descriptors);
150 HTLCDescriptor[] htlc_descriptors_conv_16_arr = new HTLCDescriptor[htlc_descriptors_conv_16_len];
151 for (int q = 0; q < htlc_descriptors_conv_16_len; q++) {
152 long htlc_descriptors_conv_16 = InternalUtils.getU64ArrayElem(htlc_descriptors, q);
153 org.ldk.structs.HTLCDescriptor htlc_descriptors_conv_16_hu_conv = null; if (htlc_descriptors_conv_16 < 0 || htlc_descriptors_conv_16 > 4096) { htlc_descriptors_conv_16_hu_conv = new org.ldk.structs.HTLCDescriptor(null, htlc_descriptors_conv_16); }
154 if (htlc_descriptors_conv_16_hu_conv != null) { htlc_descriptors_conv_16_hu_conv.ptrs_to.AddLast(this); };
155 htlc_descriptors_conv_16_arr[q] = htlc_descriptors_conv_16_hu_conv;
157 bindings.free_buffer(htlc_descriptors);
158 this.htlc_descriptors = htlc_descriptors_conv_16_arr;
159 this.tx_lock_time = bindings.LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(ptr);
162 internal long clone_ptr() {
163 long ret = bindings.BumpTransactionEvent_clone_ptr(this.ptr);
169 * Creates a copy of the BumpTransactionEvent
171 public BumpTransactionEvent clone() {
172 long ret = bindings.BumpTransactionEvent_clone(this.ptr);
174 if (ret >= 0 && ret <= 4096) { return null; }
175 org.ldk.structs.BumpTransactionEvent ret_hu_conv = org.ldk.structs.BumpTransactionEvent.constr_from_ptr(ret);
176 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(this); };
181 * Utility method to constructs a new ChannelClose-variant BumpTransactionEvent
183 public static BumpTransactionEvent channel_close(org.ldk.structs.ChannelId channel_id, byte[] counterparty_node_id, byte[] claim_id, int package_target_feerate_sat_per_1000_weight, byte[] commitment_tx, long commitment_tx_fee_satoshis, org.ldk.structs.AnchorDescriptor anchor_descriptor, HTLCOutputInCommitment[] pending_htlcs) {
184 long ret = bindings.BumpTransactionEvent_channel_close(channel_id.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(counterparty_node_id, 33)), InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(claim_id, 32)), package_target_feerate_sat_per_1000_weight, InternalUtils.encodeUint8Array(commitment_tx), commitment_tx_fee_satoshis, anchor_descriptor.ptr, InternalUtils.encodeUint64Array(InternalUtils.mapArray(pending_htlcs, pending_htlcs_conv_24 => pending_htlcs_conv_24.ptr)));
185 GC.KeepAlive(channel_id);
186 GC.KeepAlive(counterparty_node_id);
187 GC.KeepAlive(claim_id);
188 GC.KeepAlive(package_target_feerate_sat_per_1000_weight);
189 GC.KeepAlive(commitment_tx);
190 GC.KeepAlive(commitment_tx_fee_satoshis);
191 GC.KeepAlive(anchor_descriptor);
192 GC.KeepAlive(pending_htlcs);
193 if (ret >= 0 && ret <= 4096) { return null; }
194 org.ldk.structs.BumpTransactionEvent ret_hu_conv = org.ldk.structs.BumpTransactionEvent.constr_from_ptr(ret);
195 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
196 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(channel_id); };
197 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(anchor_descriptor); };
198 foreach (HTLCOutputInCommitment pending_htlcs_conv_24 in pending_htlcs) { if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(pending_htlcs_conv_24); }; };
203 * Utility method to constructs a new HTLCResolution-variant BumpTransactionEvent
205 public static BumpTransactionEvent htlcresolution(org.ldk.structs.ChannelId channel_id, byte[] counterparty_node_id, byte[] claim_id, int target_feerate_sat_per_1000_weight, HTLCDescriptor[] htlc_descriptors, int tx_lock_time) {
206 long ret = bindings.BumpTransactionEvent_htlcresolution(channel_id.ptr, InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(counterparty_node_id, 33)), InternalUtils.encodeUint8Array(InternalUtils.check_arr_len(claim_id, 32)), target_feerate_sat_per_1000_weight, InternalUtils.encodeUint64Array(InternalUtils.mapArray(htlc_descriptors, htlc_descriptors_conv_16 => htlc_descriptors_conv_16.ptr)), tx_lock_time);
207 GC.KeepAlive(channel_id);
208 GC.KeepAlive(counterparty_node_id);
209 GC.KeepAlive(claim_id);
210 GC.KeepAlive(target_feerate_sat_per_1000_weight);
211 GC.KeepAlive(htlc_descriptors);
212 GC.KeepAlive(tx_lock_time);
213 if (ret >= 0 && ret <= 4096) { return null; }
214 org.ldk.structs.BumpTransactionEvent ret_hu_conv = org.ldk.structs.BumpTransactionEvent.constr_from_ptr(ret);
215 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(ret_hu_conv); };
216 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(channel_id); };
217 foreach (HTLCDescriptor htlc_descriptors_conv_16 in htlc_descriptors) { if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.AddLast(htlc_descriptors_conv_16); }; };
222 * Checks if two BumpTransactionEvents contain equal inner contents.
223 * This ignores pointers and is_owned flags and looks at the values in fields.
225 public bool eq(org.ldk.structs.BumpTransactionEvent b) {
226 bool ret = bindings.BumpTransactionEvent_eq(this.ptr, b.ptr);
232 public override bool Equals(object o) {
233 if (!(o is BumpTransactionEvent)) return false;
234 return this.eq((BumpTransactionEvent)o);