_ Git - ldk-java/blob - src/main/java/org/ldk/structs/NodeFeatures.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 a `node_announcement` message.
  13  */
  14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
  15 public class NodeFeatures extends CommonBase {
  16         NodeFeatures(Object _dummy, long ptr) { super(ptr); }
  17         @Override @SuppressWarnings("deprecation")
  18         protected void finalize() throws Throwable {
  19                 super.finalize();
  20                 if (ptr != 0) { bindings.NodeFeatures_free(ptr); }
  21         }
  22
  23         /**
  24          * Checks if two NodeFeaturess 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.NodeFeatures b) {
  29                 boolean ret = bindings.NodeFeatures_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 NodeFeatures)) return false;
  38                 return this.eq((NodeFeatures)o);
  39         }
  40         long clone_ptr() {
  41                 long ret = bindings.NodeFeatures_clone_ptr(this.ptr);
  42                 Reference.reachabilityFence(this);
  43                 return ret;
  44         }
  45
  46         /**
  47          * Creates a copy of the NodeFeatures
  48          */
  49         public NodeFeatures clone() {
  50                 long ret = bindings.NodeFeatures_clone(this.ptr);
  51                 Reference.reachabilityFence(this);
  52                 if (ret >= 0 && ret <= 4096) { return null; }
  53                 org.ldk.structs.NodeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.NodeFeatures(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 NodeFeatures.
  60          */
  61         public long hash() {
  62                 long ret = bindings.NodeFeatures_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 NodeFeatures empty() {
  74                 long ret = bindings.NodeFeatures_empty();
  75                 if (ret >= 0 && ret <= 4096) { return null; }
  76                 org.ldk.structs.NodeFeatures ret_hu_conv = null; if (ret < 0 || ret > 4096) { ret_hu_conv = new org.ldk.structs.NodeFeatures(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.NodeFeatures other) {
  85                 boolean ret = bindings.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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 NodeFeatures object into a byte array which can be read by NodeFeatures_read
 176          */
 177         public byte[] write() {
 178                 byte[] ret = bindings.NodeFeatures_write(this.ptr);
 179                 Reference.reachabilityFence(this);
 180                 return ret;
 181         }
 182
 183         /**
 184          * Read a NodeFeatures from a byte array, created by NodeFeatures_write
 185          */
 186         public static Result_NodeFeaturesDecodeErrorZ read(byte[] ser) {
 187                 long ret = bindings.NodeFeatures_read(ser);
 188                 Reference.reachabilityFence(ser);
 189                 if (ret >= 0 && ret <= 4096) { return null; }
 190                 Result_NodeFeaturesDecodeErrorZ ret_hu_conv = Result_NodeFeaturesDecodeErrorZ.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.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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.NodeFeatures_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_upfront_shutdown_script_optional() {
 232                 bindings.NodeFeatures_set_upfront_shutdown_script_optional(this.ptr);
 233                 Reference.reachabilityFence(this);
 234         }
 235
 236         /**
 237          * Set this feature as required.
 238          */
 239         public void set_upfront_shutdown_script_required() {
 240                 bindings.NodeFeatures_set_upfront_shutdown_script_required(this.ptr);
 241                 Reference.reachabilityFence(this);
 242         }
 243
 244         /**
 245          * Checks if this feature is supported.
 246          */
 247         public boolean supports_upfront_shutdown_script() {
 248                 boolean ret = bindings.NodeFeatures_supports_upfront_shutdown_script(this.ptr);
 249                 Reference.reachabilityFence(this);
 250                 return ret;
 251         }
 252
 253         /**
 254          * Checks if this feature is required.
 255          */
 256         public boolean requires_upfront_shutdown_script() {
 257                 boolean ret = bindings.NodeFeatures_requires_upfront_shutdown_script(this.ptr);
 258                 Reference.reachabilityFence(this);
 259                 return ret;
 260         }
 261
 262         /**
 263          * Set this feature as optional.
 264          */
 265         public void set_gossip_queries_optional() {
 266                 bindings.NodeFeatures_set_gossip_queries_optional(this.ptr);
 267                 Reference.reachabilityFence(this);
 268         }
 269
 270         /**
 271          * Set this feature as required.
 272          */
 273         public void set_gossip_queries_required() {
 274                 bindings.NodeFeatures_set_gossip_queries_required(this.ptr);
 275                 Reference.reachabilityFence(this);
 276         }
 277
 278         /**
 279          * Checks if this feature is supported.
 280          */
 281         public boolean supports_gossip_queries() {
 282                 boolean ret = bindings.NodeFeatures_supports_gossip_queries(this.ptr);
 283                 Reference.reachabilityFence(this);
 284                 return ret;
 285         }
 286
 287         /**
 288          * Checks if this feature is required.
 289          */
 290         public boolean requires_gossip_queries() {
 291                 boolean ret = bindings.NodeFeatures_requires_gossip_queries(this.ptr);
 292                 Reference.reachabilityFence(this);
 293                 return ret;
 294         }
 295
 296         /**
 297          * Set this feature as optional.
 298          */
 299         public void set_variable_length_onion_optional() {
 300                 bindings.NodeFeatures_set_variable_length_onion_optional(this.ptr);
 301                 Reference.reachabilityFence(this);
 302         }
 303
 304         /**
 305          * Set this feature as required.
 306          */
 307         public void set_variable_length_onion_required() {
 308                 bindings.NodeFeatures_set_variable_length_onion_required(this.ptr);
 309                 Reference.reachabilityFence(this);
 310         }
 311
 312         /**
 313          * Checks if this feature is supported.
 314          */
 315         public boolean supports_variable_length_onion() {
 316                 boolean ret = bindings.NodeFeatures_supports_variable_length_onion(this.ptr);
 317                 Reference.reachabilityFence(this);
 318                 return ret;
 319         }
 320
 321         /**
 322          * Checks if this feature is required.
 323          */
 324         public boolean requires_variable_length_onion() {
 325                 boolean ret = bindings.NodeFeatures_requires_variable_length_onion(this.ptr);
 326                 Reference.reachabilityFence(this);
 327                 return ret;
 328         }
 329
 330         /**
 331          * Set this feature as optional.
 332          */
 333         public void set_static_remote_key_optional() {
 334                 bindings.NodeFeatures_set_static_remote_key_optional(this.ptr);
 335                 Reference.reachabilityFence(this);
 336         }
 337
 338         /**
 339          * Set this feature as required.
 340          */
 341         public void set_static_remote_key_required() {
 342                 bindings.NodeFeatures_set_static_remote_key_required(this.ptr);
 343                 Reference.reachabilityFence(this);
 344         }
 345
 346         /**
 347          * Checks if this feature is supported.
 348          */
 349         public boolean supports_static_remote_key() {
 350                 boolean ret = bindings.NodeFeatures_supports_static_remote_key(this.ptr);
 351                 Reference.reachabilityFence(this);
 352                 return ret;
 353         }
 354
 355         /**
 356          * Checks if this feature is required.
 357          */
 358         public boolean requires_static_remote_key() {
 359                 boolean ret = bindings.NodeFeatures_requires_static_remote_key(this.ptr);
 360                 Reference.reachabilityFence(this);
 361                 return ret;
 362         }
 363
 364         /**
 365          * Set this feature as optional.
 366          */
 367         public void set_payment_secret_optional() {
 368                 bindings.NodeFeatures_set_payment_secret_optional(this.ptr);
 369                 Reference.reachabilityFence(this);
 370         }
 371
 372         /**
 373          * Set this feature as required.
 374          */
 375         public void set_payment_secret_required() {
 376                 bindings.NodeFeatures_set_payment_secret_required(this.ptr);
 377                 Reference.reachabilityFence(this);
 378         }
 379
 380         /**
 381          * Checks if this feature is supported.
 382          */
 383         public boolean supports_payment_secret() {
 384                 boolean ret = bindings.NodeFeatures_supports_payment_secret(this.ptr);
 385                 Reference.reachabilityFence(this);
 386                 return ret;
 387         }
 388
 389         /**
 390          * Checks if this feature is required.
 391          */
 392         public boolean requires_payment_secret() {
 393                 boolean ret = bindings.NodeFeatures_requires_payment_secret(this.ptr);
 394                 Reference.reachabilityFence(this);
 395                 return ret;
 396         }
 397
 398         /**
 399          * Set this feature as optional.
 400          */
 401         public void set_basic_mpp_optional() {
 402                 bindings.NodeFeatures_set_basic_mpp_optional(this.ptr);
 403                 Reference.reachabilityFence(this);
 404         }
 405
 406         /**
 407          * Set this feature as required.
 408          */
 409         public void set_basic_mpp_required() {
 410                 bindings.NodeFeatures_set_basic_mpp_required(this.ptr);
 411                 Reference.reachabilityFence(this);
 412         }
 413
 414         /**
 415          * Checks if this feature is supported.
 416          */
 417         public boolean supports_basic_mpp() {
 418                 boolean ret = bindings.NodeFeatures_supports_basic_mpp(this.ptr);
 419                 Reference.reachabilityFence(this);
 420                 return ret;
 421         }
 422
 423         /**
 424          * Checks if this feature is required.
 425          */
 426         public boolean requires_basic_mpp() {
 427                 boolean ret = bindings.NodeFeatures_requires_basic_mpp(this.ptr);
 428                 Reference.reachabilityFence(this);
 429                 return ret;
 430         }
 431
 432         /**
 433          * Set this feature as optional.
 434          */
 435         public void set_wumbo_optional() {
 436                 bindings.NodeFeatures_set_wumbo_optional(this.ptr);
 437                 Reference.reachabilityFence(this);
 438         }
 439
 440         /**
 441          * Set this feature as required.
 442          */
 443         public void set_wumbo_required() {
 444                 bindings.NodeFeatures_set_wumbo_required(this.ptr);
 445                 Reference.reachabilityFence(this);
 446         }
 447
 448         /**
 449          * Checks if this feature is supported.
 450          */
 451         public boolean supports_wumbo() {
 452                 boolean ret = bindings.NodeFeatures_supports_wumbo(this.ptr);
 453                 Reference.reachabilityFence(this);
 454                 return ret;
 455         }
 456
 457         /**
 458          * Checks if this feature is required.
 459          */
 460         public boolean requires_wumbo() {
 461                 boolean ret = bindings.NodeFeatures_requires_wumbo(this.ptr);
 462                 Reference.reachabilityFence(this);
 463                 return ret;
 464         }
 465
 466         /**
 467          * Set this feature as optional.
 468          */
 469         public void set_anchors_nonzero_fee_htlc_tx_optional() {
 470                 bindings.NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(this.ptr);
 471                 Reference.reachabilityFence(this);
 472         }
 473
 474         /**
 475          * Set this feature as required.
 476          */
 477         public void set_anchors_nonzero_fee_htlc_tx_required() {
 478                 bindings.NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(this.ptr);
 479                 Reference.reachabilityFence(this);
 480         }
 481
 482         /**
 483          * Checks if this feature is supported.
 484          */
 485         public boolean supports_anchors_nonzero_fee_htlc_tx() {
 486                 boolean ret = bindings.NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(this.ptr);
 487                 Reference.reachabilityFence(this);
 488                 return ret;
 489         }
 490
 491         /**
 492          * Checks if this feature is required.
 493          */
 494         public boolean requires_anchors_nonzero_fee_htlc_tx() {
 495                 boolean ret = bindings.NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(this.ptr);
 496                 Reference.reachabilityFence(this);
 497                 return ret;
 498         }
 499
 500         /**
 501          * Set this feature as optional.
 502          */
 503         public void set_anchors_zero_fee_htlc_tx_optional() {
 504                 bindings.NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(this.ptr);
 505                 Reference.reachabilityFence(this);
 506         }
 507
 508         /**
 509          * Set this feature as required.
 510          */
 511         public void set_anchors_zero_fee_htlc_tx_required() {
 512                 bindings.NodeFeatures_set_anchors_zero_fee_htlc_tx_required(this.ptr);
 513                 Reference.reachabilityFence(this);
 514         }
 515
 516         /**
 517          * Checks if this feature is supported.
 518          */
 519         public boolean supports_anchors_zero_fee_htlc_tx() {
 520                 boolean ret = bindings.NodeFeatures_supports_anchors_zero_fee_htlc_tx(this.ptr);
 521                 Reference.reachabilityFence(this);
 522                 return ret;
 523         }
 524
 525         /**
 526          * Checks if this feature is required.
 527          */
 528         public boolean requires_anchors_zero_fee_htlc_tx() {
 529                 boolean ret = bindings.NodeFeatures_requires_anchors_zero_fee_htlc_tx(this.ptr);
 530                 Reference.reachabilityFence(this);
 531                 return ret;
 532         }
 533
 534         /**
 535          * Set this feature as optional.
 536          */
 537         public void set_route_blinding_optional() {
 538                 bindings.NodeFeatures_set_route_blinding_optional(this.ptr);
 539                 Reference.reachabilityFence(this);
 540         }
 541
 542         /**
 543          * Set this feature as required.
 544          */
 545         public void set_route_blinding_required() {
 546                 bindings.NodeFeatures_set_route_blinding_required(this.ptr);
 547                 Reference.reachabilityFence(this);
 548         }
 549
 550         /**
 551          * Checks if this feature is supported.
 552          */
 553         public boolean supports_route_blinding() {
 554                 boolean ret = bindings.NodeFeatures_supports_route_blinding(this.ptr);
 555                 Reference.reachabilityFence(this);
 556                 return ret;
 557         }
 558
 559         /**
 560          * Checks if this feature is required.
 561          */
 562         public boolean requires_route_blinding() {
 563                 boolean ret = bindings.NodeFeatures_requires_route_blinding(this.ptr);
 564                 Reference.reachabilityFence(this);
 565                 return ret;
 566         }
 567
 568         /**
 569          * Set this feature as optional.
 570          */
 571         public void set_shutdown_any_segwit_optional() {
 572                 bindings.NodeFeatures_set_shutdown_any_segwit_optional(this.ptr);
 573                 Reference.reachabilityFence(this);
 574         }
 575
 576         /**
 577          * Set this feature as required.
 578          */
 579         public void set_shutdown_any_segwit_required() {
 580                 bindings.NodeFeatures_set_shutdown_any_segwit_required(this.ptr);
 581                 Reference.reachabilityFence(this);
 582         }
 583
 584         /**
 585          * Checks if this feature is supported.
 586          */
 587         public boolean supports_shutdown_anysegwit() {
 588                 boolean ret = bindings.NodeFeatures_supports_shutdown_anysegwit(this.ptr);
 589                 Reference.reachabilityFence(this);
 590                 return ret;
 591         }
 592
 593         /**
 594          * Checks if this feature is required.
 595          */
 596         public boolean requires_shutdown_anysegwit() {
 597                 boolean ret = bindings.NodeFeatures_requires_shutdown_anysegwit(this.ptr);
 598                 Reference.reachabilityFence(this);
 599                 return ret;
 600         }
 601
 602         /**
 603          * Set this feature as optional.
 604          */
 605         public void set_taproot_optional() {
 606                 bindings.NodeFeatures_set_taproot_optional(this.ptr);
 607                 Reference.reachabilityFence(this);
 608         }
 609
 610         /**
 611          * Set this feature as required.
 612          */
 613         public void set_taproot_required() {
 614                 bindings.NodeFeatures_set_taproot_required(this.ptr);
 615                 Reference.reachabilityFence(this);
 616         }
 617
 618         /**
 619          * Checks if this feature is supported.
 620          */
 621         public boolean supports_taproot() {
 622                 boolean ret = bindings.NodeFeatures_supports_taproot(this.ptr);
 623                 Reference.reachabilityFence(this);
 624                 return ret;
 625         }
 626
 627         /**
 628          * Checks if this feature is required.
 629          */
 630         public boolean requires_taproot() {
 631                 boolean ret = bindings.NodeFeatures_requires_taproot(this.ptr);
 632                 Reference.reachabilityFence(this);
 633                 return ret;
 634         }
 635
 636         /**
 637          * Set this feature as optional.
 638          */
 639         public void set_onion_messages_optional() {
 640                 bindings.NodeFeatures_set_onion_messages_optional(this.ptr);
 641                 Reference.reachabilityFence(this);
 642         }
 643
 644         /**
 645          * Set this feature as required.
 646          */
 647         public void set_onion_messages_required() {
 648                 bindings.NodeFeatures_set_onion_messages_required(this.ptr);
 649                 Reference.reachabilityFence(this);
 650         }
 651
 652         /**
 653          * Checks if this feature is supported.
 654          */
 655         public boolean supports_onion_messages() {
 656                 boolean ret = bindings.NodeFeatures_supports_onion_messages(this.ptr);
 657                 Reference.reachabilityFence(this);
 658                 return ret;
 659         }
 660
 661         /**
 662          * Checks if this feature is required.
 663          */
 664         public boolean requires_onion_messages() {
 665                 boolean ret = bindings.NodeFeatures_requires_onion_messages(this.ptr);
 666                 Reference.reachabilityFence(this);
 667                 return ret;
 668         }
 669
 670         /**
 671          * Set this feature as optional.
 672          */
 673         public void set_channel_type_optional() {
 674                 bindings.NodeFeatures_set_channel_type_optional(this.ptr);
 675                 Reference.reachabilityFence(this);
 676         }
 677
 678         /**
 679          * Set this feature as required.
 680          */
 681         public void set_channel_type_required() {
 682                 bindings.NodeFeatures_set_channel_type_required(this.ptr);
 683                 Reference.reachabilityFence(this);
 684         }
 685
 686         /**
 687          * Checks if this feature is supported.
 688          */
 689         public boolean supports_channel_type() {
 690                 boolean ret = bindings.NodeFeatures_supports_channel_type(this.ptr);
 691                 Reference.reachabilityFence(this);
 692                 return ret;
 693         }
 694
 695         /**
 696          * Checks if this feature is required.
 697          */
 698         public boolean requires_channel_type() {
 699                 boolean ret = bindings.NodeFeatures_requires_channel_type(this.ptr);
 700                 Reference.reachabilityFence(this);
 701                 return ret;
 702         }
 703
 704         /**
 705          * Set this feature as optional.
 706          */
 707         public void set_scid_privacy_optional() {
 708                 bindings.NodeFeatures_set_scid_privacy_optional(this.ptr);
 709                 Reference.reachabilityFence(this);
 710         }
 711
 712         /**
 713          * Set this feature as required.
 714          */
 715         public void set_scid_privacy_required() {
 716                 bindings.NodeFeatures_set_scid_privacy_required(this.ptr);
 717                 Reference.reachabilityFence(this);
 718         }
 719
 720         /**
 721          * Checks if this feature is supported.
 722          */
 723         public boolean supports_scid_privacy() {
 724                 boolean ret = bindings.NodeFeatures_supports_scid_privacy(this.ptr);
 725                 Reference.reachabilityFence(this);
 726                 return ret;
 727         }
 728
 729         /**
 730          * Checks if this feature is required.
 731          */
 732         public boolean requires_scid_privacy() {
 733                 boolean ret = bindings.NodeFeatures_requires_scid_privacy(this.ptr);
 734                 Reference.reachabilityFence(this);
 735                 return ret;
 736         }
 737
 738         /**
 739          * Set this feature as optional.
 740          */
 741         public void set_zero_conf_optional() {
 742                 bindings.NodeFeatures_set_zero_conf_optional(this.ptr);
 743                 Reference.reachabilityFence(this);
 744         }
 745
 746         /**
 747          * Set this feature as required.
 748          */
 749         public void set_zero_conf_required() {
 750                 bindings.NodeFeatures_set_zero_conf_required(this.ptr);
 751                 Reference.reachabilityFence(this);
 752         }
 753
 754         /**
 755          * Checks if this feature is supported.
 756          */
 757         public boolean supports_zero_conf() {
 758                 boolean ret = bindings.NodeFeatures_supports_zero_conf(this.ptr);
 759                 Reference.reachabilityFence(this);
 760                 return ret;
 761         }
 762
 763         /**
 764          * Checks if this feature is required.
 765          */
 766         public boolean requires_zero_conf() {
 767                 boolean ret = bindings.NodeFeatures_requires_zero_conf(this.ptr);
 768                 Reference.reachabilityFence(this);
 769                 return ret;
 770         }
 771
 772         /**
 773          * Set this feature as optional.
 774          */
 775         public void set_keysend_optional() {
 776                 bindings.NodeFeatures_set_keysend_optional(this.ptr);
 777                 Reference.reachabilityFence(this);
 778         }
 779
 780         /**
 781          * Set this feature as required.
 782          */
 783         public void set_keysend_required() {
 784                 bindings.NodeFeatures_set_keysend_required(this.ptr);
 785                 Reference.reachabilityFence(this);
 786         }
 787
 788         /**
 789          * Checks if this feature is supported.
 790          */
 791         public boolean supports_keysend() {
 792                 boolean ret = bindings.NodeFeatures_supports_keysend(this.ptr);
 793                 Reference.reachabilityFence(this);
 794                 return ret;
 795         }
 796
 797         /**
 798          * Checks if this feature is required.
 799          */
 800         public boolean requires_keysend() {
 801                 boolean ret = bindings.NodeFeatures_requires_keysend(this.ptr);
 802                 Reference.reachabilityFence(this);
 803                 return ret;
 804         }
 805
 806 }