1 package org.ldk.structs;
3 import org.ldk.impl.bindings;
4 import org.ldk.enums.*;
6 import java.util.Arrays;
7 import java.lang.ref.Reference;
8 import javax.annotation.Nullable;
12 * Fallback address in case no LN payment is possible
14 @SuppressWarnings("unchecked") // We correctly assign various generic arrays
15 public class Fallback extends CommonBase {
16 private Fallback(Object _dummy, long ptr) { super(ptr); }
17 @Override @SuppressWarnings("deprecation")
18 protected void finalize() throws Throwable {
20 if (ptr != 0) { bindings.Fallback_free(ptr); }
22 static Fallback constr_from_ptr(long ptr) {
23 bindings.LDKFallback raw_val = bindings.LDKFallback_ref_from_ptr(ptr);
24 if (raw_val.getClass() == bindings.LDKFallback.SegWitProgram.class) {
25 return new SegWitProgram(ptr, (bindings.LDKFallback.SegWitProgram)raw_val);
27 if (raw_val.getClass() == bindings.LDKFallback.PubKeyHash.class) {
28 return new PubKeyHash(ptr, (bindings.LDKFallback.PubKeyHash)raw_val);
30 if (raw_val.getClass() == bindings.LDKFallback.ScriptHash.class) {
31 return new ScriptHash(ptr, (bindings.LDKFallback.ScriptHash)raw_val);
33 assert false; return null; // Unreachable without extending the (internal) bindings interface
36 public final static class SegWitProgram extends Fallback {
37 public final org.ldk.util.WitnessVersion version;
38 public final byte[] program;
39 private SegWitProgram(long ptr, bindings.LDKFallback.SegWitProgram obj) {
41 byte version = obj.version;
42 WitnessVersion version_conv = new WitnessVersion(version);
43 this.version = version_conv;
44 this.program = obj.program;
47 public final static class PubKeyHash extends Fallback {
48 public final byte[] pub_key_hash;
49 private PubKeyHash(long ptr, bindings.LDKFallback.PubKeyHash obj) {
51 this.pub_key_hash = obj.pub_key_hash;
54 public final static class ScriptHash extends Fallback {
55 public final byte[] script_hash;
56 private ScriptHash(long ptr, bindings.LDKFallback.ScriptHash obj) {
58 this.script_hash = obj.script_hash;
62 long ret = bindings.Fallback_clone_ptr(this.ptr);
63 Reference.reachabilityFence(this);
68 * Creates a copy of the Fallback
70 public Fallback clone() {
71 long ret = bindings.Fallback_clone(this.ptr);
72 Reference.reachabilityFence(this);
73 if (ret >= 0 && ret <= 4096) { return null; }
74 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
75 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); };
80 * Utility method to constructs a new SegWitProgram-variant Fallback
82 public static Fallback seg_wit_program(org.ldk.util.WitnessVersion version, byte[] program) {
83 long ret = bindings.Fallback_seg_wit_program(version.getVal(), program);
84 Reference.reachabilityFence(version);
85 Reference.reachabilityFence(program);
86 if (ret >= 0 && ret <= 4096) { return null; }
87 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
88 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
93 * Utility method to constructs a new PubKeyHash-variant Fallback
95 public static Fallback pub_key_hash(byte[] a) {
96 long ret = bindings.Fallback_pub_key_hash(InternalUtils.check_arr_len(a, 20));
97 Reference.reachabilityFence(a);
98 if (ret >= 0 && ret <= 4096) { return null; }
99 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
100 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
105 * Utility method to constructs a new ScriptHash-variant Fallback
107 public static Fallback script_hash(byte[] a) {
108 long ret = bindings.Fallback_script_hash(InternalUtils.check_arr_len(a, 20));
109 Reference.reachabilityFence(a);
110 if (ret >= 0 && ret <= 4096) { return null; }
111 org.ldk.structs.Fallback ret_hu_conv = org.ldk.structs.Fallback.constr_from_ptr(ret);
112 if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
117 * Generates a non-cryptographic 64-bit hash of the Fallback.
120 long ret = bindings.Fallback_hash(this.ptr);
121 Reference.reachabilityFence(this);
125 @Override public int hashCode() {
126 return (int)this.hash();
129 * Checks if two Fallbacks contain equal inner contents.
130 * This ignores pointers and is_owned flags and looks at the values in fields.
132 public boolean eq(org.ldk.structs.Fallback b) {
133 boolean ret = bindings.Fallback_eq(this.ptr, b == null ? 0 : b.ptr);
134 Reference.reachabilityFence(this);
135 Reference.reachabilityFence(b);
139 @Override public boolean equals(Object o) {
140 if (!(o instanceof Fallback)) return false;
141 return this.eq((Fallback)o);