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