_ Git - ldk-java/blob - src/main/java/org/ldk/structs/TxCreationKeys.java

   1 package org.ldk.structs;
   2
   3 import org.ldk.impl.bindings;
   4 import org.ldk.enums.*;
   5 import org.ldk.util.*;
   6 import java.util.Arrays;
   7 import java.lang.ref.Reference;
   8 import javax.annotation.Nullable;
   9
  10
  11 /**
  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.
  14  *
  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
  17  * transaction.
  18  *
  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.
  23  */
  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 {
  29                 super.finalize();
  30                 if (ptr != 0) { bindings.TxCreationKeys_free(ptr); }
  31         }
  32
  33         /**
  34          * The broadcaster's per-commitment public key which was used to derive the other keys.
  35          */
  36         public byte[] get_per_commitment_point() {
  37                 byte[] ret = bindings.TxCreationKeys_get_per_commitment_point(this.ptr);
  38                 Reference.reachabilityFence(this);
  39                 return ret;
  40         }
  41
  42         /**
  43          * The broadcaster's per-commitment public key which was used to derive the other keys.
  44          */
  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);
  49         }
  50
  51         /**
  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
  54          * an old state.
  55          */
  56         public byte[] get_revocation_key() {
  57                 byte[] ret = bindings.TxCreationKeys_get_revocation_key(this.ptr);
  58                 Reference.reachabilityFence(this);
  59                 return ret;
  60         }
  61
  62         /**
  63          * The revocation key which is used to allow the broadcaster of the commitment
  64          * transaction to provide their counterparty the ability to punish them if they broadcast
  65          * an old state.
  66          */
  67         public void set_revocation_key(byte[] val) {
  68                 bindings.TxCreationKeys_set_revocation_key(this.ptr, InternalUtils.check_arr_len(val, 33));
  69                 Reference.reachabilityFence(this);
  70                 Reference.reachabilityFence(val);
  71         }
  72
  73         /**
  74          * Broadcaster's HTLC Key
  75          */
  76         public byte[] get_broadcaster_htlc_key() {
  77                 byte[] ret = bindings.TxCreationKeys_get_broadcaster_htlc_key(this.ptr);
  78                 Reference.reachabilityFence(this);
  79                 return ret;
  80         }
  81
  82         /**
  83          * Broadcaster's HTLC Key
  84          */
  85         public void set_broadcaster_htlc_key(byte[] val) {
  86                 bindings.TxCreationKeys_set_broadcaster_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
  87                 Reference.reachabilityFence(this);
  88                 Reference.reachabilityFence(val);
  89         }
  90
  91         /**
  92          * Countersignatory's HTLC Key
  93          */
  94         public byte[] get_countersignatory_htlc_key() {
  95                 byte[] ret = bindings.TxCreationKeys_get_countersignatory_htlc_key(this.ptr);
  96                 Reference.reachabilityFence(this);
  97                 return ret;
  98         }
  99
 100         /**
 101          * Countersignatory's HTLC Key
 102          */
 103         public void set_countersignatory_htlc_key(byte[] val) {
 104                 bindings.TxCreationKeys_set_countersignatory_htlc_key(this.ptr, InternalUtils.check_arr_len(val, 33));
 105                 Reference.reachabilityFence(this);
 106                 Reference.reachabilityFence(val);
 107         }
 108
 109         /**
 110          * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
 111          */
 112         public byte[] get_broadcaster_delayed_payment_key() {
 113                 byte[] ret = bindings.TxCreationKeys_get_broadcaster_delayed_payment_key(this.ptr);
 114                 Reference.reachabilityFence(this);
 115                 return ret;
 116         }
 117
 118         /**
 119          * Broadcaster's Payment Key (which isn't allowed to be spent from for some delay)
 120          */
 121         public void set_broadcaster_delayed_payment_key(byte[] val) {
 122                 bindings.TxCreationKeys_set_broadcaster_delayed_payment_key(this.ptr, InternalUtils.check_arr_len(val, 33));
 123                 Reference.reachabilityFence(this);
 124                 Reference.reachabilityFence(val);
 125         }
 126
 127         /**
 128          * Constructs a new TxCreationKeys given each field
 129          */
 130         public static TxCreationKeys of(byte[] per_commitment_point_arg, byte[] revocation_key_arg, byte[] broadcaster_htlc_key_arg, byte[] countersignatory_htlc_key_arg, byte[] broadcaster_delayed_payment_key_arg) {
 131                 long ret = bindings.TxCreationKeys_new(InternalUtils.check_arr_len(per_commitment_point_arg, 33), InternalUtils.check_arr_len(revocation_key_arg, 33), InternalUtils.check_arr_len(broadcaster_htlc_key_arg, 33), InternalUtils.check_arr_len(countersignatory_htlc_key_arg, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_key_arg, 33));
 132                 Reference.reachabilityFence(per_commitment_point_arg);
 133                 Reference.reachabilityFence(revocation_key_arg);
 134                 Reference.reachabilityFence(broadcaster_htlc_key_arg);
 135                 Reference.reachabilityFence(countersignatory_htlc_key_arg);
 136                 Reference.reachabilityFence(broadcaster_delayed_payment_key_arg);
 137                 if (ret >= 0 && ret <= 4096) { return null; }
 138                 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
 139                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 140                 return ret_hu_conv;
 141         }
 142
 143         /**
 144          * Checks if two TxCreationKeyss contain equal inner contents.
 145          * This ignores pointers and is_owned flags and looks at the values in fields.
 146          * Two objects with NULL inner values will be considered "equal" here.
 147          */
 148         public boolean eq(org.ldk.structs.TxCreationKeys b) {
 149                 boolean ret = bindings.TxCreationKeys_eq(this.ptr, b == null ? 0 : b.ptr);
 150                 Reference.reachabilityFence(this);
 151                 Reference.reachabilityFence(b);
 152                 if (this != null) { this.ptrs_to.add(b); };
 153                 return ret;
 154         }
 155
 156         @Override public boolean equals(Object o) {
 157                 if (!(o instanceof TxCreationKeys)) return false;
 158                 return this.eq((TxCreationKeys)o);
 159         }
 160         long clone_ptr() {
 161                 long ret = bindings.TxCreationKeys_clone_ptr(this.ptr);
 162                 Reference.reachabilityFence(this);
 163                 return ret;
 164         }
 165
 166         /**
 167          * Creates a copy of the TxCreationKeys
 168          */
 169         public TxCreationKeys clone() {
 170                 long ret = bindings.TxCreationKeys_clone(this.ptr);
 171                 Reference.reachabilityFence(this);
 172                 if (ret >= 0 && ret <= 4096) { return null; }
 173                 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
 174                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 175                 return ret_hu_conv;
 176         }
 177
 178         /**
 179          * Serialize the TxCreationKeys object into a byte array which can be read by TxCreationKeys_read
 180          */
 181         public byte[] write() {
 182                 byte[] ret = bindings.TxCreationKeys_write(this.ptr);
 183                 Reference.reachabilityFence(this);
 184                 return ret;
 185         }
 186
 187         /**
 188          * Read a TxCreationKeys from a byte array, created by TxCreationKeys_write
 189          */
 190         public static Result_TxCreationKeysDecodeErrorZ read(byte[] ser) {
 191                 long ret = bindings.TxCreationKeys_read(ser);
 192                 Reference.reachabilityFence(ser);
 193                 if (ret >= 0 && ret <= 4096) { return null; }
 194                 Result_TxCreationKeysDecodeErrorZ ret_hu_conv = Result_TxCreationKeysDecodeErrorZ.constr_from_ptr(ret);
 195                 return ret_hu_conv;
 196         }
 197
 198         /**
 199          * Create per-state keys from channel base points and the per-commitment point.
 200          * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
 201          */
 202         public static TxCreationKeys derive_new(byte[] per_commitment_point, byte[] broadcaster_delayed_payment_base, byte[] broadcaster_htlc_base, byte[] countersignatory_revocation_base, byte[] countersignatory_htlc_base) {
 203                 long ret = bindings.TxCreationKeys_derive_new(InternalUtils.check_arr_len(per_commitment_point, 33), InternalUtils.check_arr_len(broadcaster_delayed_payment_base, 33), InternalUtils.check_arr_len(broadcaster_htlc_base, 33), InternalUtils.check_arr_len(countersignatory_revocation_base, 33), InternalUtils.check_arr_len(countersignatory_htlc_base, 33));
 204                 Reference.reachabilityFence(per_commitment_point);
 205                 Reference.reachabilityFence(broadcaster_delayed_payment_base);
 206                 Reference.reachabilityFence(broadcaster_htlc_base);
 207                 Reference.reachabilityFence(countersignatory_revocation_base);
 208                 Reference.reachabilityFence(countersignatory_htlc_base);
 209                 if (ret >= 0 && ret <= 4096) { return null; }
 210                 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
 211                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 212                 return ret_hu_conv;
 213         }
 214
 215         /**
 216          * Generate per-state keys from channel static keys.
 217          * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
 218          */
 219         public static TxCreationKeys from_channel_static_keys(byte[] per_commitment_point, org.ldk.structs.ChannelPublicKeys broadcaster_keys, org.ldk.structs.ChannelPublicKeys countersignatory_keys) {
 220                 long ret = bindings.TxCreationKeys_from_channel_static_keys(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_keys == null ? 0 : broadcaster_keys.ptr, countersignatory_keys == null ? 0 : countersignatory_keys.ptr);
 221                 Reference.reachabilityFence(per_commitment_point);
 222                 Reference.reachabilityFence(broadcaster_keys);
 223                 Reference.reachabilityFence(countersignatory_keys);
 224                 if (ret >= 0 && ret <= 4096) { return null; }
 225                 org.ldk.structs.TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.TxCreationKeys(null, ret); }
 226                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 227                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(broadcaster_keys); };
 228                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(countersignatory_keys); };
 229                 return ret_hu_conv;
 230         }
 231
 232 }