_ 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(org.ldk.structs.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          * Generates a non-cryptographic 64-bit hash of the InitFeatures.
  60          */
  61         public long hash() {
  62                 long ret = bindings.InitFeatures_hash(this.ptr);
  63                 Reference.reachabilityFence(this);
  64                 return ret;
  65         }
  66
  67         @Override public int hashCode() {
  68                 return (int)this.hash();
  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          * Returns true if this `Features` object contains required features unknown by `other`.
  83          */
  84         public boolean requires_unknown_bits_from(org.ldk.structs.InitFeatures other) {
  85                 boolean ret = bindings.InitFeatures_requires_unknown_bits_from(this.ptr, other == null ? 0 : other.ptr);
  86                 Reference.reachabilityFence(this);
  87                 Reference.reachabilityFence(other);
  88                 if (this != null) { this.ptrs_to.add(other); };
  89                 return ret;
  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          * Sets a required feature bit. Errors if `bit` is outside the feature range as defined
 104          * by [BOLT 9].
 105          *
 106          * Note: Required bits are even. If an odd bit is given, then the corresponding even bit will
 107          * be set instead (i.e., `bit - 1`).
 108          *
 109          * [BOLT 9]: https://github.com/lightning/bolts/blob/master/09-features.md
 110          */
 111         public Result_NoneNoneZ set_required_feature_bit(long bit) {
 112                 long ret = bindings.InitFeatures_set_required_feature_bit(this.ptr, bit);
 113                 Reference.reachabilityFence(this);
 114                 Reference.reachabilityFence(bit);
 115                 if (ret >= 0 && ret <= 4096) { return null; }
 116                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 117                 return ret_hu_conv;
 118         }
 119
 120         /**
 121          * Sets an optional feature bit. Errors if `bit` is outside the feature range as defined
 122          * by [BOLT 9].
 123          *
 124          * Note: Optional bits are odd. If an even bit is given, then the corresponding odd bit will be
 125          * set instead (i.e., `bit + 1`).
 126          *
 127          * [BOLT 9]: https://github.com/lightning/bolts/blob/master/09-features.md
 128          */
 129         public Result_NoneNoneZ set_optional_feature_bit(long bit) {
 130                 long ret = bindings.InitFeatures_set_optional_feature_bit(this.ptr, bit);
 131                 Reference.reachabilityFence(this);
 132                 Reference.reachabilityFence(bit);
 133                 if (ret >= 0 && ret <= 4096) { return null; }
 134                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 135                 return ret_hu_conv;
 136         }
 137
 138         /**
 139          * Sets a required custom feature bit. Errors if `bit` is outside the custom range as defined
 140          * by [bLIP 2] or if it is a known `T` feature.
 141          *
 142          * Note: Required bits are even. If an odd bit is given, then the corresponding even bit will
 143          * be set instead (i.e., `bit - 1`).
 144          *
 145          * [bLIP 2]: https://github.com/lightning/blips/blob/master/blip-0002.md#feature-bits
 146          */
 147         public Result_NoneNoneZ set_required_custom_bit(long bit) {
 148                 long ret = bindings.InitFeatures_set_required_custom_bit(this.ptr, bit);
 149                 Reference.reachabilityFence(this);
 150                 Reference.reachabilityFence(bit);
 151                 if (ret >= 0 && ret <= 4096) { return null; }
 152                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 153                 return ret_hu_conv;
 154         }
 155
 156         /**
 157          * Sets an optional custom feature bit. Errors if `bit` is outside the custom range as defined
 158          * by [bLIP 2] or if it is a known `T` feature.
 159          *
 160          * Note: Optional bits are odd. If an even bit is given, then the corresponding odd bit will be
 161          * set instead (i.e., `bit + 1`).
 162          *
 163          * [bLIP 2]: https://github.com/lightning/blips/blob/master/blip-0002.md#feature-bits
 164          */
 165         public Result_NoneNoneZ set_optional_custom_bit(long bit) {
 166                 long ret = bindings.InitFeatures_set_optional_custom_bit(this.ptr, bit);
 167                 Reference.reachabilityFence(this);
 168                 Reference.reachabilityFence(bit);
 169                 if (ret >= 0 && ret <= 4096) { return null; }
 170                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 171                 return ret_hu_conv;
 172         }
 173
 174         /**
 175          * Serialize the InitFeatures object into a byte array which can be read by InitFeatures_read
 176          */
 177         public byte[] write() {
 178                 byte[] ret = bindings.InitFeatures_write(this.ptr);
 179                 Reference.reachabilityFence(this);
 180                 return ret;
 181         }
 182
 183         /**
 184          * Read a InitFeatures from a byte array, created by InitFeatures_write
 185          */
 186         public static Result_InitFeaturesDecodeErrorZ read(byte[] ser) {
 187                 long ret = bindings.InitFeatures_read(ser);
 188                 Reference.reachabilityFence(ser);
 189                 if (ret >= 0 && ret <= 4096) { return null; }
 190                 Result_InitFeaturesDecodeErrorZ ret_hu_conv = Result_InitFeaturesDecodeErrorZ.constr_from_ptr(ret);
 191                 return ret_hu_conv;
 192         }
 193
 194         /**
 195          * Set this feature as optional.
 196          */
 197         public void set_data_loss_protect_optional() {
 198                 bindings.InitFeatures_set_data_loss_protect_optional(this.ptr);
 199                 Reference.reachabilityFence(this);
 200         }
 201
 202         /**
 203          * Set this feature as required.
 204          */
 205         public void set_data_loss_protect_required() {
 206                 bindings.InitFeatures_set_data_loss_protect_required(this.ptr);
 207                 Reference.reachabilityFence(this);
 208         }
 209
 210         /**
 211          * Checks if this feature is supported.
 212          */
 213         public boolean supports_data_loss_protect() {
 214                 boolean ret = bindings.InitFeatures_supports_data_loss_protect(this.ptr);
 215                 Reference.reachabilityFence(this);
 216                 return ret;
 217         }
 218
 219         /**
 220          * Checks if this feature is required.
 221          */
 222         public boolean requires_data_loss_protect() {
 223                 boolean ret = bindings.InitFeatures_requires_data_loss_protect(this.ptr);
 224                 Reference.reachabilityFence(this);
 225                 return ret;
 226         }
 227
 228         /**
 229          * Set this feature as optional.
 230          */
 231         public void set_initial_routing_sync_optional() {
 232                 bindings.InitFeatures_set_initial_routing_sync_optional(this.ptr);
 233                 Reference.reachabilityFence(this);
 234         }
 235
 236         /**
 237          * Set this feature as required.
 238          */
 239         public void set_initial_routing_sync_required() {
 240                 bindings.InitFeatures_set_initial_routing_sync_required(this.ptr);
 241                 Reference.reachabilityFence(this);
 242         }
 243
 244         /**
 245          * Checks if this feature is supported.
 246          */
 247         public boolean initial_routing_sync() {
 248                 boolean ret = bindings.InitFeatures_initial_routing_sync(this.ptr);
 249                 Reference.reachabilityFence(this);
 250                 return ret;
 251         }
 252
 253         /**
 254          * Set this feature as optional.
 255          */
 256         public void set_upfront_shutdown_script_optional() {
 257                 bindings.InitFeatures_set_upfront_shutdown_script_optional(this.ptr);
 258                 Reference.reachabilityFence(this);
 259         }
 260
 261         /**
 262          * Set this feature as required.
 263          */
 264         public void set_upfront_shutdown_script_required() {
 265                 bindings.InitFeatures_set_upfront_shutdown_script_required(this.ptr);
 266                 Reference.reachabilityFence(this);
 267         }
 268
 269         /**
 270          * Checks if this feature is supported.
 271          */
 272         public boolean supports_upfront_shutdown_script() {
 273                 boolean ret = bindings.InitFeatures_supports_upfront_shutdown_script(this.ptr);
 274                 Reference.reachabilityFence(this);
 275                 return ret;
 276         }
 277
 278         /**
 279          * Checks if this feature is required.
 280          */
 281         public boolean requires_upfront_shutdown_script() {
 282                 boolean ret = bindings.InitFeatures_requires_upfront_shutdown_script(this.ptr);
 283                 Reference.reachabilityFence(this);
 284                 return ret;
 285         }
 286
 287         /**
 288          * Set this feature as optional.
 289          */
 290         public void set_gossip_queries_optional() {
 291                 bindings.InitFeatures_set_gossip_queries_optional(this.ptr);
 292                 Reference.reachabilityFence(this);
 293         }
 294
 295         /**
 296          * Set this feature as required.
 297          */
 298         public void set_gossip_queries_required() {
 299                 bindings.InitFeatures_set_gossip_queries_required(this.ptr);
 300                 Reference.reachabilityFence(this);
 301         }
 302
 303         /**
 304          * Checks if this feature is supported.
 305          */
 306         public boolean supports_gossip_queries() {
 307                 boolean ret = bindings.InitFeatures_supports_gossip_queries(this.ptr);
 308                 Reference.reachabilityFence(this);
 309                 return ret;
 310         }
 311
 312         /**
 313          * Checks if this feature is required.
 314          */
 315         public boolean requires_gossip_queries() {
 316                 boolean ret = bindings.InitFeatures_requires_gossip_queries(this.ptr);
 317                 Reference.reachabilityFence(this);
 318                 return ret;
 319         }
 320
 321         /**
 322          * Set this feature as optional.
 323          */
 324         public void set_variable_length_onion_optional() {
 325                 bindings.InitFeatures_set_variable_length_onion_optional(this.ptr);
 326                 Reference.reachabilityFence(this);
 327         }
 328
 329         /**
 330          * Set this feature as required.
 331          */
 332         public void set_variable_length_onion_required() {
 333                 bindings.InitFeatures_set_variable_length_onion_required(this.ptr);
 334                 Reference.reachabilityFence(this);
 335         }
 336
 337         /**
 338          * Checks if this feature is supported.
 339          */
 340         public boolean supports_variable_length_onion() {
 341                 boolean ret = bindings.InitFeatures_supports_variable_length_onion(this.ptr);
 342                 Reference.reachabilityFence(this);
 343                 return ret;
 344         }
 345
 346         /**
 347          * Checks if this feature is required.
 348          */
 349         public boolean requires_variable_length_onion() {
 350                 boolean ret = bindings.InitFeatures_requires_variable_length_onion(this.ptr);
 351                 Reference.reachabilityFence(this);
 352                 return ret;
 353         }
 354
 355         /**
 356          * Set this feature as optional.
 357          */
 358         public void set_static_remote_key_optional() {
 359                 bindings.InitFeatures_set_static_remote_key_optional(this.ptr);
 360                 Reference.reachabilityFence(this);
 361         }
 362
 363         /**
 364          * Set this feature as required.
 365          */
 366         public void set_static_remote_key_required() {
 367                 bindings.InitFeatures_set_static_remote_key_required(this.ptr);
 368                 Reference.reachabilityFence(this);
 369         }
 370
 371         /**
 372          * Checks if this feature is supported.
 373          */
 374         public boolean supports_static_remote_key() {
 375                 boolean ret = bindings.InitFeatures_supports_static_remote_key(this.ptr);
 376                 Reference.reachabilityFence(this);
 377                 return ret;
 378         }
 379
 380         /**
 381          * Checks if this feature is required.
 382          */
 383         public boolean requires_static_remote_key() {
 384                 boolean ret = bindings.InitFeatures_requires_static_remote_key(this.ptr);
 385                 Reference.reachabilityFence(this);
 386                 return ret;
 387         }
 388
 389         /**
 390          * Set this feature as optional.
 391          */
 392         public void set_payment_secret_optional() {
 393                 bindings.InitFeatures_set_payment_secret_optional(this.ptr);
 394                 Reference.reachabilityFence(this);
 395         }
 396
 397         /**
 398          * Set this feature as required.
 399          */
 400         public void set_payment_secret_required() {
 401                 bindings.InitFeatures_set_payment_secret_required(this.ptr);
 402                 Reference.reachabilityFence(this);
 403         }
 404
 405         /**
 406          * Checks if this feature is supported.
 407          */
 408         public boolean supports_payment_secret() {
 409                 boolean ret = bindings.InitFeatures_supports_payment_secret(this.ptr);
 410                 Reference.reachabilityFence(this);
 411                 return ret;
 412         }
 413
 414         /**
 415          * Checks if this feature is required.
 416          */
 417         public boolean requires_payment_secret() {
 418                 boolean ret = bindings.InitFeatures_requires_payment_secret(this.ptr);
 419                 Reference.reachabilityFence(this);
 420                 return ret;
 421         }
 422
 423         /**
 424          * Set this feature as optional.
 425          */
 426         public void set_basic_mpp_optional() {
 427                 bindings.InitFeatures_set_basic_mpp_optional(this.ptr);
 428                 Reference.reachabilityFence(this);
 429         }
 430
 431         /**
 432          * Set this feature as required.
 433          */
 434         public void set_basic_mpp_required() {
 435                 bindings.InitFeatures_set_basic_mpp_required(this.ptr);
 436                 Reference.reachabilityFence(this);
 437         }
 438
 439         /**
 440          * Checks if this feature is supported.
 441          */
 442         public boolean supports_basic_mpp() {
 443                 boolean ret = bindings.InitFeatures_supports_basic_mpp(this.ptr);
 444                 Reference.reachabilityFence(this);
 445                 return ret;
 446         }
 447
 448         /**
 449          * Checks if this feature is required.
 450          */
 451         public boolean requires_basic_mpp() {
 452                 boolean ret = bindings.InitFeatures_requires_basic_mpp(this.ptr);
 453                 Reference.reachabilityFence(this);
 454                 return ret;
 455         }
 456
 457         /**
 458          * Set this feature as optional.
 459          */
 460         public void set_wumbo_optional() {
 461                 bindings.InitFeatures_set_wumbo_optional(this.ptr);
 462                 Reference.reachabilityFence(this);
 463         }
 464
 465         /**
 466          * Set this feature as required.
 467          */
 468         public void set_wumbo_required() {
 469                 bindings.InitFeatures_set_wumbo_required(this.ptr);
 470                 Reference.reachabilityFence(this);
 471         }
 472
 473         /**
 474          * Checks if this feature is supported.
 475          */
 476         public boolean supports_wumbo() {
 477                 boolean ret = bindings.InitFeatures_supports_wumbo(this.ptr);
 478                 Reference.reachabilityFence(this);
 479                 return ret;
 480         }
 481
 482         /**
 483          * Checks if this feature is required.
 484          */
 485         public boolean requires_wumbo() {
 486                 boolean ret = bindings.InitFeatures_requires_wumbo(this.ptr);
 487                 Reference.reachabilityFence(this);
 488                 return ret;
 489         }
 490
 491         /**
 492          * Set this feature as optional.
 493          */
 494         public void set_anchors_nonzero_fee_htlc_tx_optional() {
 495                 bindings.InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this.ptr);
 496                 Reference.reachabilityFence(this);
 497         }
 498
 499         /**
 500          * Set this feature as required.
 501          */
 502         public void set_anchors_nonzero_fee_htlc_tx_required() {
 503                 bindings.InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(this.ptr);
 504                 Reference.reachabilityFence(this);
 505         }
 506
 507         /**
 508          * Checks if this feature is supported.
 509          */
 510         public boolean supports_anchors_nonzero_fee_htlc_tx() {
 511                 boolean ret = bindings.InitFeatures_supports_anchors_nonzero_fee_htlc_tx(this.ptr);
 512                 Reference.reachabilityFence(this);
 513                 return ret;
 514         }
 515
 516         /**
 517          * Checks if this feature is required.
 518          */
 519         public boolean requires_anchors_nonzero_fee_htlc_tx() {
 520                 boolean ret = bindings.InitFeatures_requires_anchors_nonzero_fee_htlc_tx(this.ptr);
 521                 Reference.reachabilityFence(this);
 522                 return ret;
 523         }
 524
 525         /**
 526          * Set this feature as optional.
 527          */
 528         public void set_anchors_zero_fee_htlc_tx_optional() {
 529                 bindings.InitFeatures_set_anchors_zero_fee_htlc_tx_optional(this.ptr);
 530                 Reference.reachabilityFence(this);
 531         }
 532
 533         /**
 534          * Set this feature as required.
 535          */
 536         public void set_anchors_zero_fee_htlc_tx_required() {
 537                 bindings.InitFeatures_set_anchors_zero_fee_htlc_tx_required(this.ptr);
 538                 Reference.reachabilityFence(this);
 539         }
 540
 541         /**
 542          * Checks if this feature is supported.
 543          */
 544         public boolean supports_anchors_zero_fee_htlc_tx() {
 545                 boolean ret = bindings.InitFeatures_supports_anchors_zero_fee_htlc_tx(this.ptr);
 546                 Reference.reachabilityFence(this);
 547                 return ret;
 548         }
 549
 550         /**
 551          * Checks if this feature is required.
 552          */
 553         public boolean requires_anchors_zero_fee_htlc_tx() {
 554                 boolean ret = bindings.InitFeatures_requires_anchors_zero_fee_htlc_tx(this.ptr);
 555                 Reference.reachabilityFence(this);
 556                 return ret;
 557         }
 558
 559         /**
 560          * Set this feature as optional.
 561          */
 562         public void set_route_blinding_optional() {
 563                 bindings.InitFeatures_set_route_blinding_optional(this.ptr);
 564                 Reference.reachabilityFence(this);
 565         }
 566
 567         /**
 568          * Set this feature as required.
 569          */
 570         public void set_route_blinding_required() {
 571                 bindings.InitFeatures_set_route_blinding_required(this.ptr);
 572                 Reference.reachabilityFence(this);
 573         }
 574
 575         /**
 576          * Checks if this feature is supported.
 577          */
 578         public boolean supports_route_blinding() {
 579                 boolean ret = bindings.InitFeatures_supports_route_blinding(this.ptr);
 580                 Reference.reachabilityFence(this);
 581                 return ret;
 582         }
 583
 584         /**
 585          * Checks if this feature is required.
 586          */
 587         public boolean requires_route_blinding() {
 588                 boolean ret = bindings.InitFeatures_requires_route_blinding(this.ptr);
 589                 Reference.reachabilityFence(this);
 590                 return ret;
 591         }
 592
 593         /**
 594          * Set this feature as optional.
 595          */
 596         public void set_shutdown_any_segwit_optional() {
 597                 bindings.InitFeatures_set_shutdown_any_segwit_optional(this.ptr);
 598                 Reference.reachabilityFence(this);
 599         }
 600
 601         /**
 602          * Set this feature as required.
 603          */
 604         public void set_shutdown_any_segwit_required() {
 605                 bindings.InitFeatures_set_shutdown_any_segwit_required(this.ptr);
 606                 Reference.reachabilityFence(this);
 607         }
 608
 609         /**
 610          * Checks if this feature is supported.
 611          */
 612         public boolean supports_shutdown_anysegwit() {
 613                 boolean ret = bindings.InitFeatures_supports_shutdown_anysegwit(this.ptr);
 614                 Reference.reachabilityFence(this);
 615                 return ret;
 616         }
 617
 618         /**
 619          * Checks if this feature is required.
 620          */
 621         public boolean requires_shutdown_anysegwit() {
 622                 boolean ret = bindings.InitFeatures_requires_shutdown_anysegwit(this.ptr);
 623                 Reference.reachabilityFence(this);
 624                 return ret;
 625         }
 626
 627         /**
 628          * Set this feature as optional.
 629          */
 630         public void set_taproot_optional() {
 631                 bindings.InitFeatures_set_taproot_optional(this.ptr);
 632                 Reference.reachabilityFence(this);
 633         }
 634
 635         /**
 636          * Set this feature as required.
 637          */
 638         public void set_taproot_required() {
 639                 bindings.InitFeatures_set_taproot_required(this.ptr);
 640                 Reference.reachabilityFence(this);
 641         }
 642
 643         /**
 644          * Checks if this feature is supported.
 645          */
 646         public boolean supports_taproot() {
 647                 boolean ret = bindings.InitFeatures_supports_taproot(this.ptr);
 648                 Reference.reachabilityFence(this);
 649                 return ret;
 650         }
 651
 652         /**
 653          * Checks if this feature is required.
 654          */
 655         public boolean requires_taproot() {
 656                 boolean ret = bindings.InitFeatures_requires_taproot(this.ptr);
 657                 Reference.reachabilityFence(this);
 658                 return ret;
 659         }
 660
 661         /**
 662          * Set this feature as optional.
 663          */
 664         public void set_onion_messages_optional() {
 665                 bindings.InitFeatures_set_onion_messages_optional(this.ptr);
 666                 Reference.reachabilityFence(this);
 667         }
 668
 669         /**
 670          * Set this feature as required.
 671          */
 672         public void set_onion_messages_required() {
 673                 bindings.InitFeatures_set_onion_messages_required(this.ptr);
 674                 Reference.reachabilityFence(this);
 675         }
 676
 677         /**
 678          * Checks if this feature is supported.
 679          */
 680         public boolean supports_onion_messages() {
 681                 boolean ret = bindings.InitFeatures_supports_onion_messages(this.ptr);
 682                 Reference.reachabilityFence(this);
 683                 return ret;
 684         }
 685
 686         /**
 687          * Checks if this feature is required.
 688          */
 689         public boolean requires_onion_messages() {
 690                 boolean ret = bindings.InitFeatures_requires_onion_messages(this.ptr);
 691                 Reference.reachabilityFence(this);
 692                 return ret;
 693         }
 694
 695         /**
 696          * Set this feature as optional.
 697          */
 698         public void set_channel_type_optional() {
 699                 bindings.InitFeatures_set_channel_type_optional(this.ptr);
 700                 Reference.reachabilityFence(this);
 701         }
 702
 703         /**
 704          * Set this feature as required.
 705          */
 706         public void set_channel_type_required() {
 707                 bindings.InitFeatures_set_channel_type_required(this.ptr);
 708                 Reference.reachabilityFence(this);
 709         }
 710
 711         /**
 712          * Checks if this feature is supported.
 713          */
 714         public boolean supports_channel_type() {
 715                 boolean ret = bindings.InitFeatures_supports_channel_type(this.ptr);
 716                 Reference.reachabilityFence(this);
 717                 return ret;
 718         }
 719
 720         /**
 721          * Checks if this feature is required.
 722          */
 723         public boolean requires_channel_type() {
 724                 boolean ret = bindings.InitFeatures_requires_channel_type(this.ptr);
 725                 Reference.reachabilityFence(this);
 726                 return ret;
 727         }
 728
 729         /**
 730          * Set this feature as optional.
 731          */
 732         public void set_scid_privacy_optional() {
 733                 bindings.InitFeatures_set_scid_privacy_optional(this.ptr);
 734                 Reference.reachabilityFence(this);
 735         }
 736
 737         /**
 738          * Set this feature as required.
 739          */
 740         public void set_scid_privacy_required() {
 741                 bindings.InitFeatures_set_scid_privacy_required(this.ptr);
 742                 Reference.reachabilityFence(this);
 743         }
 744
 745         /**
 746          * Checks if this feature is supported.
 747          */
 748         public boolean supports_scid_privacy() {
 749                 boolean ret = bindings.InitFeatures_supports_scid_privacy(this.ptr);
 750                 Reference.reachabilityFence(this);
 751                 return ret;
 752         }
 753
 754         /**
 755          * Checks if this feature is required.
 756          */
 757         public boolean requires_scid_privacy() {
 758                 boolean ret = bindings.InitFeatures_requires_scid_privacy(this.ptr);
 759                 Reference.reachabilityFence(this);
 760                 return ret;
 761         }
 762
 763         /**
 764          * Set this feature as optional.
 765          */
 766         public void set_zero_conf_optional() {
 767                 bindings.InitFeatures_set_zero_conf_optional(this.ptr);
 768                 Reference.reachabilityFence(this);
 769         }
 770
 771         /**
 772          * Set this feature as required.
 773          */
 774         public void set_zero_conf_required() {
 775                 bindings.InitFeatures_set_zero_conf_required(this.ptr);
 776                 Reference.reachabilityFence(this);
 777         }
 778
 779         /**
 780          * Checks if this feature is supported.
 781          */
 782         public boolean supports_zero_conf() {
 783                 boolean ret = bindings.InitFeatures_supports_zero_conf(this.ptr);
 784                 Reference.reachabilityFence(this);
 785                 return ret;
 786         }
 787
 788         /**
 789          * Checks if this feature is required.
 790          */
 791         public boolean requires_zero_conf() {
 792                 boolean ret = bindings.InitFeatures_requires_zero_conf(this.ptr);
 793                 Reference.reachabilityFence(this);
 794                 return ret;
 795         }
 796
 797 }