_ 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 number clone_ptr() {
  81                 number ret = bindings.APIError_clone_ptr(this.ptr);
  82                 return ret;
  83         }
  84
  85         public APIError clone() {
  86                 number ret = bindings.APIError_clone(this.ptr);
  87                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
  88                 ret_hu_conv.ptrs_to.add(this);
  89                 return ret_hu_conv;
  90         }
  91
  92         public static APIError constructor_apimisuse_error(String err) {
  93                 number ret = bindings.APIError_apimisuse_error(err);
  94                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
  95                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
  96                 return ret_hu_conv;
  97         }
  98
  99         public static APIError constructor_fee_rate_too_high(String err, number feerate) {
 100                 number ret = bindings.APIError_fee_rate_too_high(err, feerate);
 101                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 102                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 103                 return ret_hu_conv;
 104         }
 105
 106         public static APIError constructor_route_error(String err) {
 107                 number ret = bindings.APIError_route_error(err);
 108                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 109                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 110                 return ret_hu_conv;
 111         }
 112
 113         public static APIError constructor_channel_unavailable(String err) {
 114                 number ret = bindings.APIError_channel_unavailable(err);
 115                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 116                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 117                 return ret_hu_conv;
 118         }
 119
 120         public static APIError constructor_monitor_update_failed() {
 121                 number ret = bindings.APIError_monitor_update_failed();
 122                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 123                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 124                 return ret_hu_conv;
 125         }
 126
 127         public static APIError constructor_incompatible_shutdown_script(ShutdownScript script) {
 128                 number ret = bindings.APIError_incompatible_shutdown_script(script == null ? 0 : script.ptr & ~1);
 129                 APIError ret_hu_conv = APIError.constr_from_ptr(ret);
 130                 ret_hu_conv.ptrs_to.add(ret_hu_conv);
 131                 return ret_hu_conv;
 132         }
 133
 134 }