_ Git - ldk-java/blob - src/main/java/org/ldk/structs/InitFeatures.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 an `init` message.
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class InitFeatures extends CommonBase {
  16         InitFeatures(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.InitFeatures_free(ptr); }
  21         }
  22
  23         /**
  24          * Checks if two InitFeaturess contain equal inner contents.
  25          * This ignores pointers and is_owned flags and looks at the values in fields.
  26          * Two objects with NULL inner values will be considered "equal" here.
  27          */
  28         public boolean eq(InitFeatures b) {
  29                 boolean ret = bindings.InitFeatures_eq(this.ptr, b == null ? 0 : b.ptr);
  30                 Reference.reachabilityFence(this);
  31                 Reference.reachabilityFence(b);
  32                 if (this != null) { this.ptrs_to.add(b); };
  33                 return ret;
  34         }
  35
  36         @Override public boolean equals(Object o) {
  37                 if (!(o instanceof InitFeatures)) return false;
  38                 return this.eq((InitFeatures)o);
  39         }
  40         long clone_ptr() {
  41                 long ret = bindings.InitFeatures_clone_ptr(this.ptr);
  42                 Reference.reachabilityFence(this);
  43                 return ret;
  44         }
  45
  46         /**
  47          * Creates a copy of the InitFeatures
  48          */
  49         public InitFeatures clone() {
  50                 long ret = bindings.InitFeatures_clone(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 if (ret >= 0 && ret <= 4096) { return null; }
  53                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  54                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
  55                 return ret_hu_conv;
  56         }
  57
  58         /**
  59          * Returns the set of known init features that are related to channels. At least some of
  60          * these features are likely required for peers to talk to us.
  61          */
  62         public static InitFeatures known_channel_features() {
  63                 long ret = bindings.InitFeatures_known_channel_features();
  64                 if (ret >= 0 && ret <= 4096) { return null; }
  65                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  66                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  67                 return ret_hu_conv;
  68         }
  69
  70         /**
  71          * Create a blank Features with no features set
  72          */
  73         public static InitFeatures empty() {
  74                 long ret = bindings.InitFeatures_empty();
  75                 if (ret >= 0 && ret <= 4096) { return null; }
  76                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  77                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  78                 return ret_hu_conv;
  79         }
  80
  81         /**
  82          * Creates a Features with the bits set which are known by the implementation
  83          */
  84         public static InitFeatures known() {
  85                 long ret = bindings.InitFeatures_known();
  86                 if (ret >= 0 && ret <= 4096) { return null; }
  87                 org.ldk.structs.InitFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.InitFeatures(null, ret); }
  88                 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
  89                 return ret_hu_conv;
  90         }
  91
  92         /**
  93          * Returns true if this `Features` object contains unknown feature flags which are set as
  94          * \"required\".
  95          */
  96         public boolean requires_unknown_bits() {
  97                 boolean ret = bindings.InitFeatures_requires_unknown_bits(this.ptr);
  98                 Reference.reachabilityFence(this);
  99                 return ret;
 100         }
 101
 102         /**
 103          * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
 104          */
 105         public byte[] write() {
 106                 byte[] ret = bindings.InitFeatures_write(this.ptr);
 107                 Reference.reachabilityFence(this);
 108                 return ret;
 109         }
 110
 111         /**
 112          * Read a InitFeatures from a byte array, created by InitFeatures_write
 113          */
 114         public static Result_InitFeaturesDecodeErrorZ read(byte[] ser) {
 115                 long ret = bindings.InitFeatures_read(ser);
 116                 Reference.reachabilityFence(ser);
 117                 if (ret >= 0 && ret <= 4096) { return null; }
 118                 Result_InitFeaturesDecodeErrorZ ret_hu_conv = Result_InitFeaturesDecodeErrorZ.constr_from_ptr(ret);
 119                 return ret_hu_conv;
 120         }
 121
 122         /**
 123          * Set this feature as optional.
 124          */
 125         public void set_data_loss_protect_optional() {
 126                 bindings.InitFeatures_set_data_loss_protect_optional(this.ptr);
 127                 Reference.reachabilityFence(this);
 128         }
 129
 130         /**
 131          * Set this feature as required.
 132          */
 133         public void set_data_loss_protect_required() {
 134                 bindings.InitFeatures_set_data_loss_protect_required(this.ptr);
 135                 Reference.reachabilityFence(this);
 136         }
 137
 138         /**
 139          * Checks if this feature is supported.
 140          */
 141         public boolean supports_data_loss_protect() {
 142                 boolean ret = bindings.InitFeatures_supports_data_loss_protect(this.ptr);
 143                 Reference.reachabilityFence(this);
 144                 return ret;
 145         }
 146
 147         /**
 148          * Checks if this feature is required.
 149          */
 150         public boolean requires_data_loss_protect() {
 151                 boolean ret = bindings.InitFeatures_requires_data_loss_protect(this.ptr);
 152                 Reference.reachabilityFence(this);
 153                 return ret;
 154         }
 155
 156         /**
 157          * Set this feature as optional.
 158          */
 159         public void set_initial_routing_sync_optional() {
 160                 bindings.InitFeatures_set_initial_routing_sync_optional(this.ptr);
 161                 Reference.reachabilityFence(this);
 162         }
 163
 164         /**
 165          * Set this feature as required.
 166          */
 167         public void set_initial_routing_sync_required() {
 168                 bindings.InitFeatures_set_initial_routing_sync_required(this.ptr);
 169                 Reference.reachabilityFence(this);
 170         }
 171
 172         /**
 173          * Checks if this feature is supported.
 174          */
 175         public boolean initial_routing_sync() {
 176                 boolean ret = bindings.InitFeatures_initial_routing_sync(this.ptr);
 177                 Reference.reachabilityFence(this);
 178                 return ret;
 179         }
 180
 181         /**
 182          * Set this feature as optional.
 183          */
 184         public void set_upfront_shutdown_script_optional() {
 185                 bindings.InitFeatures_set_upfront_shutdown_script_optional(this.ptr);
 186                 Reference.reachabilityFence(this);
 187         }
 188
 189         /**
 190          * Set this feature as required.
 191          */
 192         public void set_upfront_shutdown_script_required() {
 193                 bindings.InitFeatures_set_upfront_shutdown_script_required(this.ptr);
 194                 Reference.reachabilityFence(this);
 195         }
 196
 197         /**
 198          * Checks if this feature is supported.
 199          */
 200         public boolean supports_upfront_shutdown_script() {
 201                 boolean ret = bindings.InitFeatures_supports_upfront_shutdown_script(this.ptr);
 202                 Reference.reachabilityFence(this);
 203                 return ret;
 204         }
 205
 206         /**
 207          * Checks if this feature is required.
 208          */
 209         public boolean requires_upfront_shutdown_script() {
 210                 boolean ret = bindings.InitFeatures_requires_upfront_shutdown_script(this.ptr);
 211                 Reference.reachabilityFence(this);
 212                 return ret;
 213         }
 214
 215         /**
 216          * Set this feature as optional.
 217          */
 218         public void set_gossip_queries_optional() {
 219                 bindings.InitFeatures_set_gossip_queries_optional(this.ptr);
 220                 Reference.reachabilityFence(this);
 221         }
 222
 223         /**
 224          * Set this feature as required.
 225          */
 226         public void set_gossip_queries_required() {
 227                 bindings.InitFeatures_set_gossip_queries_required(this.ptr);
 228                 Reference.reachabilityFence(this);
 229         }
 230
 231         /**
 232          * Checks if this feature is supported.
 233          */
 234         public boolean supports_gossip_queries() {
 235                 boolean ret = bindings.InitFeatures_supports_gossip_queries(this.ptr);
 236                 Reference.reachabilityFence(this);
 237                 return ret;
 238         }
 239
 240         /**
 241          * Checks if this feature is required.
 242          */
 243         public boolean requires_gossip_queries() {
 244                 boolean ret = bindings.InitFeatures_requires_gossip_queries(this.ptr);
 245                 Reference.reachabilityFence(this);
 246                 return ret;
 247         }
 248
 249         /**
 250          * Set this feature as optional.
 251          */
 252         public void set_variable_length_onion_optional() {
 253                 bindings.InitFeatures_set_variable_length_onion_optional(this.ptr);
 254                 Reference.reachabilityFence(this);
 255         }
 256
 257         /**
 258          * Set this feature as required.
 259          */
 260         public void set_variable_length_onion_required() {
 261                 bindings.InitFeatures_set_variable_length_onion_required(this.ptr);
 262                 Reference.reachabilityFence(this);
 263         }
 264
 265         /**
 266          * Checks if this feature is supported.
 267          */
 268         public boolean supports_variable_length_onion() {
 269                 boolean ret = bindings.InitFeatures_supports_variable_length_onion(this.ptr);
 270                 Reference.reachabilityFence(this);
 271                 return ret;
 272         }
 273
 274         /**
 275          * Checks if this feature is required.
 276          */
 277         public boolean requires_variable_length_onion() {
 278                 boolean ret = bindings.InitFeatures_requires_variable_length_onion(this.ptr);
 279                 Reference.reachabilityFence(this);
 280                 return ret;
 281         }
 282
 283         /**
 284          * Set this feature as optional.
 285          */
 286         public void set_static_remote_key_optional() {
 287                 bindings.InitFeatures_set_static_remote_key_optional(this.ptr);
 288                 Reference.reachabilityFence(this);
 289         }
 290
 291         /**
 292          * Set this feature as required.
 293          */
 294         public void set_static_remote_key_required() {
 295                 bindings.InitFeatures_set_static_remote_key_required(this.ptr);
 296                 Reference.reachabilityFence(this);
 297         }
 298
 299         /**
 300          * Checks if this feature is supported.
 301          */
 302         public boolean supports_static_remote_key() {
 303                 boolean ret = bindings.InitFeatures_supports_static_remote_key(this.ptr);
 304                 Reference.reachabilityFence(this);
 305                 return ret;
 306         }
 307
 308         /**
 309          * Checks if this feature is required.
 310          */
 311         public boolean requires_static_remote_key() {
 312                 boolean ret = bindings.InitFeatures_requires_static_remote_key(this.ptr);
 313                 Reference.reachabilityFence(this);
 314                 return ret;
 315         }
 316
 317         /**
 318          * Set this feature as optional.
 319          */
 320         public void set_payment_secret_optional() {
 321                 bindings.InitFeatures_set_payment_secret_optional(this.ptr);
 322                 Reference.reachabilityFence(this);
 323         }
 324
 325         /**
 326          * Set this feature as required.
 327          */
 328         public void set_payment_secret_required() {
 329                 bindings.InitFeatures_set_payment_secret_required(this.ptr);
 330                 Reference.reachabilityFence(this);
 331         }
 332
 333         /**
 334          * Checks if this feature is supported.
 335          */
 336         public boolean supports_payment_secret() {
 337                 boolean ret = bindings.InitFeatures_supports_payment_secret(this.ptr);
 338                 Reference.reachabilityFence(this);
 339                 return ret;
 340         }
 341
 342         /**
 343          * Checks if this feature is required.
 344          */
 345         public boolean requires_payment_secret() {
 346                 boolean ret = bindings.InitFeatures_requires_payment_secret(this.ptr);
 347                 Reference.reachabilityFence(this);
 348                 return ret;
 349         }
 350
 351         /**
 352          * Set this feature as optional.
 353          */
 354         public void set_basic_mpp_optional() {
 355                 bindings.InitFeatures_set_basic_mpp_optional(this.ptr);
 356                 Reference.reachabilityFence(this);
 357         }
 358
 359         /**
 360          * Set this feature as required.
 361          */
 362         public void set_basic_mpp_required() {
 363                 bindings.InitFeatures_set_basic_mpp_required(this.ptr);
 364                 Reference.reachabilityFence(this);
 365         }
 366
 367         /**
 368          * Checks if this feature is supported.
 369          */
 370         public boolean supports_basic_mpp() {
 371                 boolean ret = bindings.InitFeatures_supports_basic_mpp(this.ptr);
 372                 Reference.reachabilityFence(this);
 373                 return ret;
 374         }
 375
 376         /**
 377          * Checks if this feature is required.
 378          */
 379         public boolean requires_basic_mpp() {
 380                 boolean ret = bindings.InitFeatures_requires_basic_mpp(this.ptr);
 381                 Reference.reachabilityFence(this);
 382                 return ret;
 383         }
 384
 385         /**
 386          * Set this feature as optional.
 387          */
 388         public void set_wumbo_optional() {
 389                 bindings.InitFeatures_set_wumbo_optional(this.ptr);
 390                 Reference.reachabilityFence(this);
 391         }
 392
 393         /**
 394          * Set this feature as required.
 395          */
 396         public void set_wumbo_required() {
 397                 bindings.InitFeatures_set_wumbo_required(this.ptr);
 398                 Reference.reachabilityFence(this);
 399         }
 400
 401         /**
 402          * Checks if this feature is supported.
 403          */
 404         public boolean supports_wumbo() {
 405                 boolean ret = bindings.InitFeatures_supports_wumbo(this.ptr);
 406                 Reference.reachabilityFence(this);
 407                 return ret;
 408         }
 409
 410         /**
 411          * Checks if this feature is required.
 412          */
 413         public boolean requires_wumbo() {
 414                 boolean ret = bindings.InitFeatures_requires_wumbo(this.ptr);
 415                 Reference.reachabilityFence(this);
 416                 return ret;
 417         }
 418
 419         /**
 420          * Set this feature as optional.
 421          */
 422         public void set_shutdown_any_segwit_optional() {
 423                 bindings.InitFeatures_set_shutdown_any_segwit_optional(this.ptr);
 424                 Reference.reachabilityFence(this);
 425         }
 426
 427         /**
 428          * Set this feature as required.
 429          */
 430         public void set_shutdown_any_segwit_required() {
 431                 bindings.InitFeatures_set_shutdown_any_segwit_required(this.ptr);
 432                 Reference.reachabilityFence(this);
 433         }
 434
 435         /**
 436          * Checks if this feature is supported.
 437          */
 438         public boolean supports_shutdown_anysegwit() {
 439                 boolean ret = bindings.InitFeatures_supports_shutdown_anysegwit(this.ptr);
 440                 Reference.reachabilityFence(this);
 441                 return ret;
 442         }
 443
 444         /**
 445          * Checks if this feature is required.
 446          */
 447         public boolean requires_shutdown_anysegwit() {
 448                 boolean ret = bindings.InitFeatures_requires_shutdown_anysegwit(this.ptr);
 449                 Reference.reachabilityFence(this);
 450                 return ret;
 451         }
 452
 453         /**
 454          * Set this feature as optional.
 455          */
 456         public void set_onion_messages_optional() {
 457                 bindings.InitFeatures_set_onion_messages_optional(this.ptr);
 458                 Reference.reachabilityFence(this);
 459         }
 460
 461         /**
 462          * Set this feature as required.
 463          */
 464         public void set_onion_messages_required() {
 465                 bindings.InitFeatures_set_onion_messages_required(this.ptr);
 466                 Reference.reachabilityFence(this);
 467         }
 468
 469         /**
 470          * Checks if this feature is supported.
 471          */
 472         public boolean supports_onion_messages() {
 473                 boolean ret = bindings.InitFeatures_supports_onion_messages(this.ptr);
 474                 Reference.reachabilityFence(this);
 475                 return ret;
 476         }
 477
 478         /**
 479          * Checks if this feature is required.
 480          */
 481         public boolean requires_onion_messages() {
 482                 boolean ret = bindings.InitFeatures_requires_onion_messages(this.ptr);
 483                 Reference.reachabilityFence(this);
 484                 return ret;
 485         }
 486
 487         /**
 488          * Set this feature as optional.
 489          */
 490         public void set_channel_type_optional() {
 491                 bindings.InitFeatures_set_channel_type_optional(this.ptr);
 492                 Reference.reachabilityFence(this);
 493         }
 494
 495         /**
 496          * Set this feature as required.
 497          */
 498         public void set_channel_type_required() {
 499                 bindings.InitFeatures_set_channel_type_required(this.ptr);
 500                 Reference.reachabilityFence(this);
 501         }
 502
 503         /**
 504          * Checks if this feature is supported.
 505          */
 506         public boolean supports_channel_type() {
 507                 boolean ret = bindings.InitFeatures_supports_channel_type(this.ptr);
 508                 Reference.reachabilityFence(this);
 509                 return ret;
 510         }
 511
 512         /**
 513          * Checks if this feature is required.
 514          */
 515         public boolean requires_channel_type() {
 516                 boolean ret = bindings.InitFeatures_requires_channel_type(this.ptr);
 517                 Reference.reachabilityFence(this);
 518                 return ret;
 519         }
 520
 521         /**
 522          * Set this feature as optional.
 523          */
 524         public void set_scid_privacy_optional() {
 525                 bindings.InitFeatures_set_scid_privacy_optional(this.ptr);
 526                 Reference.reachabilityFence(this);
 527         }
 528
 529         /**
 530          * Set this feature as required.
 531          */
 532         public void set_scid_privacy_required() {
 533                 bindings.InitFeatures_set_scid_privacy_required(this.ptr);
 534                 Reference.reachabilityFence(this);
 535         }
 536
 537         /**
 538          * Checks if this feature is supported.
 539          */
 540         public boolean supports_scid_privacy() {
 541                 boolean ret = bindings.InitFeatures_supports_scid_privacy(this.ptr);
 542                 Reference.reachabilityFence(this);
 543                 return ret;
 544         }
 545
 546         /**
 547          * Checks if this feature is required.
 548          */
 549         public boolean requires_scid_privacy() {
 550                 boolean ret = bindings.InitFeatures_requires_scid_privacy(this.ptr);
 551                 Reference.reachabilityFence(this);
 552                 return ret;
 553         }
 554
 555         /**
 556          * Set this feature as optional.
 557          */
 558         public void set_zero_conf_optional() {
 559                 bindings.InitFeatures_set_zero_conf_optional(this.ptr);
 560                 Reference.reachabilityFence(this);
 561         }
 562
 563         /**
 564          * Set this feature as required.
 565          */
 566         public void set_zero_conf_required() {
 567                 bindings.InitFeatures_set_zero_conf_required(this.ptr);
 568                 Reference.reachabilityFence(this);
 569         }
 570
 571         /**
 572          * Checks if this feature is supported.
 573          */
 574         public boolean supports_zero_conf() {
 575                 boolean ret = bindings.InitFeatures_supports_zero_conf(this.ptr);
 576                 Reference.reachabilityFence(this);
 577                 return ret;
 578         }
 579
 580         /**
 581          * Checks if this feature is required.
 582          */
 583         public boolean requires_zero_conf() {
 584                 boolean ret = bindings.InitFeatures_requires_zero_conf(this.ptr);
 585                 Reference.reachabilityFence(this);
 586                 return ret;
 587         }
 588
 589 }