_ 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                 TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new TxCreationKeys(null, ret); }
 139                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 140                 return ret_hu_conv;
 141         }
 142
 143         long clone_ptr() {
 144                 long ret = bindings.TxCreationKeys_clone_ptr(this.ptr);
 145                 Reference.reachabilityFence(this);
 146                 return ret;
 147         }
 148
 149         /**
 150          * Creates a copy of the TxCreationKeys
 151          */
 152         public TxCreationKeys clone() {
 153                 long ret = bindings.TxCreationKeys_clone(this.ptr);
 154                 Reference.reachabilityFence(this);
 155                 if (ret >= 0 && ret <= 4096) { return null; }
 156                 TxCreationKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new TxCreationKeys(null, ret); }
 157                 ret_hu_conv.ptrs_to.add(this);
 158                 return ret_hu_conv;
 159         }
 160
 161         /**
 162          * Serialize the TxCreationKeys object into a byte array which can be read by TxCreationKeys_read
 163          */
 164         public byte[] write() {
 165                 byte[] ret = bindings.TxCreationKeys_write(this.ptr);
 166                 Reference.reachabilityFence(this);
 167                 return ret;
 168         }
 169
 170         /**
 171          * Read a TxCreationKeys from a byte array, created by TxCreationKeys_write
 172          */
 173         public static Result_TxCreationKeysDecodeErrorZ read(byte[] ser) {
 174                 long ret = bindings.TxCreationKeys_read(ser);
 175                 Reference.reachabilityFence(ser);
 176                 if (ret >= 0 && ret <= 4096) { return null; }
 177                 Result_TxCreationKeysDecodeErrorZ ret_hu_conv = Result_TxCreationKeysDecodeErrorZ.constr_from_ptr(ret);
 178                 return ret_hu_conv;
 179         }
 180
 181         /**
 182          * Create per-state keys from channel base points and the per-commitment point.
 183          * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
 184          */
 185         public static Result_TxCreationKeysErrorZ derive_new(byte[] per_commitment_point, byte[] broadcaster_delayed_payment_base, byte[] broadcaster_htlc_base, byte[] countersignatory_revocation_base, byte[] countersignatory_htlc_base) {
 186                 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));
 187                 Reference.reachabilityFence(per_commitment_point);
 188                 Reference.reachabilityFence(broadcaster_delayed_payment_base);
 189                 Reference.reachabilityFence(broadcaster_htlc_base);
 190                 Reference.reachabilityFence(countersignatory_revocation_base);
 191                 Reference.reachabilityFence(countersignatory_htlc_base);
 192                 if (ret >= 0 && ret <= 4096) { return null; }
 193                 Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
 194                 return ret_hu_conv;
 195         }
 196
 197         /**
 198          * Generate per-state keys from channel static keys.
 199          * Key set is asymmetric and can't be used as part of counter-signatory set of transactions.
 200          */
 201         public static Result_TxCreationKeysErrorZ from_channel_static_keys(byte[] per_commitment_point, ChannelPublicKeys broadcaster_keys, ChannelPublicKeys countersignatory_keys) {
 202                 long ret = bindings.TxCreationKeys_from_channel_static_keys(InternalUtils.check_arr_len(per_commitment_point, 33), broadcaster_keys == null ? 0 : broadcaster_keys.ptr & ~1, countersignatory_keys == null ? 0 : countersignatory_keys.ptr & ~1);
 203                 Reference.reachabilityFence(per_commitment_point);
 204                 Reference.reachabilityFence(broadcaster_keys);
 205                 Reference.reachabilityFence(countersignatory_keys);
 206                 if (ret >= 0 && ret <= 4096) { return null; }
 207                 Result_TxCreationKeysErrorZ ret_hu_conv = Result_TxCreationKeysErrorZ.constr_from_ptr(ret);
 208                 ret_hu_conv.ptrs_to.add(broadcaster_keys);
 209                 ret_hu_conv.ptrs_to.add(countersignatory_keys);
 210                 return ret_hu_conv;
 211         }
 212
 213 }