X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fmain%2Fjava%2Forg%2Fldk%2Fstructs%2FAPIError.java;h=1d5bc19f0412c591bac5e3da7378e0dba219d5fd;hb=3e33cfde4213dafe90eb976eb67224e2451da855;hp=1410b0e51d6954c751f9b7528ab0bb9956d0636b;hpb=6d094e745feaf94c1059555cd1c997965a34bc36;p=ldk-java diff --git a/src/main/java/org/ldk/structs/APIError.java b/src/main/java/org/ldk/structs/APIError.java index 1410b0e5..1d5bc19f 100644 --- a/src/main/java/org/ldk/structs/APIError.java +++ b/src/main/java/org/ldk/structs/APIError.java @@ -4,6 +4,7 @@ import org.ldk.impl.bindings; import org.ldk.enums.*; import org.ldk.util.*; import java.util.Arrays; +import java.lang.ref.Reference; import javax.annotation.Nullable; @@ -27,14 +28,14 @@ public class APIError extends CommonBase { if (raw_val.getClass() == bindings.LDKAPIError.FeeRateTooHigh.class) { return new FeeRateTooHigh(ptr, (bindings.LDKAPIError.FeeRateTooHigh)raw_val); } - if (raw_val.getClass() == bindings.LDKAPIError.RouteError.class) { - return new RouteError(ptr, (bindings.LDKAPIError.RouteError)raw_val); + if (raw_val.getClass() == bindings.LDKAPIError.InvalidRoute.class) { + return new InvalidRoute(ptr, (bindings.LDKAPIError.InvalidRoute)raw_val); } if (raw_val.getClass() == bindings.LDKAPIError.ChannelUnavailable.class) { return new ChannelUnavailable(ptr, (bindings.LDKAPIError.ChannelUnavailable)raw_val); } - if (raw_val.getClass() == bindings.LDKAPIError.MonitorUpdateFailed.class) { - return new MonitorUpdateFailed(ptr, (bindings.LDKAPIError.MonitorUpdateFailed)raw_val); + if (raw_val.getClass() == bindings.LDKAPIError.MonitorUpdateInProgress.class) { + return new MonitorUpdateInProgress(ptr, (bindings.LDKAPIError.MonitorUpdateInProgress)raw_val); } if (raw_val.getClass() == bindings.LDKAPIError.IncompatibleShutdownScript.class) { return new IncompatibleShutdownScript(ptr, (bindings.LDKAPIError.IncompatibleShutdownScript)raw_val); @@ -50,7 +51,7 @@ public class APIError extends CommonBase { /** * A human-readable error message */ - public final String err; + public final java.lang.String err; private APIMisuseError(long ptr, bindings.LDKAPIError.APIMisuseError obj) { super(null, ptr); this.err = obj.err; @@ -65,7 +66,7 @@ public class APIError extends CommonBase { /** * A human-readable error message */ - public final String err; + public final java.lang.String err; /** * The feerate which was too high. */ @@ -80,12 +81,12 @@ public class APIError extends CommonBase { * A malformed Route was provided (eg overflowed value, node id mismatch, overly-looped route, * too-many-hops, etc). */ - public final static class RouteError extends APIError { + public final static class InvalidRoute extends APIError { /** * A human-readable error message */ - public final String err; - private RouteError(long ptr, bindings.LDKAPIError.RouteError obj) { + public final java.lang.String err; + private InvalidRoute(long ptr, bindings.LDKAPIError.InvalidRoute obj) { super(null, ptr); this.err = obj.err; } @@ -99,46 +100,53 @@ public class APIError extends CommonBase { /** * A human-readable error message */ - public final String err; + public final java.lang.String err; private ChannelUnavailable(long ptr, bindings.LDKAPIError.ChannelUnavailable obj) { super(null, ptr); this.err = obj.err; } } /** - * An attempt to call watch/update_channel returned an Err (ie you did this!), causing the - * attempted action to fail. + * An attempt to call [`chain::Watch::watch_channel`]/[`chain::Watch::update_channel`] + * returned a [`ChannelMonitorUpdateStatus::InProgress`] indicating the persistence of a + * monitor update is awaiting async resolution. Once it resolves the attempted action should + * complete automatically. + * + * [`chain::Watch::watch_channel`]: crate::chain::Watch::watch_channel + * [`chain::Watch::update_channel`]: crate::chain::Watch::update_channel + * [`ChannelMonitorUpdateStatus::InProgress`]: crate::chain::ChannelMonitorUpdateStatus::InProgress */ - public final static class MonitorUpdateFailed extends APIError { - private MonitorUpdateFailed(long ptr, bindings.LDKAPIError.MonitorUpdateFailed obj) { + public final static class MonitorUpdateInProgress extends APIError { + private MonitorUpdateInProgress(long ptr, bindings.LDKAPIError.MonitorUpdateInProgress obj) { super(null, ptr); } } /** - * [`KeysInterface::get_shutdown_scriptpubkey`] returned a shutdown scriptpubkey incompatible + * [`SignerProvider::get_shutdown_scriptpubkey`] returned a shutdown scriptpubkey incompatible * with the channel counterparty as negotiated in [`InitFeatures`]. * * Using a SegWit v0 script should resolve this issue. If you cannot, you won't be able to open * a channel or cooperatively close one with this peer (and will have to force-close instead). * - * [`KeysInterface::get_shutdown_scriptpubkey`]: crate::chain::keysinterface::KeysInterface::get_shutdown_scriptpubkey + * [`SignerProvider::get_shutdown_scriptpubkey`]: crate::sign::SignerProvider::get_shutdown_scriptpubkey * [`InitFeatures`]: crate::ln::features::InitFeatures */ public final static class IncompatibleShutdownScript extends APIError { /** * The incompatible shutdown script. */ - public final ShutdownScript script; + public final org.ldk.structs.ShutdownScript script; private IncompatibleShutdownScript(long ptr, bindings.LDKAPIError.IncompatibleShutdownScript obj) { super(null, ptr); long script = obj.script; - ShutdownScript script_hu_conv = null; if (script < 0 || script > 4096) { script_hu_conv = new ShutdownScript(null, script); } - script_hu_conv.ptrs_to.add(this); + org.ldk.structs.ShutdownScript script_hu_conv = null; if (script < 0 || script > 4096) { script_hu_conv = new org.ldk.structs.ShutdownScript(null, script); } + if (script_hu_conv != null) { script_hu_conv.ptrs_to.add(this); }; this.script = script_hu_conv; } } long clone_ptr() { long ret = bindings.APIError_clone_ptr(this.ptr); + Reference.reachabilityFence(this); return ret; } @@ -147,9 +155,10 @@ public class APIError extends CommonBase { */ public APIError clone() { long ret = bindings.APIError_clone(this.ptr); + Reference.reachabilityFence(this); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(this); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(this); }; return ret_hu_conv; } @@ -158,9 +167,10 @@ public class APIError extends CommonBase { */ public static APIError apimisuse_error(java.lang.String err) { long ret = bindings.APIError_apimisuse_error(err); + Reference.reachabilityFence(err); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; return ret_hu_conv; } @@ -169,20 +179,23 @@ public class APIError extends CommonBase { */ public static APIError fee_rate_too_high(java.lang.String err, int feerate) { long ret = bindings.APIError_fee_rate_too_high(err, feerate); + Reference.reachabilityFence(err); + Reference.reachabilityFence(feerate); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.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 RouteError-variant APIError + * Utility method to constructs a new InvalidRoute-variant APIError */ - public static APIError route_error(java.lang.String err) { - long ret = bindings.APIError_route_error(err); + public static APIError invalid_route(java.lang.String err) { + long ret = bindings.APIError_invalid_route(err); + Reference.reachabilityFence(err); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; return ret_hu_conv; } @@ -191,32 +204,59 @@ public class APIError extends CommonBase { */ public static APIError channel_unavailable(java.lang.String err) { long ret = bindings.APIError_channel_unavailable(err); + Reference.reachabilityFence(err); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.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 MonitorUpdateFailed-variant APIError + * Utility method to constructs a new MonitorUpdateInProgress-variant APIError */ - public static APIError monitor_update_failed() { - long ret = bindings.APIError_monitor_update_failed(); + public static APIError monitor_update_in_progress() { + long ret = bindings.APIError_monitor_update_in_progress(); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.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 IncompatibleShutdownScript-variant APIError */ - public static APIError incompatible_shutdown_script(ShutdownScript script) { - long ret = bindings.APIError_incompatible_shutdown_script(script == null ? 0 : script.ptr & ~1); + public static APIError incompatible_shutdown_script(org.ldk.structs.ShutdownScript script) { + long ret = bindings.APIError_incompatible_shutdown_script(script == null ? 0 : script.ptr); + Reference.reachabilityFence(script); if (ret >= 0 && ret <= 4096) { return null; } - APIError ret_hu_conv = APIError.constr_from_ptr(ret); - ret_hu_conv.ptrs_to.add(ret_hu_conv); + org.ldk.structs.APIError ret_hu_conv = org.ldk.structs.APIError.constr_from_ptr(ret); + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(ret_hu_conv); }; + if (ret_hu_conv != null) { ret_hu_conv.ptrs_to.add(script); }; return ret_hu_conv; } + /** + * Checks if two APIErrors contain equal inner contents. + * This ignores pointers and is_owned flags and looks at the values in fields. + */ + public boolean eq(org.ldk.structs.APIError b) { + boolean ret = bindings.APIError_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 APIError)) return false; + return this.eq((APIError)o); + } + /** + * Serialize the APIError object into a byte array which can be read by APIError_read + */ + public byte[] write() { + byte[] ret = bindings.APIError_write(this.ptr); + Reference.reachabilityFence(this); + return ret; + } + }