_ Git - ldk-java/blob - src/main/java/org/ldk/structs/ChannelTypeFeatures.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  * Features used within the channel_type field in an OpenChannel message.
  13  *
  14  * A channel is always of some known \"type\", describing the transaction formats used and the exact
  15  * semantics of our interaction with our peer.
  16  *
  17  * Note that because a channel is a specific type which is proposed by the opener and accepted by
  18  * the counterparty, only required features are allowed here.
  19  *
  20  * This is serialized differently from other feature types - it is not prefixed by a length, and
  21  * thus must only appear inside a TLV where its length is known in advance.
  22  */
  23 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  24 public class ChannelTypeFeatures extends CommonBase {
  25         ChannelTypeFeatures(Object _dummy, long ptr) { super(ptr); }
  26         @Override @SuppressWarnings("deprecation")
  27         protected void finalize() throws Throwable {
  28                 super.finalize();
  29                 if (ptr != 0) { bindings.ChannelTypeFeatures_free(ptr); }
  30         }
  31
  32         /**
  33          * Checks if two ChannelTypeFeaturess contain equal inner contents.
  34          * This ignores pointers and is_owned flags and looks at the values in fields.
  35          * Two objects with NULL inner values will be considered "equal" here.
  36          */
  37         public boolean eq(ChannelTypeFeatures b) {
  38                 boolean ret = bindings.ChannelTypeFeatures_eq(this.ptr, b == null ? 0 : b.ptr);
  39                 Reference.reachabilityFence(this);
  40                 Reference.reachabilityFence(b);
  41                 this.ptrs_to.add(b);
  42                 return ret;
  43         }
  44
  45         @Override public boolean equals(Object o) {
  46                 if (!(o instanceof ChannelTypeFeatures)) return false;
  47                 return this.eq((ChannelTypeFeatures)o);
  48         }
  49         long clone_ptr() {
  50                 long ret = bindings.ChannelTypeFeatures_clone_ptr(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 return ret;
  53         }
  54
  55         /**
  56          * Creates a copy of the ChannelTypeFeatures
  57          */
  58         public ChannelTypeFeatures clone() {
  59                 long ret = bindings.ChannelTypeFeatures_clone(this.ptr);
  60                 Reference.reachabilityFence(this);
  61                 if (ret >= 0 && ret <= 4096) { return null; }
  62                 org.ldk.structs.ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelTypeFeatures(null, ret); }
  63                 ret_hu_conv.ptrs_to.add(this);
  64                 return ret_hu_conv;
  65         }
  66
  67         /**
  68          * Create a blank Features with no features set
  69          */
  70         public static ChannelTypeFeatures empty() {
  71                 long ret = bindings.ChannelTypeFeatures_empty();
  72                 if (ret >= 0 && ret <= 4096) { return null; }
  73                 org.ldk.structs.ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelTypeFeatures(null, ret); }
  74                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  75                 return ret_hu_conv;
  76         }
  77
  78         /**
  79          * Creates a Features with the bits set which are known by the implementation
  80          */
  81         public static ChannelTypeFeatures known() {
  82                 long ret = bindings.ChannelTypeFeatures_known();
  83                 if (ret >= 0 && ret <= 4096) { return null; }
  84                 org.ldk.structs.ChannelTypeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.ChannelTypeFeatures(null, ret); }
  85                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  86                 return ret_hu_conv;
  87         }
  88
  89         /**
  90          * Returns true if this `Features` object contains unknown feature flags which are set as
  91          * \"required\".
  92          */
  93         public boolean requires_unknown_bits() {
  94                 boolean ret = bindings.ChannelTypeFeatures_requires_unknown_bits(this.ptr);
  95                 Reference.reachabilityFence(this);
  96                 return ret;
  97         }
  98
  99         /**
 100          * Serialize the ChannelTypeFeatures object into a byte array which can be read by ChannelTypeFeatures_read
 101          */
 102         public byte[] write() {
 103                 byte[] ret = bindings.ChannelTypeFeatures_write(this.ptr);
 104                 Reference.reachabilityFence(this);
 105                 return ret;
 106         }
 107
 108         /**
 109          * Read a ChannelTypeFeatures from a byte array, created by ChannelTypeFeatures_write
 110          */
 111         public static Result_ChannelTypeFeaturesDecodeErrorZ read(byte[] ser) {
 112                 long ret = bindings.ChannelTypeFeatures_read(ser);
 113                 Reference.reachabilityFence(ser);
 114                 if (ret >= 0 && ret <= 4096) { return null; }
 115                 Result_ChannelTypeFeaturesDecodeErrorZ ret_hu_conv = Result_ChannelTypeFeaturesDecodeErrorZ.constr_from_ptr(ret);
 116                 return ret_hu_conv;
 117         }
 118
 119         /**
 120          * Set this feature as optional.
 121          */
 122         public void set_static_remote_key_optional() {
 123                 bindings.ChannelTypeFeatures_set_static_remote_key_optional(this.ptr);
 124                 Reference.reachabilityFence(this);
 125         }
 126
 127         /**
 128          * Set this feature as required.
 129          */
 130         public void set_static_remote_key_required() {
 131                 bindings.ChannelTypeFeatures_set_static_remote_key_required(this.ptr);
 132                 Reference.reachabilityFence(this);
 133         }
 134
 135         /**
 136          * Checks if this feature is supported.
 137          */
 138         public boolean supports_static_remote_key() {
 139                 boolean ret = bindings.ChannelTypeFeatures_supports_static_remote_key(this.ptr);
 140                 Reference.reachabilityFence(this);
 141                 return ret;
 142         }
 143
 144         /**
 145          * Checks if this feature is required.
 146          */
 147         public boolean requires_static_remote_key() {
 148                 boolean ret = bindings.ChannelTypeFeatures_requires_static_remote_key(this.ptr);
 149                 Reference.reachabilityFence(this);
 150                 return ret;
 151         }
 152
 153         /**
 154          * Set this feature as optional.
 155          */
 156         public void set_scid_privacy_optional() {
 157                 bindings.ChannelTypeFeatures_set_scid_privacy_optional(this.ptr);
 158                 Reference.reachabilityFence(this);
 159         }
 160
 161         /**
 162          * Set this feature as required.
 163          */
 164         public void set_scid_privacy_required() {
 165                 bindings.ChannelTypeFeatures_set_scid_privacy_required(this.ptr);
 166                 Reference.reachabilityFence(this);
 167         }
 168
 169         /**
 170          * Checks if this feature is supported.
 171          */
 172         public boolean supports_scid_privacy() {
 173                 boolean ret = bindings.ChannelTypeFeatures_supports_scid_privacy(this.ptr);
 174                 Reference.reachabilityFence(this);
 175                 return ret;
 176         }
 177
 178         /**
 179          * Checks if this feature is required.
 180          */
 181         public boolean requires_scid_privacy() {
 182                 boolean ret = bindings.ChannelTypeFeatures_requires_scid_privacy(this.ptr);
 183                 Reference.reachabilityFence(this);
 184                 return ret;
 185         }
 186
 187         /**
 188          * Set this feature as optional.
 189          */
 190         public void set_zero_conf_optional() {
 191                 bindings.ChannelTypeFeatures_set_zero_conf_optional(this.ptr);
 192                 Reference.reachabilityFence(this);
 193         }
 194
 195         /**
 196          * Set this feature as required.
 197          */
 198         public void set_zero_conf_required() {
 199                 bindings.ChannelTypeFeatures_set_zero_conf_required(this.ptr);
 200                 Reference.reachabilityFence(this);
 201         }
 202
 203         /**
 204          * Checks if this feature is supported.
 205          */
 206         public boolean supports_zero_conf() {
 207                 boolean ret = bindings.ChannelTypeFeatures_supports_zero_conf(this.ptr);
 208                 Reference.reachabilityFence(this);
 209                 return ret;
 210         }
 211
 212         /**
 213          * Checks if this feature is required.
 214          */
 215         public boolean requires_zero_conf() {
 216                 boolean ret = bindings.ChannelTypeFeatures_requires_zero_conf(this.ptr);
 217                 Reference.reachabilityFence(this);
 218                 return ret;
 219         }
 220
 221 }