import CommonBase from './CommonBase.mjs';
import * as bindings from '../bindings.mjs'
-import * as InternalUtils from '../InternalUtils.mjs'
+/**
+ * The reason the channel was closed. See individual variants more details.
+ */
export class ClosureReason extends CommonBase {
protected constructor(_dummy: object, ptr: number) { super(ptr, bindings.ClosureReason_free); }
/* @internal */
public static constr_from_ptr(ptr: number): ClosureReason {
- const raw_val: bindings.LDKClosureReason = bindings.LDKClosureReason_ref_from_ptr(ptr);
- if (raw_val instanceof bindings.LDKClosureReason_CounterpartyForceClosed) {
- return new ClosureReason_CounterpartyForceClosed(ptr, raw_val);
+ const raw_ty: number = bindings.LDKClosureReason_ty_from_ptr(ptr);
+ switch (raw_ty) {
+ case 0: return new ClosureReason_CounterpartyForceClosed(ptr);
+ case 1: return new ClosureReason_HolderForceClosed(ptr);
+ case 2: return new ClosureReason_CooperativeClosure(ptr);
+ case 3: return new ClosureReason_CommitmentTxConfirmed(ptr);
+ case 4: return new ClosureReason_FundingTimedOut(ptr);
+ case 5: return new ClosureReason_ProcessingError(ptr);
+ case 6: return new ClosureReason_DisconnectedPeer(ptr);
+ case 7: return new ClosureReason_OutdatedChannelManager(ptr);
+ default:
+ throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
}
- if (raw_val instanceof bindings.LDKClosureReason_HolderForceClosed) {
- return new ClosureReason_HolderForceClosed(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_CooperativeClosure) {
- return new ClosureReason_CooperativeClosure(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_CommitmentTxConfirmed) {
- return new ClosureReason_CommitmentTxConfirmed(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_FundingTimedOut) {
- return new ClosureReason_FundingTimedOut(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_ProcessingError) {
- return new ClosureReason_ProcessingError(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_DisconnectedPeer) {
- return new ClosureReason_DisconnectedPeer(ptr, raw_val);
- }
- if (raw_val instanceof bindings.LDKClosureReason_OutdatedChannelManager) {
- return new ClosureReason_OutdatedChannelManager(ptr, raw_val);
- }
- throw new Error('oops, this should be unreachable'); // Unreachable without extending the (internal) bindings interface
}
public clone_ptr(): number {
return ret;
}
+ /**
+ * Creates a copy of the ClosureReason
+ */
public clone(): ClosureReason {
const ret: number = bindings.ClosureReason_clone(this.ptr);
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
- public static constructor_counterparty_force_closed(peer_msg: String): ClosureReason {
- const ret: number = bindings.ClosureReason_counterparty_force_closed(peer_msg);
+ /**
+ * Utility method to constructs a new CounterpartyForceClosed-variant ClosureReason
+ */
+ public static constructor_counterparty_force_closed(peer_msg: string): ClosureReason {
+ const ret: number = bindings.ClosureReason_counterparty_force_closed(bindings.encodeString(peer_msg));
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new HolderForceClosed-variant ClosureReason
+ */
public static constructor_holder_force_closed(): ClosureReason {
const ret: number = bindings.ClosureReason_holder_force_closed();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new CooperativeClosure-variant ClosureReason
+ */
public static constructor_cooperative_closure(): ClosureReason {
const ret: number = bindings.ClosureReason_cooperative_closure();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new CommitmentTxConfirmed-variant ClosureReason
+ */
public static constructor_commitment_tx_confirmed(): ClosureReason {
const ret: number = bindings.ClosureReason_commitment_tx_confirmed();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new FundingTimedOut-variant ClosureReason
+ */
public static constructor_funding_timed_out(): ClosureReason {
const ret: number = bindings.ClosureReason_funding_timed_out();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
- public static constructor_processing_error(err: String): ClosureReason {
- const ret: number = bindings.ClosureReason_processing_error(err);
+ /**
+ * Utility method to constructs a new ProcessingError-variant ClosureReason
+ */
+ public static constructor_processing_error(err: string): ClosureReason {
+ const ret: number = bindings.ClosureReason_processing_error(bindings.encodeString(err));
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
CommonBase.add_ref_from(ret_hu_conv, ret_hu_conv);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new DisconnectedPeer-variant ClosureReason
+ */
public static constructor_disconnected_peer(): ClosureReason {
const ret: number = bindings.ClosureReason_disconnected_peer();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
+ /**
+ * Utility method to constructs a new OutdatedChannelManager-variant ClosureReason
+ */
public static constructor_outdated_channel_manager(): ClosureReason {
const ret: number = bindings.ClosureReason_outdated_channel_manager();
const ret_hu_conv: ClosureReason = ClosureReason.constr_from_ptr(ret);
return ret_hu_conv;
}
+ /**
+ * Serialize the ClosureReason object into a byte array which can be read by ClosureReason_read
+ */
public write(): Uint8Array {
- const ret: Uint8Array = bindings.ClosureReason_write(this.ptr);
- return ret;
+ const ret: number = bindings.ClosureReason_write(this.ptr);
+ const ret_conv: Uint8Array = bindings.decodeUint8Array(ret);
+ return ret_conv;
}
}
+/** A ClosureReason of type CounterpartyForceClosed */
export class ClosureReason_CounterpartyForceClosed extends ClosureReason {
- public peer_msg: String;
+ /**
+ * The error which the peer sent us.
+ *
+ * The string should be sanitized before it is used (e.g emitted to logs
+ * or printed to stdout). Otherwise, a well crafted error message may exploit
+ * a security vulnerability in the terminal emulator or the logging subsystem.
+ */
+ public peer_msg: string;
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_CounterpartyForceClosed) {
+ public constructor(ptr: number) {
super(null, ptr);
- this.peer_msg = obj.peer_msg;
+ const peer_msg: number = bindings.LDKClosureReason_CounterpartyForceClosed_get_peer_msg(ptr);
+ const peer_msg_conv: string = bindings.decodeString(peer_msg);
+ this.peer_msg = peer_msg_conv;
}
}
+/** A ClosureReason of type HolderForceClosed */
export class ClosureReason_HolderForceClosed extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_HolderForceClosed) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
+/** A ClosureReason of type CooperativeClosure */
export class ClosureReason_CooperativeClosure extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_CooperativeClosure) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
+/** A ClosureReason of type CommitmentTxConfirmed */
export class ClosureReason_CommitmentTxConfirmed extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_CommitmentTxConfirmed) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
+/** A ClosureReason of type FundingTimedOut */
export class ClosureReason_FundingTimedOut extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_FundingTimedOut) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
+/** A ClosureReason of type ProcessingError */
export class ClosureReason_ProcessingError extends ClosureReason {
- public err: String;
+ /**
+ * A developer-readable error message which we generated.
+ */
+ public err: string;
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_ProcessingError) {
+ public constructor(ptr: number) {
super(null, ptr);
- this.err = obj.err;
+ const err: number = bindings.LDKClosureReason_ProcessingError_get_err(ptr);
+ const err_conv: string = bindings.decodeString(err);
+ this.err = err_conv;
}
}
+/** A ClosureReason of type DisconnectedPeer */
export class ClosureReason_DisconnectedPeer extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_DisconnectedPeer) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
+/** A ClosureReason of type OutdatedChannelManager */
export class ClosureReason_OutdatedChannelManager extends ClosureReason {
/* @internal */
- public constructor(ptr: number, obj: bindings.LDKClosureReason_OutdatedChannelManager) {
+ public constructor(ptr: number) {
super(null, ptr);
}
}
projects / ldk-java / blobdiff