_ Git - ldk-java/blob - ts/structs/APIError.ts

   1
   2 import CommonBase from './CommonBase';
   3 import * as bindings from '../bindings' // TODO: figure out location
   4
   5 export default class APIError extends CommonBase {
   6         protected constructor(_dummy: object, ptr: number) { super(ptr); }
   7         protected finalize() {
   8                 super.finalize();
   9                 if (this.ptr != 0) { bindings.APIError_free(this.ptr); }
  10         }
  11         static constr_from_ptr(ptr: number): APIError {
  12                 const raw_val: bindings.LDKAPIError = bindings.LDKAPIError_ref_from_ptr(ptr);
  13                 if (raw_val instanceof bindings.LDKAPIError.APIMisuseError) {
  14                         return new APIMisuseError(this.ptr, raw_val);
  15                 }
  16                 if (raw_val instanceof bindings.LDKAPIError.FeeRateTooHigh) {
  17                         return new FeeRateTooHigh(this.ptr, raw_val);
  18                 }
  19                 if (raw_val instanceof bindings.LDKAPIError.RouteError) {
  20                         return new RouteError(this.ptr, raw_val);
  21                 }
  22                 if (raw_val instanceof bindings.LDKAPIError.ChannelUnavailable) {
  23                         return new ChannelUnavailable(this.ptr, raw_val);
  24                 }
  25                 if (raw_val instanceof bindings.LDKAPIError.MonitorUpdateFailed) {
  26                         return new MonitorUpdateFailed(this.ptr, raw_val);
  27                 }
  28                 if (raw_val instanceof bindings.LDKAPIError.IncompatibleShutdownScript) {
  29                         return new IncompatibleShutdownScript(this.ptr, raw_val);
  30                 }
  31                 throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
  32         }
  33
  34 }
  35 export class APIMisuseError extends APIError {
  36         public err: String;
  37         private constructor(ptr: number, obj: bindings.LDKAPIError.APIMisuseError) {
  38                 super(null, ptr);
  39                 this.err = obj.err;
  40         }
  41 }
  42 export class FeeRateTooHigh extends APIError {
  43         public err: String;
  44         public feerate: number;
  45         private constructor(ptr: number, obj: bindings.LDKAPIError.FeeRateTooHigh) {
  46                 super(null, ptr);
  47                 this.err = obj.err;
  48                 this.feerate = obj.feerate;
  49         }
  50 }
  51 export class RouteError extends APIError {
  52         public err: String;
  53         private constructor(ptr: number, obj: bindings.LDKAPIError.RouteError) {
  54                 super(null, ptr);
  55                 this.err = obj.err;
  56         }
  57 }
  58 export class ChannelUnavailable extends APIError {
  59         public err: String;
  60         private constructor(ptr: number, obj: bindings.LDKAPIError.ChannelUnavailable) {
  61                 super(null, ptr);
  62                 this.err = obj.err;
  63         }
  64 }
  65 export class MonitorUpdateFailed extends APIError {
  66         private constructor(ptr: number, obj: bindings.LDKAPIError.MonitorUpdateFailed) {
  67                 super(null, ptr);
  68         }
  69 }
  70 export class IncompatibleShutdownScript extends APIError {
  71         public script: ShutdownScript;
  72         private constructor(ptr: number, obj: bindings.LDKAPIError.IncompatibleShutdownScript) {
  73                 super(null, ptr);
  74                 const script: number = obj.script;
  75                 const script_hu_conv: ShutdownScript = new ShutdownScript(null, script);
  76                         script_hu_conv.ptrs_to.add(this);
  77                 this.script = script_hu_conv;
  78         }
  79 }
  80         public APIError clone() {
  81                 number ret = bindings.APIError_clone(this.ptr);
  82                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
  83                 ret_hu_conv.ptrs_to.add(this);
  84                 return ret_hu_conv;
  85         }
  86
  87         public static APIError constructor_apimisuse_error(String err) {
  88                 number ret = bindings.APIError_apimisuse_error(err);
  89                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
  90                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  91                 return ret_hu_conv;
  92         }
  93
  94         public static APIError constructor_fee_rate_too_high(String err, number feerate) {
  95                 number ret = bindings.APIError_fee_rate_too_high(err, feerate);
  96                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
  97                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  98                 return ret_hu_conv;
  99         }
 100
 101         public static APIError constructor_route_error(String err) {
 102                 number ret = bindings.APIError_route_error(err);
 103                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 104                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 105                 return ret_hu_conv;
 106         }
 107
 108         public static APIError constructor_channel_unavailable(String err) {
 109                 number ret = bindings.APIError_channel_unavailable(err);
 110                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 111                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 112                 return ret_hu_conv;
 113         }
 114
 115         public static APIError constructor_monitor_update_failed() {
 116                 number ret = bindings.APIError_monitor_update_failed();
 117                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 118                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 119                 return ret_hu_conv;
 120         }
 121
 122         public static APIError constructor_incompatible_shutdown_script(ShutdownScript script) {
 123                 number ret = bindings.APIError_incompatible_shutdown_script(script == null ? 0 : script.ptr & ~1);
 124                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 125                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 126                 return ret_hu_conv;
 127         }
 128
 129 }