1 package org.ldk.structs;
3 import org.ldk.impl.bindings;
4 import org.ldk.enums.*;
6 import java.util.Arrays;
7 import java.lang.ref.Reference;
8 import javax.annotation.Nullable;
12 * The set of public keys which are used in the creation of one commitment transaction.
13 * These are derived from the channel base keys and per-commitment data.
15 * A broadcaster key is provided from potential broadcaster of the computed transaction.
16 * A countersignatory key is coming from a protocol participant unable to broadcast the
19 * These keys are assumed to be good, either because the code derived them from
20 * channel basepoints via the new function, or they were obtained via
21 * CommitmentTransaction.trust().keys() because we trusted the source of the
22 * pre-calculated keys.
24 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
25 public class TxCreationKeys extends CommonBase {
26 TxCreationKeys(Object _dummy, long ptr) { super(ptr); }
27 @Override @SuppressWarnings("deprecation")
28 protected void finalize() throws Throwable {
30 if (ptr != 0) { bindings.TxCreationKeys_free(ptr); }
34 * The broadcaster's per-commitment public key which was used to derive the other keys.
36 public byte[] get_per_commitment_point() {
37 byte[] ret = bindings.TxCreationKeys_get_per_commitment_point(this.ptr);
38 Reference.reachabilityFence(this);
43 * The broadcaster's per-commitment public key which was used to derive the other keys.
45 public void set_per_commitment_point(byte[] val) {
46 bindings.TxCreationKeys_set_per_commitment_point(this.ptr, InternalUtils.check_arr_len(val, 33));
47 Reference.reachabilityFence(this);
48 Reference.reachabilityFence(val);
52 * The revocation key which is used to allow the broadcaster of the commitment
53 * transaction to provide their counterparty the ability to punish them if they broadcast
56 public RevocationKey get_revocation_key() {
57 long ret = bindings.TxCreationKeys_get_revocation_key(this.ptr);
58 Reference.reachabilityFence(this);
59 if (ret >= 0 && ret <= 4096) { return null; }
60 org.ldk.structs.RevocationKey ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.RevocationKey(null, ret); }
61 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
66 * The revocation key which is used to allow the broadcaster of the commitment
67 * transaction to provide their counterparty the ability to punish them if they broadcast
70 public void set_revocation_key(org.ldk.structs.RevocationKey val) {
71 bindings.TxCreationKeys_set_revocation_key(this.ptr, val.ptr);
72 Reference.reachabilityFence(this);
73 Reference.reachabilityFence(val);
74 if (this != null) { this.ptrs_to.add(val); };
78 * Broadcaster's HTLC Key
80 public HtlcKey get_broadcaster_htlc_key() {
81 long ret = bindings.TxCreationKeys_get_broadcaster_htlc_key(this.ptr);
82 Reference.reachabilityFence(this);
83 if (ret >= 0 && ret <= 4096) { return null; }
84 org.ldk.structs.HtlcKey ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.HtlcKey(null, ret); }
85 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
90 * Broadcaster's HTLC Key
92 public void set_broadcaster_htlc_key(org.ldk.structs.HtlcKey val) {
93 bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, val.ptr);
94 Reference.reachabilityFence(this);
95 Reference.reachabilityFence(val);
96 if (this != null) { this.ptrs_to.add(val); };
100 * Countersignatory's HTLC Key
102 public HtlcKey get_countersignatory_htlc_key() {
103 long ret = bindings.TxCreationKeys_get_countersignatory_htlc_key(this.ptr);
104 Reference.reachabilityFence(this);
105 if (ret >= 0 && ret <= 4096) { return null; }
106 org.ldk.structs.HtlcKey ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.HtlcKey(null, ret); }
107 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
112 * Countersignatory's HTLC Key
114 public void set_countersignatory_htlc_key(org.ldk.structs.HtlcKey val) {
115 bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, val.ptr);
116 Reference.reachabilityFence(this);
117 Reference.reachabilityFence(val);
118 if (this != null) { this.ptrs_to.add(val); };
122 * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
124 public DelayedPaymentKey get_broadcaster_delayed_payment_key() {
125 long ret = bindings.TxCreationKeys_get_broadcaster_delayed_payment_key(this.ptr);
126 Reference.reachabilityFence(this);
127 if (ret >= 0 && ret <= 4096) { return null; }
128 org.ldk.structs.DelayedPaymentKey ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.DelayedPaymentKey(null, ret); }
129 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
134 * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
136 public void set_broadcaster_delayed_payment_key(org.ldk.structs.DelayedPaymentKey val) {
137 bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, val.ptr);
138 Reference.reachabilityFence(this);
139 Reference.reachabilityFence(val);
140 if (this != null) { this.ptrs_to.add(val); };
144 * Constructs a new TxCreationKeys given each field
146 public static TxCreationKeys of(byte[] per_commitment_point_arg, org.ldk.structs.RevocationKey revocation_key_arg, org.ldk.structs.HtlcKey broadcaster_htlc_key_arg, org.ldk.structs.HtlcKey countersignatory_htlc_key_arg, org.ldk.structs.DelayedPaymentKey broadcaster_delayed_payment_key_arg) {
147 long ret = bindings.TxCreationKeys_new(InternalUtils.check_arr_len(per_commitment_point_arg, 33), revocation_key_arg.ptr, broadcaster_htlc_key_arg.ptr, countersignatory_htlc_key_arg.ptr, broadcaster_delayed_payment_key_arg.ptr);
148 Reference.reachabilityFence(per_commitment_point_arg);
149 Reference.reachabilityFence(revocation_key_arg);
150 Reference.reachabilityFence(broadcaster_htlc_key_arg);
151 Reference.reachabilityFence(countersignatory_htlc_key_arg);
152 Reference.reachabilityFence(broadcaster_delayed_payment_key_arg);
153 if (ret >= 0 && ret <= 4096) { return null; }
154 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
155 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
156 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(revocation_key_arg); };
157 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_htlc_key_arg); };
158 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(countersignatory_htlc_key_arg); };
159 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_delayed_payment_key_arg); };
164 * Checks if two TxCreationKeyss contain equal inner contents.
165 * This ignores pointers and is_owned flags and looks at the values in fields.
166 * Two objects with NULL inner values will be considered "equal" here.
168 public boolean eq(org.ldk.structs.TxCreationKeys b) {
169 boolean ret = bindings.TxCreationKeys_eq(this.ptr, b.ptr);
170 Reference.reachabilityFence(this);
171 Reference.reachabilityFence(b);
172 if (this != null) { this.ptrs_to.add(b); };
176 @Override public boolean equals(Object o) {
177 if (!(o instanceof TxCreationKeys)) return false;
178 return this.eq((TxCreationKeys)o);
181 long ret = bindings.TxCreationKeys_clone_ptr(this.ptr);
182 Reference.reachabilityFence(this);
187 * Creates a copy of the TxCreationKeys
189 public TxCreationKeys clone() {
190 long ret = bindings.TxCreationKeys_clone(this.ptr);
191 Reference.reachabilityFence(this);
192 if (ret >= 0 && ret <= 4096) { return null; }
193 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
194 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
199 * Serialize the TxCreationKeys object into a byte array which can be read by TxCreationKeys_read
201 public byte[] write() {
202 byte[] ret = bindings.TxCreationKeys_write(this.ptr);
203 Reference.reachabilityFence(this);
208 * Read a TxCreationKeys from a byte array, created by TxCreationKeys_write
210 public static Result_TxCreationKeysDecodeErrorZ read(byte[] ser) {
211 long ret = bindings.TxCreationKeys_read(ser);
212 Reference.reachabilityFence(ser);
213 if (ret >= 0 && ret <= 4096) { return null; }
214 Result_TxCreationKeysDecodeErrorZ ret_hu_conv = Result_TxCreationKeysDecodeErrorZ.constr_from_ptr(ret);
219 * Create per-state keys from channel base points and the per-commitment point.
220 * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
222 public static TxCreationKeys derive_new(byte[] per_commitment_point, org.ldk.structs.DelayedPaymentBasepoint broadcaster_delayed_payment_base, org.ldk.structs.HtlcBasepoint broadcaster_htlc_base, org.ldk.structs.RevocationBasepoint countersignatory_revocation_base, org.ldk.structs.HtlcBasepoint countersignatory_htlc_base) {
223 long ret = bindings.TxCreationKeys_derive_new(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_delayed_payment_base.ptr, broadcaster_htlc_base.ptr, countersignatory_revocation_base.ptr, countersignatory_htlc_base.ptr);
224 Reference.reachabilityFence(per_commitment_point);
225 Reference.reachabilityFence(broadcaster_delayed_payment_base);
226 Reference.reachabilityFence(broadcaster_htlc_base);
227 Reference.reachabilityFence(countersignatory_revocation_base);
228 Reference.reachabilityFence(countersignatory_htlc_base);
229 if (ret >= 0 && ret <= 4096) { return null; }
230 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
231 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
232 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_delayed_payment_base); };
233 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_htlc_base); };
234 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(countersignatory_revocation_base); };
235 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(countersignatory_htlc_base); };
240 * Generate per-state keys from channel static keys.
241 * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
243 public static TxCreationKeys from_channel_static_keys(byte[] per_commitment_point, org.ldk.structs.ChannelPublicKeys broadcaster_keys, org.ldk.structs.ChannelPublicKeys countersignatory_keys) {
244 long ret = bindings.TxCreationKeys_from_channel_static_keys(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_keys.ptr, countersignatory_keys.ptr);
245 Reference.reachabilityFence(per_commitment_point);
246 Reference.reachabilityFence(broadcaster_keys);
247 Reference.reachabilityFence(countersignatory_keys);
248 if (ret >= 0 && ret <= 4096) { return null; }
249 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
250 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
251 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_keys); };
252 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(countersignatory_keys); };