_ 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 [`Sign`] 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[] node_secret, 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(node_secret, 32), 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(node_secret);
 160                 Reference.reachabilityFence(funding_key);
 161                 Reference.reachabilityFence(revocation_base_key);
 162                 Reference.reachabilityFence(payment_key);
 163                 Reference.reachabilityFence(delayed_payment_base_key);
 164                 Reference.reachabilityFence(htlc_base_key);
 165                 Reference.reachabilityFence(commitment_seed);
 166                 Reference.reachabilityFence(channel_value_satoshis);
 167                 Reference.reachabilityFence(channel_keys_id);
 168                 if (ret >= 0 && ret <= 4096) { return null; }
 169                 org.ldk.structs.InMemorySigner ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InMemorySigner(null, ret); }
 170                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
 171                 return ret_hu_conv;
 172         }
 173
 174         /**
 175          * Returns the counterparty's pubkeys.
 176          *
 177          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 178          */
 179         public ChannelPublicKeys counterparty_pubkeys() {
 180                 long ret = bindings.InMemorySigner_counterparty_pubkeys(this.ptr);
 181                 Reference.reachabilityFence(this);
 182                 if (ret >= 0 && ret <= 4096) { return null; }
 183                 org.ldk.structs.ChannelPublicKeys ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelPublicKeys(null, ret); }
 184                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 185                 return ret_hu_conv;
 186         }
 187
 188         /**
 189          * Returns the `contest_delay` value specified by our counterparty and applied on holder-broadcastable
 190          * transactions, i.e., the amount of time that we have to wait to recover our funds if we
 191          * broadcast a transaction.
 192          *
 193          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 194          */
 195         public short counterparty_selected_contest_delay() {
 196                 short ret = bindings.InMemorySigner_counterparty_selected_contest_delay(this.ptr);
 197                 Reference.reachabilityFence(this);
 198                 return ret;
 199         }
 200
 201         /**
 202          * Returns the `contest_delay` value specified by us and applied on transactions broadcastable
 203          * by our counterparty, i.e., the amount of time that they have to wait to recover their funds
 204          * if they broadcast a transaction.
 205          *
 206          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 207          */
 208         public short holder_selected_contest_delay() {
 209                 short ret = bindings.InMemorySigner_holder_selected_contest_delay(this.ptr);
 210                 Reference.reachabilityFence(this);
 211                 return ret;
 212         }
 213
 214         /**
 215          * Returns whether the holder is the initiator.
 216          *
 217          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 218          */
 219         public boolean is_outbound() {
 220                 boolean ret = bindings.InMemorySigner_is_outbound(this.ptr);
 221                 Reference.reachabilityFence(this);
 222                 return ret;
 223         }
 224
 225         /**
 226          * Funding outpoint
 227          *
 228          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 229          */
 230         public OutPoint funding_outpoint() {
 231                 long ret = bindings.InMemorySigner_funding_outpoint(this.ptr);
 232                 Reference.reachabilityFence(this);
 233                 if (ret >= 0 && ret <= 4096) { return null; }
 234                 org.ldk.structs.OutPoint ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.OutPoint(null, ret); }
 235                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 236                 return ret_hu_conv;
 237         }
 238
 239         /**
 240          * Returns a [`ChannelTransactionParameters`] for this channel, to be used when verifying or
 241          * building transactions.
 242          *
 243          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 244          */
 245         public ChannelTransactionParameters get_channel_parameters() {
 246                 long ret = bindings.InMemorySigner_get_channel_parameters(this.ptr);
 247                 Reference.reachabilityFence(this);
 248                 if (ret >= 0 && ret <= 4096) { return null; }
 249                 org.ldk.structs.ChannelTransactionParameters ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelTransactionParameters(null, ret); }
 250                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 251                 return ret_hu_conv;
 252         }
 253
 254         /**
 255          * Returns whether anchors should be used.
 256          *
 257          * Will panic if [`BaseSign::provide_channel_parameters`] has not been called before.
 258          */
 259         public boolean opt_anchors() {
 260                 boolean ret = bindings.InMemorySigner_opt_anchors(this.ptr);
 261                 Reference.reachabilityFence(this);
 262                 return ret;
 263         }
 264
 265         /**
 266          * Sign the single input of `spend_tx` at index `input_idx`, which spends the output described
 267          * by `descriptor`, returning the witness stack for the input.
 268          *
 269          * Returns an error if the input at `input_idx` does not exist, has a non-empty `script_sig`,
 270          * is not spending the outpoint described by [`descriptor.outpoint`],
 271          * or if an output descriptor `script_pubkey` does not match the one we can spend.
 272          *
 273          * [`descriptor.outpoint`]: StaticPaymentOutputDescriptor::outpoint
 274          */
 275         public Result_CVec_CVec_u8ZZNoneZ sign_counterparty_payment_input(byte[] spend_tx, long input_idx, org.ldk.structs.StaticPaymentOutputDescriptor descriptor) {
 276                 long ret = bindings.InMemorySigner_sign_counterparty_payment_input(this.ptr, spend_tx, input_idx, descriptor == null ? 0 : descriptor.ptr);
 277                 Reference.reachabilityFence(this);
 278                 Reference.reachabilityFence(spend_tx);
 279                 Reference.reachabilityFence(input_idx);
 280                 Reference.reachabilityFence(descriptor);
 281                 if (ret >= 0 && ret <= 4096) { return null; }
 282                 Result_CVec_CVec_u8ZZNoneZ ret_hu_conv = Result_CVec_CVec_u8ZZNoneZ.constr_from_ptr(ret);
 283                 if (this != null) { this.ptrs_to.add(descriptor); };
 284                 return ret_hu_conv;
 285         }
 286
 287         /**
 288          * Sign the single input of `spend_tx` at index `input_idx` which spends the output
 289          * described by `descriptor`, returning the witness stack for the input.
 290          *
 291          * Returns an error if the input at `input_idx` does not exist, has a non-empty `script_sig`,
 292          * is not spending the outpoint described by [`descriptor.outpoint`], does not have a
 293          * sequence set to [`descriptor.to_self_delay`], or if an output descriptor
 294          * `script_pubkey` does not match the one we can spend.
 295          *
 296          * [`descriptor.outpoint`]: DelayedPaymentOutputDescriptor::outpoint
 297          * [`descriptor.to_self_delay`]: DelayedPaymentOutputDescriptor::to_self_delay
 298          */
 299         public Result_CVec_CVec_u8ZZNoneZ sign_dynamic_p2wsh_input(byte[] spend_tx, long input_idx, org.ldk.structs.DelayedPaymentOutputDescriptor descriptor) {
 300                 long ret = bindings.InMemorySigner_sign_dynamic_p2wsh_input(this.ptr, spend_tx, input_idx, descriptor == null ? 0 : descriptor.ptr);
 301                 Reference.reachabilityFence(this);
 302                 Reference.reachabilityFence(spend_tx);
 303                 Reference.reachabilityFence(input_idx);
 304                 Reference.reachabilityFence(descriptor);
 305                 if (ret >= 0 && ret <= 4096) { return null; }
 306                 Result_CVec_CVec_u8ZZNoneZ ret_hu_conv = Result_CVec_CVec_u8ZZNoneZ.constr_from_ptr(ret);
 307                 if (this != null) { this.ptrs_to.add(descriptor); };
 308                 return ret_hu_conv;
 309         }
 310
 311         /**
 312          * Constructs a new BaseSign which calls the relevant methods on this_arg.
 313          * This copies the `inner` pointer in this_arg and thus the returned BaseSign must be freed before this_arg is
 314          */
 315         public BaseSign as_BaseSign() {
 316                 long ret = bindings.InMemorySigner_as_BaseSign(this.ptr);
 317                 Reference.reachabilityFence(this);
 318                 if (ret >= 0 && ret <= 4096) { return null; }
 319                 BaseSign ret_hu_conv = new BaseSign(null, ret);
 320                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 321                 return ret_hu_conv;
 322         }
 323
 324         /**
 325          * Constructs a new Sign which calls the relevant methods on this_arg.
 326          * This copies the `inner` pointer in this_arg and thus the returned Sign must be freed before this_arg is
 327          */
 328         public Sign as_Sign() {
 329                 long ret = bindings.InMemorySigner_as_Sign(this.ptr);
 330                 Reference.reachabilityFence(this);
 331                 if (ret >= 0 && ret <= 4096) { return null; }
 332                 Sign ret_hu_conv = new Sign(null, ret);
 333                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
 334                 return ret_hu_conv;
 335         }
 336
 337         /**
 338          * Serialize the InMemorySigner object into a byte array which can be read by InMemorySigner_read
 339          */
 340         public byte[] write() {
 341                 byte[] ret = bindings.InMemorySigner_write(this.ptr);
 342                 Reference.reachabilityFence(this);
 343                 return ret;
 344         }
 345
 346         /**
 347          * Read a InMemorySigner from a byte array, created by InMemorySigner_write
 348          */
 349         public static Result_InMemorySignerDecodeErrorZ read(byte[] ser, byte[] arg) {
 350                 long ret = bindings.InMemorySigner_read(ser, InternalUtils.check_arr_len(arg, 32));
 351                 Reference.reachabilityFence(ser);
 352                 Reference.reachabilityFence(arg);
 353                 if (ret >= 0 && ret <= 4096) { return null; }
 354                 Result_InMemorySignerDecodeErrorZ ret_hu_conv = Result_InMemorySignerDecodeErrorZ.constr_from_ptr(ret);
 355                 return ret_hu_conv;
 356         }
 357
 358 }