_ Git - ldk-java/blob - src/main/java/org/ldk/structs/InMemorySigner.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  * A simple implementation of [`WriteableEcdsaChannelSigner`] that just keeps the private keys in memory.
  13  *
  14  * This implementation performs no policy checks and is insufficient by itself as
  15  * a secure external signer.
  16  */
  17 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  18 public class InMemorySigner extends CommonBase {
  19         InMemorySigner(Object _dummy, long ptr) { super(ptr); }
  20         @Override @SuppressWarnings("deprecation")
  21         protected void finalize() throws Throwable {
  22                 super.finalize();
  23                 if (ptr != 0) { bindings.InMemorySigner_free(ptr); }
  24         }
  25
  26         /**
  27          * Holder secret key in the 2-of-2 multisig script of a channel. This key also backs the
  28          * holder's anchor output in a commitment transaction, if one is present.
  29          */
  30         public byte[] get_funding_key() {
  31                 byte[] ret = bindings.InMemorySigner_get_funding_key(this.ptr);
  32                 Reference.reachabilityFence(this);
  33                 return ret;
  34         }
  35
  36         /**
  37          * Holder secret key in the 2-of-2 multisig script of a channel. This key also backs the
  38          * holder's anchor output in a commitment transaction, if one is present.
  39          */
  40         public void set_funding_key(byte[] val) {
  41                 bindings.InMemorySigner_set_funding_key(this.ptr, InternalUtils.check_arr_len(val, 32));
  42                 Reference.reachabilityFence(this);
  43                 Reference.reachabilityFence(val);
  44         }
  45
  46         /**
  47          * Holder secret key for blinded revocation pubkey.
  48          */
  49         public byte[] get_revocation_base_key() {
  50                 byte[] ret = bindings.InMemorySigner_get_revocation_base_key(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 return ret;
  53         }
  54
  55         /**
  56          * Holder secret key for blinded revocation pubkey.
  57          */
  58         public void set_revocation_base_key(byte[] val) {
  59                 bindings.InMemorySigner_set_revocation_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
  60                 Reference.reachabilityFence(this);
  61                 Reference.reachabilityFence(val);
  62         }
  63
  64         /**
  65          * Holder secret key used for our balance in counterparty-broadcasted commitment transactions.
  66          */
  67         public byte[] get_payment_key() {
  68                 byte[] ret = bindings.InMemorySigner_get_payment_key(this.ptr);
  69                 Reference.reachabilityFence(this);
  70                 return ret;
  71         }
  72
  73         /**
  74          * Holder secret key used for our balance in counterparty-broadcasted commitment transactions.
  75          */
  76         public void set_payment_key(byte[] val) {
  77                 bindings.InMemorySigner_set_payment_key(this.ptr, InternalUtils.check_arr_len(val, 32));
  78                 Reference.reachabilityFence(this);
  79                 Reference.reachabilityFence(val);
  80         }
  81
  82         /**
  83          * Holder secret key used in an HTLC transaction.
  84          */
  85         public byte[] get_delayed_payment_base_key() {
  86                 byte[] ret = bindings.InMemorySigner_get_delayed_payment_base_key(this.ptr);
  87                 Reference.reachabilityFence(this);
  88                 return ret;
  89         }
  90
  91         /**
  92          * Holder secret key used in an HTLC transaction.
  93          */
  94         public void set_delayed_payment_base_key(byte[] val) {
  95                 bindings.InMemorySigner_set_delayed_payment_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
  96                 Reference.reachabilityFence(this);
  97                 Reference.reachabilityFence(val);
  98         }
  99
 100         /**
 101          * Holder HTLC secret key used in commitment transaction HTLC outputs.
 102          */
 103         public byte[] get_htlc_base_key() {
 104                 byte[] ret = bindings.InMemorySigner_get_htlc_base_key(this.ptr);
 105                 Reference.reachabilityFence(this);
 106                 return ret;
 107         }
 108
 109         /**
 110          * Holder HTLC secret key used in commitment transaction HTLC outputs.
 111          */
 112         public void set_htlc_base_key(byte[] val) {
 113                 bindings.InMemorySigner_set_htlc_base_key(this.ptr, InternalUtils.check_arr_len(val, 32));
 114                 Reference.reachabilityFence(this);
 115                 Reference.reachabilityFence(val);
 116         }
 117
 118         /**
 119          * Commitment seed.
 120          */
 121         public byte[] get_commitment_seed() {
 122                 byte[] ret = bindings.InMemorySigner_get_commitment_seed(this.ptr);
 123                 Reference.reachabilityFence(this);
 124                 return ret;
 125         }
 126
 127         /**
 128          * Commitment seed.
 129          */
 130         public void set_commitment_seed(byte[] val) {
 131                 bindings.InMemorySigner_set_commitment_seed(this.ptr, InternalUtils.check_arr_len(val, 32));
 132                 Reference.reachabilityFence(this);
 133                 Reference.reachabilityFence(val);
 134         }
 135
 136         long clone_ptr() {
 137                 long ret = bindings.InMemorySigner_clone_ptr(this.ptr);
 138                 Reference.reachabilityFence(this);
 139                 return ret;
 140         }
 141
 142         /**
 143          * Creates a copy of the InMemorySigner
 144          */
 145         public InMemorySigner clone() {
 146                 long ret = bindings.InMemorySigner_clone(this.ptr);
 147                 Reference.reachabilityFence(this);
 148                 if (ret >= 0 && ret <= 4096) { return null; }
 149                 org.ldk.structs.InMemorySigner ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InMemorySigner(null, ret); }
 150                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 151                 return ret_hu_conv;
 152         }
 153
 154         /**
 155          * Creates a new [`InMemorySigner`].
 156          */
 157         public static InMemorySigner of(byte[] funding_key, byte[] revocation_base_key, byte[] payment_key, byte[] delayed_payment_base_key, byte[] htlc_base_key, byte[] commitment_seed, long channel_value_satoshis, byte[] channel_keys_id) {
 158                 long ret = bindings.InMemorySigner_new(InternalUtils.check_arr_len(funding_key, 32), InternalUtils.check_arr_len(revocation_base_key, 32), InternalUtils.check_arr_len(payment_key, 32), InternalUtils.check_arr_len(delayed_payment_base_key, 32), InternalUtils.check_arr_len(htlc_base_key, 32), InternalUtils.check_arr_len(commitment_seed, 32), channel_value_satoshis, InternalUtils.check_arr_len(channel_keys_id, 32));
 159                 Reference.reachabilityFence(funding_key);
 160                 Reference.reachabilityFence(revocation_base_key);
 161                 Reference.reachabilityFence(payment_key);
 162                 Reference.reachabilityFence(delayed_payment_base_key);
 163                 Reference.reachabilityFence(htlc_base_key);
 164                 Reference.reachabilityFence(commitment_seed);
 165                 Reference.reachabilityFence(channel_value_satoshis);
 166                 Reference.reachabilityFence(channel_keys_id);
 167                 if (ret >= 0 && ret <= 4096) { return null; }
 168                 org.ldk.structs.InMemorySigner ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InMemorySigner(null, ret); }
 169                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 170                 return ret_hu_conv;
 171         }
 172
 173         /**
 174          * Returns the counterparty's pubkeys.
 175          *
 176          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 177          */
 178         public ChannelPublicKeys counterparty_pubkeys() {
 179                 long ret = bindings.InMemorySigner_counterparty_pubkeys(this.ptr);
 180                 Reference.reachabilityFence(this);
 181                 if (ret >= 0 && ret <= 4096) { return null; }
 182                 org.ldk.structs.ChannelPublicKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelPublicKeys(null, ret); }
 183                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 184                 return ret_hu_conv;
 185         }
 186
 187         /**
 188          * Returns the `contest_delay` value specified by our counterparty and applied on holder-broadcastable
 189          * transactions, i.e., the amount of time that we have to wait to recover our funds if we
 190          * broadcast a transaction.
 191          *
 192          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 193          */
 194         public short counterparty_selected_contest_delay() {
 195                 short ret = bindings.InMemorySigner_counterparty_selected_contest_delay(this.ptr);
 196                 Reference.reachabilityFence(this);
 197                 return ret;
 198         }
 199
 200         /**
 201          * Returns the `contest_delay` value specified by us and applied on transactions broadcastable
 202          * by our counterparty, i.e., the amount of time that they have to wait to recover their funds
 203          * if they broadcast a transaction.
 204          *
 205          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 206          */
 207         public short holder_selected_contest_delay() {
 208                 short ret = bindings.InMemorySigner_holder_selected_contest_delay(this.ptr);
 209                 Reference.reachabilityFence(this);
 210                 return ret;
 211         }
 212
 213         /**
 214          * Returns whether the holder is the initiator.
 215          *
 216          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 217          */
 218         public boolean is_outbound() {
 219                 boolean ret = bindings.InMemorySigner_is_outbound(this.ptr);
 220                 Reference.reachabilityFence(this);
 221                 return ret;
 222         }
 223
 224         /**
 225          * Funding outpoint
 226          *
 227          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 228          */
 229         public OutPoint funding_outpoint() {
 230                 long ret = bindings.InMemorySigner_funding_outpoint(this.ptr);
 231                 Reference.reachabilityFence(this);
 232                 if (ret >= 0 && ret <= 4096) { return null; }
 233                 org.ldk.structs.OutPoint ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.OutPoint(null, ret); }
 234                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 235                 return ret_hu_conv;
 236         }
 237
 238         /**
 239          * Returns a [`ChannelTransactionParameters`] for this channel, to be used when verifying or
 240          * building transactions.
 241          *
 242          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 243          */
 244         public ChannelTransactionParameters get_channel_parameters() {
 245                 long ret = bindings.InMemorySigner_get_channel_parameters(this.ptr);
 246                 Reference.reachabilityFence(this);
 247                 if (ret >= 0 && ret <= 4096) { return null; }
 248                 org.ldk.structs.ChannelTransactionParameters ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelTransactionParameters(null, ret); }
 249                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 250                 return ret_hu_conv;
 251         }
 252
 253         /**
 254          * Returns whether anchors should be used.
 255          *
 256          * Will panic if [`ChannelSigner::provide_channel_parameters`] has not been called before.
 257          */
 258         public boolean opt_anchors() {
 259                 boolean ret = bindings.InMemorySigner_opt_anchors(this.ptr);
 260                 Reference.reachabilityFence(this);
 261                 return ret;
 262         }
 263
 264         /**
 265          * Sign the single input of `spend_tx` at index `input_idx`, which spends the output described
 266          * by `descriptor`, returning the witness stack for the input.
 267          *
 268          * Returns an error if the input at `input_idx` does not exist, has a non-empty `script_sig`,
 269          * is not spending the outpoint described by [`descriptor.outpoint`],
 270          * or if an output descriptor `script_pubkey` does not match the one we can spend.
 271          *
 272          * [`descriptor.outpoint`]: StaticPaymentOutputDescriptor::outpoint
 273          */
 274         public Result_CVec_CVec_u8ZZNoneZ sign_counterparty_payment_input(byte[] spend_tx, long input_idx, org.ldk.structs.StaticPaymentOutputDescriptor descriptor) {
 275                 long ret = bindings.InMemorySigner_sign_counterparty_payment_input(this.ptr, spend_tx, input_idx, descriptor == null ? 0 : descriptor.ptr);
 276                 Reference.reachabilityFence(this);
 277                 Reference.reachabilityFence(spend_tx);
 278                 Reference.reachabilityFence(input_idx);
 279                 Reference.reachabilityFence(descriptor);
 280                 if (ret >= 0 && ret <= 4096) { return null; }
 281                 Result_CVec_CVec_u8ZZNoneZ ret_hu_conv = Result_CVec_CVec_u8ZZNoneZ.constr_from_ptr(ret);
 282                 if (this != null) { this.ptrs_to.add(descriptor); };
 283                 return ret_hu_conv;
 284         }
 285
 286         /**
 287          * Sign the single input of `spend_tx` at index `input_idx` which spends the output
 288          * described by `descriptor`, returning the witness stack for the input.
 289          *
 290          * Returns an error if the input at `input_idx` does not exist, has a non-empty `script_sig`,
 291          * is not spending the outpoint described by [`descriptor.outpoint`], does not have a
 292          * sequence set to [`descriptor.to_self_delay`], or if an output descriptor
 293          * `script_pubkey` does not match the one we can spend.
 294          *
 295          * [`descriptor.outpoint`]: DelayedPaymentOutputDescriptor::outpoint
 296          * [`descriptor.to_self_delay`]: DelayedPaymentOutputDescriptor::to_self_delay
 297          */
 298         public Result_CVec_CVec_u8ZZNoneZ sign_dynamic_p2wsh_input(byte[] spend_tx, long input_idx, org.ldk.structs.DelayedPaymentOutputDescriptor descriptor) {
 299                 long ret = bindings.InMemorySigner_sign_dynamic_p2wsh_input(this.ptr, spend_tx, input_idx, descriptor == null ? 0 : descriptor.ptr);
 300                 Reference.reachabilityFence(this);
 301                 Reference.reachabilityFence(spend_tx);
 302                 Reference.reachabilityFence(input_idx);
 303                 Reference.reachabilityFence(descriptor);
 304                 if (ret >= 0 && ret <= 4096) { return null; }
 305                 Result_CVec_CVec_u8ZZNoneZ ret_hu_conv = Result_CVec_CVec_u8ZZNoneZ.constr_from_ptr(ret);
 306                 if (this != null) { this.ptrs_to.add(descriptor); };
 307                 return ret_hu_conv;
 308         }
 309
 310         /**
 311          * Constructs a new ChannelSigner which calls the relevant methods on this_arg.
 312          * This copies the `inner` pointer in this_arg and thus the returned ChannelSigner must be freed before this_arg is
 313          */
 314         public ChannelSigner as_ChannelSigner() {
 315                 long ret = bindings.InMemorySigner_as_ChannelSigner(this.ptr);
 316                 Reference.reachabilityFence(this);
 317                 if (ret >= 0 && ret <= 4096) { return null; }
 318                 ChannelSigner ret_hu_conv = new ChannelSigner(null, ret);
 319                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 320                 return ret_hu_conv;
 321         }
 322
 323         /**
 324          * Constructs a new EcdsaChannelSigner which calls the relevant methods on this_arg.
 325          * This copies the `inner` pointer in this_arg and thus the returned EcdsaChannelSigner must be freed before this_arg is
 326          */
 327         public EcdsaChannelSigner as_EcdsaChannelSigner() {
 328                 long ret = bindings.InMemorySigner_as_EcdsaChannelSigner(this.ptr);
 329                 Reference.reachabilityFence(this);
 330                 if (ret >= 0 && ret <= 4096) { return null; }
 331                 EcdsaChannelSigner ret_hu_conv = new EcdsaChannelSigner(null, ret);
 332                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 333                 return ret_hu_conv;
 334         }
 335
 336         /**
 337          * Constructs a new WriteableEcdsaChannelSigner which calls the relevant methods on this_arg.
 338          * This copies the `inner` pointer in this_arg and thus the returned WriteableEcdsaChannelSigner must be freed before this_arg is
 339          */
 340         public WriteableEcdsaChannelSigner as_WriteableEcdsaChannelSigner() {
 341                 long ret = bindings.InMemorySigner_as_WriteableEcdsaChannelSigner(this.ptr);
 342                 Reference.reachabilityFence(this);
 343                 if (ret >= 0 && ret <= 4096) { return null; }
 344                 WriteableEcdsaChannelSigner ret_hu_conv = new WriteableEcdsaChannelSigner(null, ret);
 345                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 346                 return ret_hu_conv;
 347         }
 348
 349         /**
 350          * Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
 351          */
 352         public byte[] write() {
 353                 byte[] ret = bindings.InMemorySigner_write(this.ptr);
 354                 Reference.reachabilityFence(this);
 355                 return ret;
 356         }
 357
 358         /**
 359          * Read a InMemorySigner from a byte array, created by InMemorySigner_write
 360          */
 361         public static Result_InMemorySignerDecodeErrorZ read(byte[] ser) {
 362                 long ret = bindings.InMemorySigner_read(ser);
 363                 Reference.reachabilityFence(ser);
 364                 if (ret >= 0 && ret <= 4096) { return null; }
 365                 Result_InMemorySignerDecodeErrorZ ret_hu_conv = Result_InMemorySignerDecodeErrorZ.constr_from_ptr(ret);
 366                 return ret_hu_conv;
 367         }
 368
 369 }