[Java] Update auto-generated bindings to 0.0.115

[ldk-java] / src / main / java / org / ldk / structs / HTLCDestination.java

diff --git a/src/main/java/org/ldk/structs/HTLCDestination.java b/src/main/java/org/ldk/structs/HTLCDestination.java
index b7e8801792f3efbe8a91586fe4cbaab0dea00384..df280da439280021e2b55f9145c4ad4512cf862c 100644 (file)
--- a/src/main/java/org/ldk/structs/HTLCDestination.java
+++ b/src/main/java/org/ldk/structs/HTLCDestination.java
@@ -27,6 +27,9 @@ public class HTLCDestination extends CommonBase {
                if (raw_val.getClass() == bindings.LDKHTLCDestination.UnknownNextHop.class) {
                        return new UnknownNextHop(ptr, (bindings.LDKHTLCDestination.UnknownNextHop)raw_val);
                }
+               if (raw_val.getClass() == bindings.LDKHTLCDestination.InvalidForward.class) {
+                       return new InvalidForward(ptr, (bindings.LDKHTLCDestination.InvalidForward)raw_val);
+               }
                if (raw_val.getClass() == bindings.LDKHTLCDestination.FailedPayment.class) {
                        return new FailedPayment(ptr, (bindings.LDKHTLCDestination.FailedPayment)raw_val);
                }
@@ -69,14 +72,31 @@ public class HTLCDestination extends CommonBase {
                        this.requested_forward_scid = obj.requested_forward_scid;
                }
        }
+       /**
+        * We couldn't forward to the outgoing scid. An example would be attempting to send a duplicate
+        * intercept HTLC.
+        */
+       public final static class InvalidForward extends HTLCDestination {
+               /**
+                * Short channel id we are requesting to forward an HTLC to.
+               */
+               public final long requested_forward_scid;
+               private InvalidForward(long ptr, bindings.LDKHTLCDestination.InvalidForward obj) {
+                       super(null, ptr);
+                       this.requested_forward_scid = obj.requested_forward_scid;
+               }
+       }
        /**
         * Failure scenario where an HTLC may have been forwarded to be intended for us,
         * but is invalid for some reason, so we reject it.
         * 
         * Some of the reasons may include:
         * HTLC Timeouts
-        * Expected MPP amount to claim does not equal HTLC total
-        * Claimable amount does not match expected amount
+        * Excess HTLCs for a payment that we have already fully received, over-paying for the
+        * payment,
+        * The counterparty node modified the HTLC in transit,
+        * A probing attack where an intermediary node is trying to detect if we are the ultimate
+        * recipient for a payment.
         */
        public final static class FailedPayment extends HTLCDestination {
                /**
@@ -131,6 +151,18 @@ public class HTLCDestination extends CommonBase {
                return ret_hu_conv;
        }
 
+       /**
+        * Utility method to constructs a new InvalidForward-variant HTLCDestination
+        */
+       public static HTLCDestination invalid_forward(long requested_forward_scid) {
+               long ret = bindings.HTLCDestination_invalid_forward(requested_forward_scid);
+               Reference.reachabilityFence(requested_forward_scid);
+               if (ret >= 0 && ret <= 4096) { return null; }
+               org.ldk.structs.HTLCDestination ret_hu_conv = org.ldk.structs.HTLCDestination.constr_from_ptr(ret);
+               if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); };
+               return ret_hu_conv;
+       }
+
        /**
         * Utility method to constructs a new FailedPayment-variant HTLCDestination
         */
@@ -143,6 +175,21 @@ public class HTLCDestination extends CommonBase {
                return ret_hu_conv;
        }
 
+       /**
+        * Checks if two HTLCDestinations contain equal inner contents.
+        * This ignores pointers and is_owned flags and looks at the values in fields.
+        */
+       public boolean eq(org.ldk.structs.HTLCDestination b) {
+               boolean ret = bindings.HTLCDestination_eq(this.ptr, b == null ? 0 : b.ptr);
+               Reference.reachabilityFence(this);
+               Reference.reachabilityFence(b);
+               return ret;
+       }
+
+       @Override public boolean equals(Object o) {
+               if (!(o instanceof HTLCDestination)) return false;
+               return this.eq((HTLCDestination)o);
+       }
        /**
         * Serialize the HTLCDestination object into a byte array which can be read by HTLCDestination_read
         */