*/
public static native long LDKCVec_u8Z_new(number[] elems);
+ public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_OutPointDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_OutPointDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_OutPointDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_SecretKeyErrorZ_result_ok(long arg);
public static native Uint8Array LDKCResult_SecretKeyErrorZ_get_ok(long arg);
public static native LDKSecp256k1Error LDKCResult_SecretKeyErrorZ_get_err(long arg);
public static native boolean LDKCResult_TxCreationKeysErrorZ_result_ok(long arg);
public static native number LDKCResult_TxCreationKeysErrorZ_get_ok(long arg);
public static native LDKSecp256k1Error LDKCResult_TxCreationKeysErrorZ_get_err(long arg);
+ public static class LDKCOption_u32Z {
+ private LDKCOption_u32Z() {}
+ export class Some extends LDKCOption_u32Z {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_u32Z {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_u32Z.init(); }
+ public static native LDKCOption_u32Z LDKCOption_u32Z_ref_from_ptr(long ptr);
public static native boolean LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_CVec_SignatureZNoneZ_result_ok(long arg);
public static native Uint8Array[] LDKCResult_CVec_SignatureZNoneZ_get_ok(long arg);
public static native void LDKCResult_CVec_SignatureZNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NoneMonitorUpdateErrorZ_result_ok(long arg);
+ public static native void LDKCResult_NoneMonitorUpdateErrorZ_get_ok(long arg);
+ public static native number LDKCResult_NoneMonitorUpdateErrorZ_get_err(long arg);
+ public static native long LDKC2Tuple_OutPointScriptZ_new(number a, Uint8Array b);
+ public static native number LDKC2Tuple_OutPointScriptZ_get_a(long ptr);
+ public static native Uint8Array LDKC2Tuple_OutPointScriptZ_get_b(long ptr);
+ public static native long LDKC2Tuple_u32ScriptZ_new(number a, Uint8Array b);
+ public static native number LDKC2Tuple_u32ScriptZ_get_a(long ptr);
+ public static native Uint8Array LDKC2Tuple_u32ScriptZ_get_b(long ptr);
+ public static native long LDKCVec_C2Tuple_u32ScriptZZ_new(number[] elems);
+ public static native long LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(Uint8Array a, number[] b);
+ public static native Uint8Array LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(long ptr);
+ public static native number[] LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(long ptr);
+ public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(number[] elems);
+ public static class LDKMonitorEvent {
+ private LDKMonitorEvent() {}
+ export class HTLCEvent extends LDKMonitorEvent {
+ public number htlc_event;
+ HTLCEvent(number htlc_event) { this.htlc_event = htlc_event; }
+ }
+ export class CommitmentTxBroadcasted extends LDKMonitorEvent {
+ public number commitment_tx_broadcasted;
+ CommitmentTxBroadcasted(number commitment_tx_broadcasted) { this.commitment_tx_broadcasted = commitment_tx_broadcasted; }
+ }
+ static native void init();
+ }
+ static { LDKMonitorEvent.init(); }
+ public static native LDKMonitorEvent LDKMonitorEvent_ref_from_ptr(long ptr);
+ public static native long LDKCVec_MonitorEventZ_new(number[] elems);
+ public static class LDKSpendableOutputDescriptor {
+ private LDKSpendableOutputDescriptor() {}
+ export class StaticOutput extends LDKSpendableOutputDescriptor {
+ public number outpoint;
+ public number output;
+ StaticOutput(number outpoint, number output) { this.outpoint = outpoint; this.output = output; }
+ }
+ export class DelayedPaymentOutput extends LDKSpendableOutputDescriptor {
+ public number delayed_payment_output;
+ DelayedPaymentOutput(number delayed_payment_output) { this.delayed_payment_output = delayed_payment_output; }
+ }
+ export class StaticPaymentOutput extends LDKSpendableOutputDescriptor {
+ public number static_payment_output;
+ StaticPaymentOutput(number static_payment_output) { this.static_payment_output = static_payment_output; }
+ }
+ static native void init();
+ }
+ static { LDKSpendableOutputDescriptor.init(); }
+ public static native LDKSpendableOutputDescriptor LDKSpendableOutputDescriptor_ref_from_ptr(long ptr);
+ public static native long LDKCVec_SpendableOutputDescriptorZ_new(number[] elems);
+ public static class LDKEvent {
+ private LDKEvent() {}
+ export class FundingGenerationReady extends LDKEvent {
+ public Uint8Array temporary_channel_id;
+ public number channel_value_satoshis;
+ public Uint8Array output_script;
+ public number user_channel_id;
+ FundingGenerationReady(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
+ }
+ export class PaymentReceived extends LDKEvent {
+ public Uint8Array payment_hash;
+ public Uint8Array payment_secret;
+ public number amt;
+ PaymentReceived(Uint8Array payment_hash, Uint8Array payment_secret, number amt) { this.payment_hash = payment_hash; this.payment_secret = payment_secret; this.amt = amt; }
+ }
+ export class PaymentSent extends LDKEvent {
+ public Uint8Array payment_preimage;
+ PaymentSent(Uint8Array payment_preimage) { this.payment_preimage = payment_preimage; }
+ }
+ export class PaymentFailed extends LDKEvent {
+ public Uint8Array payment_hash;
+ public boolean rejected_by_dest;
+ PaymentFailed(Uint8Array payment_hash, boolean rejected_by_dest) { this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; }
+ }
+ export class PendingHTLCsForwardable extends LDKEvent {
+ public number time_forwardable;
+ PendingHTLCsForwardable(number time_forwardable) { this.time_forwardable = time_forwardable; }
+ }
+ export class SpendableOutputs extends LDKEvent {
+ public number[] outputs;
+ SpendableOutputs(number[] outputs) { this.outputs = outputs; }
+ }
+ static native void init();
+ }
+ static { LDKEvent.init(); }
+ public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
+ public static native long LDKCVec_EventZ_new(number[] elems);
+ public static native long LDKC2Tuple_usizeTransactionZ_new(number a, Uint8Array b);
+ public static native number LDKC2Tuple_usizeTransactionZ_get_a(long ptr);
+ public static native Uint8Array LDKC2Tuple_usizeTransactionZ_get_b(long ptr);
+ public static native long LDKCVec_C2Tuple_usizeTransactionZZ_new(number[] elems);
+ public static native long LDKC2Tuple_u32TxOutZ_new(number a, number b);
+ public static native number LDKC2Tuple_u32TxOutZ_get_a(long ptr);
+ public static native number LDKC2Tuple_u32TxOutZ_get_b(long ptr);
+ public static native long LDKCVec_C2Tuple_u32TxOutZZ_new(number[] elems);
+ public static native long LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(Uint8Array a, number[] b);
+ public static native Uint8Array LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(long ptr);
+ public static native number[] LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(long ptr);
+ public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(number[] elems);
+ public static native boolean LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
+ public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
+ public static native LDKChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(long arg);
+ public static native long LDKC2Tuple_SignatureCVec_SignatureZZ_new(Uint8Array a, Uint8Array[] b);
+ public static native Uint8Array LDKC2Tuple_SignatureCVec_SignatureZZ_get_a(long ptr);
+ public static native Uint8Array[] LDKC2Tuple_SignatureCVec_SignatureZZ_get_b(long ptr);
+ public static native boolean LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(long arg);
+ public static native number LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(long arg);
+ public static native void LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_SignatureNoneZ_result_ok(long arg);
+ public static native Uint8Array LDKCResult_SignatureNoneZ_get_ok(long arg);
+ public static native void LDKCResult_SignatureNoneZ_get_err(long arg);
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKBaseSign {
+ get_per_commitment_point (idx: number): Uint8Array;
+ release_commitment_secret (idx: number): Uint8Array;
+ channel_keys_id (): Uint8Array;
+ sign_counterparty_commitment (commitment_tx: number): number;
+ sign_holder_commitment_and_htlcs (commitment_tx: number): number;
+ sign_justice_transaction (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number;
+ sign_counterparty_htlc_transaction (htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number;
+ sign_closing_transaction (closing_tx: Uint8Array): number;
+ sign_channel_announcement (msg: number): number;
+ ready_channel (channel_parameters: number): void;
+ }
+
+ export function LDKBaseSign_new(impl: LDKBaseSign, pubkeys: number): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // LDKPublicKey BaseSign_get_per_commitment_point LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
+ export function BaseSign_get_per_commitment_point(this_arg: number, idx: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_get_per_commitment_point(this_arg, idx);
+ return decodeArray(nativeResponseValue);
+ }
+ // LDKThirtyTwoBytes BaseSign_release_commitment_secret LDKBaseSign *NONNULL_PTR this_arg, uint64_t idx
+ export function BaseSign_release_commitment_secret(this_arg: number, idx: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_release_commitment_secret(this_arg, idx);
+ return decodeArray(nativeResponseValue);
+ }
+ // LDKThirtyTwoBytes BaseSign_channel_keys_id LDKBaseSign *NONNULL_PTR this_arg
+ export function BaseSign_channel_keys_id(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_channel_keys_id(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_counterparty_commitment LDKBaseSign *NONNULL_PTR this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
+ export function BaseSign_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_counterparty_commitment(this_arg, commitment_tx);
+ return nativeResponseValue;
+ }
+ // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ BaseSign_sign_holder_commitment_and_htlcs LDKBaseSign *NONNULL_PTR this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
+ export function BaseSign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
+ return nativeResponseValue;
+ }
+ // LDKCResult_SignatureNoneZ BaseSign_sign_justice_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
+ export function BaseSign_sign_justice_transaction(this_arg: number, justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc);
+ return nativeResponseValue;
+ }
+ // LDKCResult_SignatureNoneZ BaseSign_sign_counterparty_htlc_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
+ export function BaseSign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc);
+ return nativeResponseValue;
+ }
+ // LDKCResult_SignatureNoneZ BaseSign_sign_closing_transaction LDKBaseSign *NONNULL_PTR this_arg, struct LDKTransaction closing_tx
+ export function BaseSign_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_closing_transaction(this_arg, encodeArray(closing_tx));
+ return nativeResponseValue;
+ }
+ // LDKCResult_SignatureNoneZ BaseSign_sign_channel_announcement LDKBaseSign *NONNULL_PTR this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
+ export function BaseSign_sign_channel_announcement(this_arg: number, msg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_sign_channel_announcement(this_arg, msg);
+ return nativeResponseValue;
+ }
+ // void BaseSign_ready_channel LDKBaseSign *NONNULL_PTR this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
+ export function BaseSign_ready_channel(this_arg: number, channel_parameters: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_ready_channel(this_arg, channel_parameters);
+ // debug statements here
+ }
+ // LDKChannelPublicKeys BaseSign_get_pubkeys LDKBaseSign *NONNULL_PTR this_arg
+ export function BaseSign_get_pubkeys(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_get_pubkeys(this_arg);
+ return nativeResponseValue;
+ }
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKSign {
+ write (): Uint8Array;
+ }
+
+ export function LDKSign_new(impl: LDKSign, BaseSign: LDKBaseSign, pubkeys: number): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // LDKCVec_u8Z Sign_write LDKSign *NONNULL_PTR this_arg
+ export function Sign_write(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Sign_write(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ public static native long LDKC2Tuple_BlockHashChannelMonitorZ_new(Uint8Array a, number b);
+ public static native Uint8Array LDKC2Tuple_BlockHashChannelMonitorZ_get_a(long ptr);
+ public static native number LDKC2Tuple_BlockHashChannelMonitorZ_get_b(long ptr);
+ public static native boolean LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(long arg);
+ public static native long LDKCVec_RouteHopZ_new(number[] elems);
+ public static native boolean LDKCResult_RouteDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_RouteDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_RouteDecodeErrorZ_get_err(long arg);
+ public static class LDKCOption_u64Z {
+ private LDKCOption_u64Z() {}
+ export class Some extends LDKCOption_u64Z {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_u64Z {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_u64Z.init(); }
+ public static native LDKCOption_u64Z LDKCOption_u64Z_ref_from_ptr(long ptr);
+ public static native long LDKCVec_ChannelDetailsZ_new(number[] elems);
+ public static native long LDKCVec_RouteHintZ_new(number[] elems);
+ public static native boolean LDKCResult_RouteLightningErrorZ_result_ok(long arg);
+ public static native number LDKCResult_RouteLightningErrorZ_get_ok(long arg);
+ public static native number LDKCResult_RouteLightningErrorZ_get_err(long arg);
public static class LDKErrorAction {
private LDKErrorAction() {}
export class DisconnectPeer extends LDKErrorAction {
public number msg;
SendShortIdsQuery(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
}
+ export class SendReplyChannelRange extends LDKMessageSendEvent {
+ public Uint8Array node_id;
+ public number msg;
+ SendReplyChannelRange(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
+ }
static native void init();
}
static { LDKMessageSendEvent.init(); }
public static native boolean LDKCResult_boolPeerHandleErrorZ_result_ok(long arg);
public static native boolean LDKCResult_boolPeerHandleErrorZ_get_ok(long arg);
public static native number LDKCResult_boolPeerHandleErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_TxOutAccessErrorZ_result_ok(long arg);
+ public static native number LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
+ public static native LDKAccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
+ public static class LDKCOption_C2Tuple_usizeTransactionZZ {
+ private LDKCOption_C2Tuple_usizeTransactionZZ() {}
+ export class Some extends LDKCOption_C2Tuple_usizeTransactionZZ {
+ public number some;
+ Some(number some) { this.some = some; }
+ }
+ export class None extends LDKCOption_C2Tuple_usizeTransactionZZ {
+ None() { }
+ }
+ static native void init();
+ }
+ static { LDKCOption_C2Tuple_usizeTransactionZZ.init(); }
+ public static native LDKCOption_C2Tuple_usizeTransactionZZ LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(long ptr);
public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
public static native boolean LDKCResult_NetworkGraphDecodeErrorZ_result_ok(long arg);
public static native number LDKCResult_NetworkGraphDecodeErrorZ_get_ok(long arg);
public static native number LDKCResult_NetworkGraphDecodeErrorZ_get_err(long arg);
- public static native long LDKC2Tuple_usizeTransactionZ_new(number a, Uint8Array b);
- public static native number LDKC2Tuple_usizeTransactionZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_usizeTransactionZ_get_b(long ptr);
- public static native long LDKCVec_C2Tuple_usizeTransactionZZ_new(number[] elems);
- public static native boolean LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(long arg);
- public static native void LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(long arg);
- public static native LDKChannelMonitorUpdateErr LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(long arg);
- public static class LDKMonitorEvent {
- private LDKMonitorEvent() {}
- export class HTLCEvent extends LDKMonitorEvent {
- HTLCEvent() { }
- }
- export class CommitmentTxBroadcasted extends LDKMonitorEvent {
- CommitmentTxBroadcasted() { }
- }
- static native void init();
- }
- static { LDKMonitorEvent.init(); }
- public static native LDKMonitorEvent LDKMonitorEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_MonitorEventZ_new(number[] elems);
- public static class LDKSpendableOutputDescriptor {
- private LDKSpendableOutputDescriptor() {}
- export class StaticOutput extends LDKSpendableOutputDescriptor {
- public number outpoint;
- public number output;
- StaticOutput(number outpoint, number output) { this.outpoint = outpoint; this.output = output; }
- }
- export class DelayedPaymentOutput extends LDKSpendableOutputDescriptor {
- DelayedPaymentOutput() { }
- }
- export class StaticPaymentOutput extends LDKSpendableOutputDescriptor {
- StaticPaymentOutput() { }
- }
- static native void init();
- }
- static { LDKSpendableOutputDescriptor.init(); }
- public static native LDKSpendableOutputDescriptor LDKSpendableOutputDescriptor_ref_from_ptr(long ptr);
- public static native long LDKCVec_SpendableOutputDescriptorZ_new(number[] elems);
- public static class LDKEvent {
- private LDKEvent() {}
- export class FundingGenerationReady extends LDKEvent {
- public Uint8Array temporary_channel_id;
- public number channel_value_satoshis;
- public Uint8Array output_script;
- public number user_channel_id;
- FundingGenerationReady(Uint8Array temporary_channel_id, number channel_value_satoshis, Uint8Array output_script, number user_channel_id) { this.temporary_channel_id = temporary_channel_id; this.channel_value_satoshis = channel_value_satoshis; this.output_script = output_script; this.user_channel_id = user_channel_id; }
- }
- export class FundingBroadcastSafe extends LDKEvent {
- public number funding_txo;
- public number user_channel_id;
- FundingBroadcastSafe(number funding_txo, number user_channel_id) { this.funding_txo = funding_txo; this.user_channel_id = user_channel_id; }
- }
- export class PaymentReceived extends LDKEvent {
- public Uint8Array payment_hash;
- public Uint8Array payment_secret;
- public number amt;
- PaymentReceived(Uint8Array payment_hash, Uint8Array payment_secret, number amt) { this.payment_hash = payment_hash; this.payment_secret = payment_secret; this.amt = amt; }
- }
- export class PaymentSent extends LDKEvent {
- public Uint8Array payment_preimage;
- PaymentSent(Uint8Array payment_preimage) { this.payment_preimage = payment_preimage; }
- }
- export class PaymentFailed extends LDKEvent {
- public Uint8Array payment_hash;
- public boolean rejected_by_dest;
- PaymentFailed(Uint8Array payment_hash, boolean rejected_by_dest) { this.payment_hash = payment_hash; this.rejected_by_dest = rejected_by_dest; }
- }
- export class PendingHTLCsForwardable extends LDKEvent {
- public number time_forwardable;
- PendingHTLCsForwardable(number time_forwardable) { this.time_forwardable = time_forwardable; }
- }
- export class SpendableOutputs extends LDKEvent {
- public number[] outputs;
- SpendableOutputs(number[] outputs) { this.outputs = outputs; }
- }
- static native void init();
- }
- static { LDKEvent.init(); }
- public static native LDKEvent LDKEvent_ref_from_ptr(long ptr);
- public static native long LDKCVec_EventZ_new(number[] elems);
- public static native boolean LDKCResult_OutPointDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_OutPointDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_OutPointDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_HTLCUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NoneMonitorUpdateErrorZ_result_ok(long arg);
- public static native void LDKCResult_NoneMonitorUpdateErrorZ_get_ok(long arg);
- public static native number LDKCResult_NoneMonitorUpdateErrorZ_get_err(long arg);
- public static native long LDKC2Tuple_OutPointScriptZ_new(number a, Uint8Array b);
- public static native number LDKC2Tuple_OutPointScriptZ_get_a(long ptr);
- public static native Uint8Array LDKC2Tuple_OutPointScriptZ_get_b(long ptr);
- public static native long LDKC2Tuple_u32TxOutZ_new(number a, number b);
- public static native number LDKC2Tuple_u32TxOutZ_get_a(long ptr);
- public static native number LDKC2Tuple_u32TxOutZ_get_b(long ptr);
- public static native long LDKCVec_C2Tuple_u32TxOutZZ_new(number[] elems);
- public static native long LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(Uint8Array a, number[] b);
- public static native Uint8Array LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(long ptr);
- public static native number[] LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(long ptr);
- public static native long LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(number[] elems);
- public static native long LDKC2Tuple_SignatureCVec_SignatureZZ_new(Uint8Array a, Uint8Array[] b);
- public static native Uint8Array LDKC2Tuple_SignatureCVec_SignatureZZ_get_a(long ptr);
- public static native Uint8Array[] LDKC2Tuple_SignatureCVec_SignatureZZ_get_b(long ptr);
- public static native boolean LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(long arg);
- public static native number LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(long arg);
- public static native void LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_SignatureNoneZ_result_ok(long arg);
- public static native Uint8Array LDKCResult_SignatureNoneZ_get_ok(long arg);
- public static native void LDKCResult_SignatureNoneZ_get_err(long arg);
-
-
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
-
- export interface LDKSign {
- get_per_commitment_point (idx: number): Uint8Array;
- release_commitment_secret (idx: number): Uint8Array;
- channel_keys_id (): Uint8Array;
- sign_counterparty_commitment (commitment_tx: number): number;
- sign_holder_commitment_and_htlcs (commitment_tx: number): number;
- sign_justice_transaction (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number;
- sign_counterparty_htlc_transaction (htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number;
- sign_closing_transaction (closing_tx: Uint8Array): number;
- sign_channel_announcement (msg: number): number;
- ready_channel (channel_parameters: number): void;
- write (): Uint8Array;
- }
-
- export function LDKSign_new(impl: LDKSign, pubkeys: number): number {
- throw new Error('unimplemented'); // TODO: bind to WASM
- }
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
-
-
- // LDKPublicKey Sign_get_per_commitment_point LDKSign* this_arg, uint64_t idx
- export function Sign_get_per_commitment_point(this_arg: number, idx: number): Uint8Array {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_get_per_commitment_point(this_arg, idx);
- return decodeArray(nativeResponseValue);
- }
- // LDKThirtyTwoBytes Sign_release_commitment_secret LDKSign* this_arg, uint64_t idx
- export function Sign_release_commitment_secret(this_arg: number, idx: number): Uint8Array {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_release_commitment_secret(this_arg, idx);
- return decodeArray(nativeResponseValue);
- }
- // LDKThirtyTwoBytes Sign_channel_keys_id LDKSign* this_arg
- export function Sign_channel_keys_id(this_arg: number): Uint8Array {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_channel_keys_id(this_arg);
- return decodeArray(nativeResponseValue);
- }
- // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_counterparty_commitment LDKSign* this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx
- export function Sign_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_counterparty_commitment(this_arg, commitment_tx);
- return nativeResponseValue;
- }
- // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_holder_commitment_and_htlcs LDKSign* this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx
- export function Sign_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx);
- return nativeResponseValue;
- }
- // LDKCResult_SignatureNoneZ Sign_sign_justice_transaction LDKSign* this_arg, struct LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (*per_commitment_key)[32], const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
- export function Sign_sign_justice_transaction(this_arg: number, justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc);
- return nativeResponseValue;
- }
- // LDKCResult_SignatureNoneZ Sign_sign_counterparty_htlc_transaction LDKSign* this_arg, struct LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, struct LDKPublicKey per_commitment_point, const struct LDKHTLCOutputInCommitment *NONNULL_PTR htlc
- export function Sign_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc);
- return nativeResponseValue;
- }
- // LDKCResult_SignatureNoneZ Sign_sign_closing_transaction LDKSign* this_arg, struct LDKTransaction closing_tx
- export function Sign_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_closing_transaction(this_arg, encodeArray(closing_tx));
- return nativeResponseValue;
- }
- // LDKCResult_SignatureNoneZ Sign_sign_channel_announcement LDKSign* this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg
- export function Sign_sign_channel_announcement(this_arg: number, msg: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_sign_channel_announcement(this_arg, msg);
- return nativeResponseValue;
- }
- // void Sign_ready_channel LDKSign* this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters
- export function Sign_ready_channel(this_arg: number, channel_parameters: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_ready_channel(this_arg, channel_parameters);
- // debug statements here
- }
- // LDKCVec_u8Z Sign_write LDKSign* this_arg
- export function Sign_write(this_arg: number): Uint8Array {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_write(this_arg);
- return decodeArray(nativeResponseValue);
- }
- // LDKChannelPublicKeys Sign_get_pubkeys LDKSign* this_arg
- export function Sign_get_pubkeys(this_arg: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.Sign_get_pubkeys(this_arg);
- return nativeResponseValue;
- }
- public static native long LDKC2Tuple_BlockHashChannelMonitorZ_new(Uint8Array a, number b);
- public static native Uint8Array LDKC2Tuple_BlockHashChannelMonitorZ_get_a(long ptr);
- public static native number LDKC2Tuple_BlockHashChannelMonitorZ_get_b(long ptr);
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_TxOutAccessErrorZ_result_ok(long arg);
- public static native number LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
- public static native LDKAccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_InitFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InitFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_NodeFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NetAddressu8Z_result_ok(long arg);
+ public static native number LDKCResult_NetAddressu8Z_get_ok(long arg);
+ public static native number LDKCResult_NetAddressu8Z_get_err(long arg);
+ public static native boolean LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_err(long arg);
+ public static native long LDKCVec_UpdateAddHTLCZ_new(number[] elems);
+ public static native long LDKCVec_UpdateFulfillHTLCZ_new(number[] elems);
+ public static native long LDKCVec_UpdateFailHTLCZ_new(number[] elems);
+ public static native long LDKCVec_UpdateFailMalformedHTLCZ_new(number[] elems);
+ public static native boolean LDKCResult_AcceptChannelDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ClosingSignedDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_FundingCreatedDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_FundingSignedDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_FundingSignedDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_FundingSignedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_FundingLockedDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_FundingLockedDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_FundingLockedDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_InitDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InitDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InitDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_OpenChannelDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_OpenChannelDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_OpenChannelDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ShutdownDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ShutdownDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ShutdownDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UpdateFeeDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_PingDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_PingDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_PingDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_PongDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_PongDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_PongDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ErrorMessageDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_SignDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_SignDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_SignDecodeErrorZ_get_err(long arg);
+ public static native boolean LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(long arg);
+ public static native Uint8Array[] LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(long arg);
+ public static native void LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_InMemorySignerDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_err(long arg);
+ public static native long LDKCVec_TxOutZ_new(number[] elems);
+ public static native boolean LDKCResult_TransactionNoneZ_result_ok(long arg);
+ public static native Uint8Array LDKCResult_TransactionNoneZ_get_ok(long arg);
+ public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
+ public static native boolean LDKCResult_NoneErrorZ_result_ok(long arg);
+ public static native void LDKCResult_NoneErrorZ_get_ok(long arg);
+ public static native LDKIOError LDKCResult_NoneErrorZ_get_err(long arg);
+ public static native long LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(number[] elems);
+ public static native boolean LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(long arg);
+ public static native number[] LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(long arg);
+ public static native LDKIOError LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_err(long arg);
public static class LDKAPIError {
private LDKAPIError() {}
export class APIMisuseError extends LDKAPIError {
public static native number LDKCResult_NoneAPIErrorZ_get_err(long arg);
public static native long LDKCVec_CResult_NoneAPIErrorZZ_new(number[] elems);
public static native long LDKCVec_APIErrorZ_new(number[] elems);
- public static native long LDKCVec_ChannelDetailsZ_new(number[] elems);
public static class LDKPaymentSendFailure {
private LDKPaymentSendFailure() {}
export class ParameterError extends LDKPaymentSendFailure {
- ParameterError() { }
+ public number parameter_error;
+ ParameterError(number parameter_error) { this.parameter_error = parameter_error; }
}
export class PathParameterError extends LDKPaymentSendFailure {
- PathParameterError() { }
+ public number[] path_parameter_error;
+ PathParameterError(number[] path_parameter_error) { this.path_parameter_error = path_parameter_error; }
}
export class AllFailedRetrySafe extends LDKPaymentSendFailure {
- AllFailedRetrySafe() { }
+ public number[] all_failed_retry_safe;
+ AllFailedRetrySafe(number[] all_failed_retry_safe) { this.all_failed_retry_safe = all_failed_retry_safe; }
}
export class PartialFailure extends LDKPaymentSendFailure {
- PartialFailure() { }
+ public number[] partial_failure;
+ PartialFailure(number[] partial_failure) { this.partial_failure = partial_failure; }
}
static native void init();
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch* this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
+ // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_watch_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitor monitor
export function Watch_watch_channel(this_arg: number, funding_txo: number, monitor: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.Watch_watch_channel(this_arg, funding_txo, monitor);
return nativeResponseValue;
}
- // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch* this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
+ // LDKCResult_NoneChannelMonitorUpdateErrZ Watch_update_channel LDKWatch *NONNULL_PTR this_arg, struct LDKOutPoint funding_txo, struct LDKChannelMonitorUpdate update
export function Watch_update_channel(this_arg: number, funding_txo: number, update: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.Watch_update_channel(this_arg, funding_txo, update);
return nativeResponseValue;
}
- // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch* this_arg
+ // LDKCVec_MonitorEventZ Watch_release_pending_monitor_events LDKWatch *NONNULL_PTR this_arg
export function Watch_release_pending_monitor_events(this_arg: number): number[] {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface* this_arg, struct LDKTransaction tx
+ // void BroadcasterInterface_broadcast_transaction LDKBroadcasterInterface *NONNULL_PTR this_arg, struct LDKTransaction tx
export function BroadcasterInterface_broadcast_transaction(this_arg: number, tx: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.BroadcasterInterface_broadcast_transaction(this_arg, encodeArray(tx));
// debug statements here
}
- public static native boolean LDKCResult_SignDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_SignDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_SignDecodeErrorZ_get_err(long arg);
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKSecretKey KeysInterface_get_node_secret LDKKeysInterface* this_arg
+ // LDKSecretKey KeysInterface_get_node_secret LDKKeysInterface *NONNULL_PTR this_arg
export function KeysInterface_get_node_secret(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.KeysInterface_get_node_secret(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface* this_arg
+ // LDKCVec_u8Z KeysInterface_get_destination_script LDKKeysInterface *NONNULL_PTR this_arg
export function KeysInterface_get_destination_script(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.KeysInterface_get_destination_script(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKPublicKey KeysInterface_get_shutdown_pubkey LDKKeysInterface* this_arg
+ // LDKPublicKey KeysInterface_get_shutdown_pubkey LDKKeysInterface *NONNULL_PTR this_arg
export function KeysInterface_get_shutdown_pubkey(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.KeysInterface_get_shutdown_pubkey(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKSign KeysInterface_get_channel_signer LDKKeysInterface* this_arg, bool inbound, uint64_t channel_value_satoshis
+ // LDKSign KeysInterface_get_channel_signer LDKKeysInterface *NONNULL_PTR this_arg, bool inbound, uint64_t channel_value_satoshis
export function KeysInterface_get_channel_signer(this_arg: number, inbound: boolean, channel_value_satoshis: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.KeysInterface_get_channel_signer(this_arg, inbound, channel_value_satoshis);
return nativeResponseValue;
}
- // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface* this_arg
+ // LDKThirtyTwoBytes KeysInterface_get_secure_random_bytes LDKKeysInterface *NONNULL_PTR this_arg
export function KeysInterface_get_secure_random_bytes(this_arg: number): Uint8Array {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.KeysInterface_get_secure_random_bytes(this_arg);
return decodeArray(nativeResponseValue);
}
- // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface* this_arg, struct LDKu8slice reader
+ // LDKCResult_SignDecodeErrorZ KeysInterface_read_chan_signer LDKKeysInterface *NONNULL_PTR this_arg, struct LDKu8slice reader
export function KeysInterface_read_chan_signer(this_arg: number, reader: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
- export interface LDKFeeEstimator {
- get_est_sat_per_1000_weight (confirmation_target: LDKConfirmationTarget): number;
- }
-
- export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
- throw new Error('unimplemented'); // TODO: bind to WASM
- }
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
-
-
- // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator* this_arg, enum LDKConfirmationTarget confirmation_target
- export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: LDKConfirmationTarget): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
- return nativeResponseValue;
- }
-
-
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
-
- export interface LDKLogger {
- log (record: String): void;
- }
-
- export function LDKLogger_new(impl: LDKLogger): number {
- throw new Error('unimplemented'); // TODO: bind to WASM
- }
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
-
-
- public static native long LDKC2Tuple_BlockHashChannelManagerZ_new(Uint8Array a, number b);
- public static native Uint8Array LDKC2Tuple_BlockHashChannelManagerZ_get_a(long ptr);
- public static native number LDKC2Tuple_BlockHashChannelManagerZ_get_b(long ptr);
- public static native boolean LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(long arg);
- public static native Uint8Array[] LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(long arg);
- public static native void LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(long arg);
- public static native boolean LDKCResult_InMemorySignerDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_InMemorySignerDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_TxOutZ_new(number[] elems);
- public static native boolean LDKCResult_TransactionNoneZ_result_ok(long arg);
- public static native Uint8Array LDKCResult_TransactionNoneZ_get_ok(long arg);
- public static native void LDKCResult_TransactionNoneZ_get_err(long arg);
- public static native long LDKCVec_RouteHopZ_new(number[] elems);
- public static native boolean LDKCResult_RouteDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_RouteDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_RouteDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_RouteHintZ_new(number[] elems);
- public static native boolean LDKCResult_RouteLightningErrorZ_result_ok(long arg);
- public static native number LDKCResult_RouteLightningErrorZ_get_ok(long arg);
- public static native number LDKCResult_RouteLightningErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NetAddressu8Z_result_ok(long arg);
- public static native number LDKCResult_NetAddressu8Z_get_ok(long arg);
- public static native number LDKCResult_NetAddressu8Z_get_err(long arg);
- public static native boolean LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_err(long arg);
- public static native long LDKCVec_UpdateAddHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFulfillHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFailHTLCZ_new(number[] elems);
- public static native long LDKCVec_UpdateFailMalformedHTLCZ_new(number[] elems);
- public static native boolean LDKCResult_AcceptChannelDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_AcceptChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelReestablishDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ClosingSignedDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ClosingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_CommitmentSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingCreatedDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_FundingCreatedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingSignedDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_FundingSignedDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_FundingSignedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_FundingLockedDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_FundingLockedDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_FundingLockedDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_InitDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_InitDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_InitDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_OpenChannelDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_OpenChannelDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_OpenChannelDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_RevokeAndACKDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ShutdownDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ShutdownDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ShutdownDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UpdateFailHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFeeDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UpdateFeeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UpdateAddHTLCDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PingDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_PingDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_PingDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_PongDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_PongDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_PongDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ChannelUpdateDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ErrorMessageDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ErrorMessageDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_NodeAnnouncementDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_QueryChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_ReplyChannelRangeDecodeErrorZ_get_err(long arg);
- public static native boolean LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(long arg);
- public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(long arg);
- public static native number LDKCResult_GossipTimestampFilterDecodeErrorZ_get_err(long arg);
-
-
-
-// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
-
+ export interface LDKFeeEstimator {
+ get_est_sat_per_1000_weight (confirmation_target: LDKConfirmationTarget): number;
+ }
+
+ export function LDKFeeEstimator_new(impl: LDKFeeEstimator): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator *NONNULL_PTR this_arg, enum LDKConfirmationTarget confirmation_target
+ export function FeeEstimator_get_est_sat_per_1000_weight(this_arg: number, confirmation_target: LDKConfirmationTarget): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FeeEstimator_get_est_sat_per_1000_weight(this_arg, confirmation_target);
+ return nativeResponseValue;
+ }
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
+ export interface LDKLogger {
+ log (record: String): void;
+ }
+
+ export function LDKLogger_new(impl: LDKLogger): number {
+ throw new Error('unimplemented'); // TODO: bind to WASM
+ }
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
+
+
+ public static native long LDKC2Tuple_BlockHashChannelManagerZ_new(Uint8Array a, number b);
+ public static native Uint8Array LDKC2Tuple_BlockHashChannelManagerZ_get_a(long ptr);
+ public static native number LDKC2Tuple_BlockHashChannelManagerZ_get_b(long ptr);
+ public static native boolean LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(long arg);
+ public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(long arg);
+ public static native number LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(long arg);
+
+
+
+// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START
+
export interface LDKMessageSendEventsProvider {
get_and_clear_pending_msg_events (): number[];
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider* this_arg
+ // LDKCVec_MessageSendEventZ MessageSendEventsProvider_get_and_clear_pending_msg_events LDKMessageSendEventsProvider *NONNULL_PTR this_arg
export function MessageSendEventsProvider_get_and_clear_pending_msg_events(this_arg: number): number[] {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCVec_EventZ EventsProvider_get_and_clear_pending_events LDKEventsProvider* this_arg
+ // LDKCVec_EventZ EventsProvider_get_and_clear_pending_events LDKEventsProvider *NONNULL_PTR this_arg
export function EventsProvider_get_and_clear_pending_events(this_arg: number): number[] {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess* this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
+ // LDKCResult_TxOutAccessErrorZ Access_get_utxo LDKAccess *NONNULL_PTR this_arg, const uint8_t (*genesis_hash)[32], uint64_t short_channel_id
export function Access_get_utxo(this_arg: number, genesis_hash: Uint8Array, short_channel_id: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // void Listen_block_connected LDKListen* this_arg, struct LDKu8slice block, uint32_t height
+ // void Listen_block_connected LDKListen *NONNULL_PTR this_arg, struct LDKu8slice block, uint32_t height
export function Listen_block_connected(this_arg: number, block: Uint8Array, height: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.Listen_block_connected(this_arg, encodeArray(block), height);
// debug statements here
}
- // void Listen_block_disconnected LDKListen* this_arg, const uint8_t (*header)[80], uint32_t height
+ // void Listen_block_disconnected LDKListen *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height
export function Listen_block_disconnected(this_arg: number, header: Uint8Array, height: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
export interface LDKFilter {
register_tx (txid: Uint8Array, script_pubkey: Uint8Array): void;
- register_output (outpoint: number, script_pubkey: Uint8Array): void;
+ register_output (output: number): number;
}
export function LDKFilter_new(impl: LDKFilter): number {
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // void Filter_register_tx LDKFilter* this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
+ // void Filter_register_tx LDKFilter *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKu8slice script_pubkey
export function Filter_register_tx(this_arg: number, txid: Uint8Array, script_pubkey: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.Filter_register_tx(this_arg, encodeArray(txid), encodeArray(script_pubkey));
// debug statements here
}
- // void Filter_register_output LDKFilter* this_arg, const struct LDKOutPoint *NONNULL_PTR outpoint, struct LDKu8slice script_pubkey
- export function Filter_register_output(this_arg: number, outpoint: number, script_pubkey: Uint8Array): void {
+ // LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
+ export function Filter_register_output(this_arg: number, output: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Filter_register_output(this_arg, outpoint, encodeArray(script_pubkey));
- // debug statements here
+ const nativeResponseValue = wasm.Filter_register_output(this_arg, output);
+ return nativeResponseValue;
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_persist_new_channel LDKPersist* this_arg, struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data
+ // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_persist_new_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint id, const struct LDKChannelMonitor *NONNULL_PTR data
export function Persist_persist_new_channel(this_arg: number, id: number, data: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.Persist_persist_new_channel(this_arg, id, data);
return nativeResponseValue;
}
- // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_update_persisted_channel LDKPersist* this_arg, struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data
+ // LDKCResult_NoneChannelMonitorUpdateErrZ Persist_update_persisted_channel LDKPersist *NONNULL_PTR this_arg, struct LDKOutPoint id, const struct LDKChannelMonitorUpdate *NONNULL_PTR update, const struct LDKChannelMonitor *NONNULL_PTR data
export function Persist_update_persisted_channel(this_arg: number, id: number, update: number, data: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
peer_disconnected (their_node_id: Uint8Array, no_connection_possible: boolean): void;
peer_connected (their_node_id: Uint8Array, msg: number): void;
handle_channel_reestablish (their_node_id: Uint8Array, msg: number): void;
+ handle_channel_update (their_node_id: Uint8Array, msg: number): void;
handle_error (their_node_id: Uint8Array, msg: number): void;
}
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_open_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKOpenChannel *NONNULL_PTR msg
export function ChannelMessageHandler_handle_open_channel(this_arg: number, their_node_id: Uint8Array, their_features: number, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_open_channel(this_arg, encodeArray(their_node_id), their_features, msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_accept_channel LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKInitFeatures their_features, const struct LDKAcceptChannel *NONNULL_PTR msg
export function ChannelMessageHandler_handle_accept_channel(this_arg: number, their_node_id: Uint8Array, their_features: number, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_accept_channel(this_arg, encodeArray(their_node_id), their_features, msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_funding_created LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingCreated *NONNULL_PTR msg
export function ChannelMessageHandler_handle_funding_created(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_funding_created(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_funding_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingSigned *NONNULL_PTR msg
export function ChannelMessageHandler_handle_funding_signed(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_funding_signed(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_funding_locked LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKFundingLocked *NONNULL_PTR msg
export function ChannelMessageHandler_handle_funding_locked(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_funding_locked(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_shutdown LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInitFeatures *NONNULL_PTR their_features, const struct LDKShutdown *NONNULL_PTR msg
export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: Uint8Array, their_features: number, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_shutdown(this_arg, encodeArray(their_node_id), their_features, msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_closing_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKClosingSigned *NONNULL_PTR msg
export function ChannelMessageHandler_handle_closing_signed(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_closing_signed(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_update_add_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateAddHTLC *NONNULL_PTR msg
export function ChannelMessageHandler_handle_update_add_htlc(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_update_add_htlc(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_update_fulfill_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFulfillHTLC *NONNULL_PTR msg
export function ChannelMessageHandler_handle_update_fulfill_htlc(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_update_fulfill_htlc(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_update_fail_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailHTLC *NONNULL_PTR msg
export function ChannelMessageHandler_handle_update_fail_htlc(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_update_fail_htlc(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_update_fail_malformed_htlc LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR msg
export function ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_update_fail_malformed_htlc(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_commitment_signed LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKCommitmentSigned *NONNULL_PTR msg
export function ChannelMessageHandler_handle_commitment_signed(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_commitment_signed(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_revoke_and_ack LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKRevokeAndACK *NONNULL_PTR msg
export function ChannelMessageHandler_handle_revoke_and_ack(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_revoke_and_ack(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_update_fee LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKUpdateFee *NONNULL_PTR msg
export function ChannelMessageHandler_handle_update_fee(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_update_fee(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_announcement_signatures LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKAnnouncementSignatures *NONNULL_PTR msg
export function ChannelMessageHandler_handle_announcement_signatures(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_announcement_signatures(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
+ // void ChannelMessageHandler_peer_disconnected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, bool no_connection_possible
export function ChannelMessageHandler_peer_disconnected(this_arg: number, their_node_id: Uint8Array, no_connection_possible: boolean): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_peer_disconnected(this_arg, encodeArray(their_node_id), no_connection_possible);
// debug statements here
}
- // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
+ // void ChannelMessageHandler_peer_connected LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR msg
export function ChannelMessageHandler_peer_connected(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_peer_connected(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_channel_reestablish LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelReestablish *NONNULL_PTR msg
export function ChannelMessageHandler_handle_channel_reestablish(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_reestablish(this_arg, encodeArray(their_node_id), msg);
// debug statements here
}
- // void ChannelMessageHandler_handle_error LDKChannelMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
+ // void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+ export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: Uint8Array, msg: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_update(this_arg, encodeArray(their_node_id), msg);
+ // debug statements here
+ }
+ // void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: Uint8Array, msg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler* this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_node_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKNodeAnnouncement *NONNULL_PTR msg
export function RoutingMessageHandler_handle_node_announcement(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_node_announcement(this_arg, msg);
return nativeResponseValue;
}
- // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler* this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_announcement LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelAnnouncement *NONNULL_PTR msg
export function RoutingMessageHandler_handle_channel_announcement(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_channel_announcement(this_arg, msg);
return nativeResponseValue;
}
- // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler* this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
+ // LDKCResult_boolLightningErrorZ RoutingMessageHandler_handle_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKChannelUpdate *NONNULL_PTR msg
export function RoutingMessageHandler_handle_channel_update(this_arg: number, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_channel_update(this_arg, msg);
return nativeResponseValue;
}
- // void RoutingMessageHandler_handle_htlc_fail_channel_update LDKRoutingMessageHandler* this_arg, const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update
+ // void RoutingMessageHandler_handle_htlc_fail_channel_update LDKRoutingMessageHandler *NONNULL_PTR this_arg, const struct LDKHTLCFailChannelUpdate *NONNULL_PTR update
export function RoutingMessageHandler_handle_htlc_fail_channel_update(this_arg: number, update: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_htlc_fail_channel_update(this_arg, update);
// debug statements here
}
- // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler* this_arg, uint64_t starting_point, uint8_t batch_amount
+ // LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ RoutingMessageHandler_get_next_channel_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, uint64_t starting_point, uint8_t batch_amount
export function RoutingMessageHandler_get_next_channel_announcements(this_arg: number, starting_point: number, batch_amount: number): number[] {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_get_next_channel_announcements(this_arg, starting_point, batch_amount);
return nativeResponseValue;
}
- // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler* this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
+ // LDKCVec_NodeAnnouncementZ RoutingMessageHandler_get_next_node_announcements LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey starting_point, uint8_t batch_amount
export function RoutingMessageHandler_get_next_node_announcements(this_arg: number, starting_point: Uint8Array, batch_amount: number): number[] {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_get_next_node_announcements(this_arg, encodeArray(starting_point), batch_amount);
return nativeResponseValue;
}
- // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler* this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
+ // void RoutingMessageHandler_sync_routing_table LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKInit *NONNULL_PTR init
export function RoutingMessageHandler_sync_routing_table(this_arg: number, their_node_id: Uint8Array, init: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_sync_routing_table(this_arg, encodeArray(their_node_id), init);
// debug statements here
}
- // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyChannelRange msg
export function RoutingMessageHandler_handle_reply_channel_range(this_arg: number, their_node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_reply_channel_range(this_arg, encodeArray(their_node_id), msg);
return nativeResponseValue;
}
- // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_reply_short_channel_ids_end LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKReplyShortChannelIdsEnd msg
export function RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg: number, their_node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_reply_short_channel_ids_end(this_arg, encodeArray(their_node_id), msg);
return nativeResponseValue;
}
- // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_channel_range LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryChannelRange msg
export function RoutingMessageHandler_handle_query_channel_range(this_arg: number, their_node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.RoutingMessageHandler_handle_query_channel_range(this_arg, encodeArray(their_node_id), msg);
return nativeResponseValue;
}
- // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler* this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
+ // LDKCResult_NoneLightningErrorZ RoutingMessageHandler_handle_query_short_channel_ids LDKRoutingMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, struct LDKQueryShortChannelIds msg
export function RoutingMessageHandler_handle_query_short_channel_ids(this_arg: number, their_node_id: Uint8Array, msg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END
- // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor* this_arg, struct LDKu8slice data, bool resume_read
+ // uintptr_t SocketDescriptor_send_data LDKSocketDescriptor *NONNULL_PTR this_arg, struct LDKu8slice data, bool resume_read
export function SocketDescriptor_send_data(this_arg: number, data: Uint8Array, resume_read: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.SocketDescriptor_send_data(this_arg, encodeArray(data), resume_read);
return nativeResponseValue;
}
- // void SocketDescriptor_disconnect_socket LDKSocketDescriptor* this_arg
+ // void SocketDescriptor_disconnect_socket LDKSocketDescriptor *NONNULL_PTR this_arg
export function SocketDescriptor_disconnect_socket(this_arg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.SocketDescriptor_disconnect_socket(this_arg);
// debug statements here
}
- // uint64_t SocketDescriptor_hash LDKSocketDescriptor* this_arg
+ // uint64_t SocketDescriptor_hash LDKSocketDescriptor *NONNULL_PTR this_arg
export function SocketDescriptor_hash(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
const nativeResponseValue = wasm.TxOut_clone(orig);
return nativeResponseValue;
}
+ // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
+ export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
+ export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
+ export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_OutPointDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
+ export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_SecretKeyErrorZ CResult_SecretKeyErrorZ_ok(struct LDKSecretKey o);
export function CResult_SecretKeyErrorZ_ok(o: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_free(_res);
// debug statements here
}
+ // struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
+ export function COption_u32Z_some(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u32Z_some(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCOption_u32Z COption_u32Z_none(void);
+ export function COption_u32Z_none(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u32Z_none();
+ return nativeResponseValue;
+ }
+ // void COption_u32Z_free(struct LDKCOption_u32Z _res);
+ export function COption_u32Z_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u32Z_free(_res);
+ // debug statements here
+ }
+ // struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
+ export function COption_u32Z_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.COption_u32Z_clone(orig);
+ return nativeResponseValue;
+ }
// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_CommitmentTransactionDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
+ export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
+ export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_err();
+ return nativeResponseValue;
+ }
+ // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
+ export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
+ export function CResult_CVec_SignatureZNoneZ_ok(o: Uint8Array[]): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
+ export function CResult_CVec_SignatureZNoneZ_err(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_err();
+ return nativeResponseValue;
+ }
+ // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
+ export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
+ export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
+ export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_err(e);
+ return nativeResponseValue;
+ }
+ // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
+ export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_ok(struct LDKTrustedCommitmentTransaction o);
- export function CResult_TrustedCommitmentTransactionNoneZ_ok(o: number): number {
+ // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
+ export function CResult_NoneMonitorUpdateErrorZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_TrustedCommitmentTransactionNoneZ CResult_TrustedCommitmentTransactionNoneZ_err(void);
- export function CResult_TrustedCommitmentTransactionNoneZ_err(): number {
+ // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
+ export function CResult_NoneMonitorUpdateErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_err();
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_TrustedCommitmentTransactionNoneZ_free(struct LDKCResult_TrustedCommitmentTransactionNoneZ _res);
- export function CResult_TrustedCommitmentTransactionNoneZ_free(_res: number): void {
+ // void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
+ export function CResult_NoneMonitorUpdateErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TrustedCommitmentTransactionNoneZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_ok(struct LDKCVec_SignatureZ o);
- export function CResult_CVec_SignatureZNoneZ_ok(o: Uint8Array[]): number {
+ // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
+ export function CResult_NoneMonitorUpdateErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_err(void);
- export function CResult_CVec_SignatureZNoneZ_err(): number {
+ // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
+ export function C2Tuple_OutPointScriptZ_new(a: number, b: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_err();
+ const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_new(a, encodeArray(b));
return nativeResponseValue;
}
- // void CResult_CVec_SignatureZNoneZ_free(struct LDKCResult_CVec_SignatureZNoneZ _res);
- export function CResult_CVec_SignatureZNoneZ_free(_res: number): void {
+ // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
+ export function C2Tuple_OutPointScriptZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CVec_SignatureZNoneZ CResult_CVec_SignatureZNoneZ_clone(const struct LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR orig);
- export function CResult_CVec_SignatureZNoneZ_clone(orig: number): number {
+ // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_new(uint32_t a, struct LDKCVec_u8Z b);
+ export function C2Tuple_u32ScriptZ_new(a: number, b: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig);
+ const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_new(a, encodeArray(b));
return nativeResponseValue;
}
- // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
- export function CVec_MessageSendEventZ_free(_res: number[]): void {
+ // void C2Tuple_u32ScriptZ_free(struct LDKC2Tuple_u32ScriptZ _res);
+ export function C2Tuple_u32ScriptZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_MessageSendEventZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_free(_res);
// debug statements here
}
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
- export function CResult_boolLightningErrorZ_ok(o: boolean): number {
+ // void CVec_C2Tuple_u32ScriptZZ_free(struct LDKCVec_C2Tuple_u32ScriptZZ _res);
+ export function CVec_C2Tuple_u32ScriptZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_C2Tuple_u32ScriptZZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
- export function CResult_boolLightningErrorZ_err(e: number): number {
+ // struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32ScriptZZ b);
+ export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a: Uint8Array, b: number[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(encodeArray(a), b);
return nativeResponseValue;
}
- // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
- export function CResult_boolLightningErrorZ_free(_res: number): void {
+ // void C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res);
+ export function C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
- export function CResult_boolLightningErrorZ_clone(orig: number): number {
+ // void CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res);
+ export function CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res);
+ // debug statements here
}
- // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
+ // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
+ export function CVec_MonitorEventZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_MonitorEventZ_free(_res);
+ // debug statements here
}
- // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
+ // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
+ export function CVec_EventZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_EventZ_free(_res);
+ // debug statements here
}
- // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
- export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
+ // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
+ export function CVec_TransactionZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
+ const nativeResponseValue = wasm.CVec_TransactionZ_free(_res);
// debug statements here
}
- // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
- export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
+ // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
+ export function C2Tuple_usizeTransactionZ_new(a: number, b: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_new(a, encodeArray(b));
+ return nativeResponseValue;
}
- // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
- export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
+ // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
+ export function C2Tuple_usizeTransactionZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
- export function CResult_NoneLightningErrorZ_ok(): number {
+ // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
+ export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_C2Tuple_usizeTransactionZZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
- export function CResult_NoneLightningErrorZ_err(e: number): number {
+ // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
+ export function C2Tuple_u32TxOutZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
- export function CResult_NoneLightningErrorZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
- export function CResult_NoneLightningErrorZ_clone(orig: number): number {
+ // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
+ export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_new(a, b);
return nativeResponseValue;
}
- // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
- export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
+ // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
+ export function C2Tuple_u32TxOutZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_PublicKeyZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_free(_res);
// debug statements here
}
- // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
- export function CVec_u8Z_free(_res: Uint8Array): void {
+ // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
+ export function CVec_C2Tuple_u32TxOutZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_u8Z_free(encodeArray(_res));
+ const nativeResponseValue = wasm.CVec_C2Tuple_u32TxOutZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
- export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: Uint8Array): number {
+ // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
+ export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: Uint8Array, b: number[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_ok(encodeArray(o));
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(encodeArray(a), b);
return nativeResponseValue;
}
- // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
- export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
+ // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
+ export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
+ // debug statements here
}
- // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
- export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
+ // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
+ export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
- export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
+ // void CVec_TxidZ_free(struct LDKCVec_TxidZ _res);
+ export function CVec_TxidZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_TxidZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
- export function CResult_NonePeerHandleErrorZ_ok(): number {
+ // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
+ export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_ok();
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
- export function CResult_NonePeerHandleErrorZ_err(e: number): number {
+ // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
+ export function CResult_NoneChannelMonitorUpdateErrZ_err(e: LDKChannelMonitorUpdateErr): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_err(e);
return nativeResponseValue;
}
- // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
- export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
+ // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
+ export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
- export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
+ export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
- export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
+ // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
+ export function C2Tuple_BlockHashChannelMonitorZ_new(a: Uint8Array, b: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_ok(o);
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_new(encodeArray(a), b);
return nativeResponseValue;
}
- // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
- export function CResult_boolPeerHandleErrorZ_err(e: number): number {
+ // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
+ export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_free(_res);
+ // debug statements here
}
- // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
- export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
+ // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
- export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
+ // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
- export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
+ // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
+ export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
+ // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
+ export function CVec_RouteHopZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_RouteHopZ_free(_res);
+ // debug statements here
}
- // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
- export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
+ // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
+ export function CVec_CVec_RouteHopZZ_free(_res: number[][]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_CVec_RouteHopZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
- export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
+ export function CResult_RouteDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_RouteDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
- export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
+ // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
+ export function CResult_RouteDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
- export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
+ // struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+ export function COption_u64Z_some(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.COption_u64Z_some(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
+ // struct LDKCOption_u64Z COption_u64Z_none(void);
+ export function COption_u64Z_none(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.COption_u64Z_none();
return nativeResponseValue;
}
- // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
- export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
+ // void COption_u64Z_free(struct LDKCOption_u64Z _res);
+ export function COption_u64Z_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.COption_u64Z_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
- export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
+ // struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+ export function COption_u64Z_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.COption_u64Z_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number {
+ // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
+ export function CVec_ChannelDetailsZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_ChannelDetailsZ_free(_res);
+ // debug statements here
}
- // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res);
- export function CResult_ChannelConfigDecodeErrorZ_free(_res: number): void {
+ // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
+ export function CVec_RouteHintZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_RouteHintZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_clone(const struct LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelConfigDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
+ export function CResult_RouteLightningErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
- export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
+ export function CResult_RouteLightningErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_DirectionalChannelInfoDecodeErrorZ_err(e: number): number {
+ // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
+ export function CResult_RouteLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_free(_res);
+ // debug statements here
}
- // void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
- export function CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: number): void {
+ // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
+ export function CResult_RouteLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: number): number {
+ // void CVec_MessageSendEventZ_free(struct LDKCVec_MessageSendEventZ _res);
+ export function CVec_MessageSendEventZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_MessageSendEventZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
- export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o);
+ export function CResult_boolLightningErrorZ_ok(o: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e);
+ export function CResult_boolLightningErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
- export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
+ // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res);
+ export function CResult_boolLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_clone(const struct LDKCResult_boolLightningErrorZ *NONNULL_PTR orig);
+ export function CResult_boolLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
- export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
+ // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(const struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR orig);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
+ // struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(struct LDKChannelAnnouncement a, struct LDKChannelUpdate b, struct LDKChannelUpdate c);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a: number, b: number, c: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c);
return nativeResponseValue;
}
- // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
- export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
+ // void C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(struct LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res);
+ export function C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res);
// debug statements here
}
- // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
+ // void CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(struct LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res);
+ export function CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res);
+ // debug statements here
}
- // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
- export function CVec_NetAddressZ_free(_res: number[]): void {
+ // void CVec_NodeAnnouncementZ_free(struct LDKCVec_NodeAnnouncementZ _res);
+ export function CVec_NodeAnnouncementZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_NetAddressZ_free(_res);
+ const nativeResponseValue = wasm.CVec_NodeAnnouncementZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
- export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void);
+ export function CResult_NoneLightningErrorZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e);
+ export function CResult_NoneLightningErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
- export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
+ // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res);
+ export function CResult_NoneLightningErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_clone(const struct LDKCResult_NoneLightningErrorZ *NONNULL_PTR orig);
+ export function CResult_NoneLightningErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
- export function CVec_u64Z_free(_res: number[]): void {
+ // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res);
+ export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_u64Z_free(_res);
+ const nativeResponseValue = wasm.CVec_PublicKeyZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
- export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
+ // void CVec_u8Z_free(struct LDKCVec_u8Z _res);
+ export function CVec_u8Z_free(_res: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CVec_u8Z_free(encodeArray(_res));
+ // debug statements here
+ }
+ // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_ok(struct LDKCVec_u8Z o);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_ok(o: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_ok(encodeArray(o));
return nativeResponseValue;
}
- // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_err(struct LDKPeerHandleError e);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
- export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
+ // void CResult_CVec_u8ZPeerHandleErrorZ_free(struct LDKCResult_CVec_u8ZPeerHandleErrorZ _res);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_CVec_u8ZPeerHandleErrorZ CResult_CVec_u8ZPeerHandleErrorZ_clone(const struct LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR orig);
+ export function CResult_CVec_u8ZPeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_CVec_u8ZPeerHandleErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
- export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_ok(void);
+ export function CResult_NonePeerHandleErrorZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_err(struct LDKPeerHandleError e);
+ export function CResult_NonePeerHandleErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
- export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
+ // void CResult_NonePeerHandleErrorZ_free(struct LDKCResult_NonePeerHandleErrorZ _res);
+ export function CResult_NonePeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NonePeerHandleErrorZ CResult_NonePeerHandleErrorZ_clone(const struct LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR orig);
+ export function CResult_NonePeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NonePeerHandleErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKC2Tuple_usizeTransactionZ C2Tuple_usizeTransactionZ_new(uintptr_t a, struct LDKTransaction b);
- export function C2Tuple_usizeTransactionZ_new(a: number, b: Uint8Array): number {
+ // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_ok(bool o);
+ export function CResult_boolPeerHandleErrorZ_ok(o: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_new(a, encodeArray(b));
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_ok(o);
return nativeResponseValue;
}
- // void C2Tuple_usizeTransactionZ_free(struct LDKC2Tuple_usizeTransactionZ _res);
- export function C2Tuple_usizeTransactionZ_free(_res: number): void {
+ // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_err(struct LDKPeerHandleError e);
+ export function CResult_boolPeerHandleErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_usizeTransactionZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_C2Tuple_usizeTransactionZZ_free(struct LDKCVec_C2Tuple_usizeTransactionZZ _res);
- export function CVec_C2Tuple_usizeTransactionZZ_free(_res: number[]): void {
+ // void CResult_boolPeerHandleErrorZ_free(struct LDKCResult_boolPeerHandleErrorZ _res);
+ export function CResult_boolPeerHandleErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_C2Tuple_usizeTransactionZZ_free(_res);
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_ok(void);
- export function CResult_NoneChannelMonitorUpdateErrZ_ok(): number {
+ // struct LDKCResult_boolPeerHandleErrorZ CResult_boolPeerHandleErrorZ_clone(const struct LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR orig);
+ export function CResult_boolPeerHandleErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_ok();
+ const nativeResponseValue = wasm.CResult_boolPeerHandleErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_err(enum LDKChannelMonitorUpdateErr e);
- export function CResult_NoneChannelMonitorUpdateErrZ_err(e: LDKChannelMonitorUpdateErr): number {
+ // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
+ export function CResult_TxOutAccessErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_err(e);
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_ok(o);
return nativeResponseValue;
}
- // void CResult_NoneChannelMonitorUpdateErrZ_free(struct LDKCResult_NoneChannelMonitorUpdateErrZ _res);
- export function CResult_NoneChannelMonitorUpdateErrZ_free(_res: number): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_NoneChannelMonitorUpdateErrZ CResult_NoneChannelMonitorUpdateErrZ_clone(const struct LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR orig);
- export function CResult_NoneChannelMonitorUpdateErrZ_clone(orig: number): number {
+ // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
+ export function CResult_TxOutAccessErrorZ_err(e: LDKAccessError): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneChannelMonitorUpdateErrZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_err(e);
return nativeResponseValue;
}
- // void CVec_MonitorEventZ_free(struct LDKCVec_MonitorEventZ _res);
- export function CVec_MonitorEventZ_free(_res: number[]): void {
+ // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
+ export function CResult_TxOutAccessErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_MonitorEventZ_free(_res);
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_free(_res);
// debug statements here
}
- // void CVec_EventZ_free(struct LDKCVec_EventZ _res);
- export function CVec_EventZ_free(_res: number[]): void {
+ // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
+ export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_EventZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_ok(struct LDKOutPoint o);
- export function CResult_OutPointDecodeErrorZ_ok(o: number): number {
+ // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
+ export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_some(o);
return nativeResponseValue;
}
- // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_OutPointDecodeErrorZ_err(e: number): number {
+ // struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
+ export function COption_C2Tuple_usizeTransactionZZ_none(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_none();
return nativeResponseValue;
}
- // void CResult_OutPointDecodeErrorZ_free(struct LDKCResult_OutPointDecodeErrorZ _res);
- export function CResult_OutPointDecodeErrorZ_free(_res: number): void {
+ // void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
+ export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_OutPointDecodeErrorZ CResult_OutPointDecodeErrorZ_clone(const struct LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_OutPointDecodeErrorZ_clone(orig: number): number {
+ // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
+ export function CVec_SpendableOutputDescriptorZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OutPointDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_SpendableOutputDescriptorZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_ok(struct LDKChannelMonitorUpdate o);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ChannelMonitorUpdateDecodeErrorZ_free(struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res: number): void {
+ // void CResult_DirectionalChannelInfoDecodeErrorZ_free(struct LDKCResult_DirectionalChannelInfoDecodeErrorZ _res);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ CResult_ChannelMonitorUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_clone(const struct LDKCResult_DirectionalChannelInfoDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_ok(struct LDKHTLCUpdate o);
- export function CResult_HTLCUpdateDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_ok(struct LDKChannelInfo o);
+ export function CResult_ChannelInfoDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_HTLCUpdateDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelInfoDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_HTLCUpdateDecodeErrorZ_free(struct LDKCResult_HTLCUpdateDecodeErrorZ _res);
- export function CResult_HTLCUpdateDecodeErrorZ_free(_res: number): void {
+ // void CResult_ChannelInfoDecodeErrorZ_free(struct LDKCResult_ChannelInfoDecodeErrorZ _res);
+ export function CResult_ChannelInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_HTLCUpdateDecodeErrorZ CResult_HTLCUpdateDecodeErrorZ_clone(const struct LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_HTLCUpdateDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ChannelInfoDecodeErrorZ CResult_ChannelInfoDecodeErrorZ_clone(const struct LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_HTLCUpdateDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_ok(void);
- export function CResult_NoneMonitorUpdateErrorZ_ok(): number {
+ // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o);
+ export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_ok();
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_err(struct LDKMonitorUpdateError e);
- export function CResult_NoneMonitorUpdateErrorZ_err(e: number): number {
+ // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_RoutingFeesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NoneMonitorUpdateErrorZ_free(struct LDKCResult_NoneMonitorUpdateErrorZ _res);
- export function CResult_NoneMonitorUpdateErrorZ_free(_res: number): void {
+ // void CResult_RoutingFeesDecodeErrorZ_free(struct LDKCResult_RoutingFeesDecodeErrorZ _res);
+ export function CResult_RoutingFeesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneMonitorUpdateErrorZ CResult_NoneMonitorUpdateErrorZ_clone(const struct LDKCResult_NoneMonitorUpdateErrorZ *NONNULL_PTR orig);
- export function CResult_NoneMonitorUpdateErrorZ_clone(orig: number): number {
+ // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_clone(const struct LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_RoutingFeesDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneMonitorUpdateErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_RoutingFeesDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_clone(const struct LDKC2Tuple_OutPointScriptZ *NONNULL_PTR orig);
- export function C2Tuple_OutPointScriptZ_clone(orig: number): number {
+ // void CVec_NetAddressZ_free(struct LDKCVec_NetAddressZ _res);
+ export function CVec_NetAddressZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_NetAddressZ_free(_res);
+ // debug statements here
}
- // struct LDKC2Tuple_OutPointScriptZ C2Tuple_OutPointScriptZ_new(struct LDKOutPoint a, struct LDKCVec_u8Z b);
- export function C2Tuple_OutPointScriptZ_new(a: number, b: Uint8Array): number {
+ // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_ok(struct LDKNodeAnnouncementInfo o);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_new(a, encodeArray(b));
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // void C2Tuple_OutPointScriptZ_free(struct LDKC2Tuple_OutPointScriptZ _res);
- export function C2Tuple_OutPointScriptZ_free(_res: number): void {
+ // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res);
- export function CVec_TransactionZ_free(_res: Uint8Array[]): void {
+ // void CResult_NodeAnnouncementInfoDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_TransactionZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_clone(const struct LDKC2Tuple_u32TxOutZ *NONNULL_PTR orig);
- export function C2Tuple_u32TxOutZ_clone(orig: number): number {
+ // struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ CResult_NodeAnnouncementInfoDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKC2Tuple_u32TxOutZ C2Tuple_u32TxOutZ_new(uint32_t a, struct LDKTxOut b);
- export function C2Tuple_u32TxOutZ_new(a: number, b: number): number {
+ // void CVec_u64Z_free(struct LDKCVec_u64Z _res);
+ export function CVec_u64Z_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_new(a, b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_u64Z_free(_res);
+ // debug statements here
}
- // void C2Tuple_u32TxOutZ_free(struct LDKC2Tuple_u32TxOutZ _res);
- export function C2Tuple_u32TxOutZ_free(_res: number): void {
+ // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_ok(struct LDKNodeInfo o);
+ export function CResult_NodeInfoDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_u32TxOutZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // void CVec_C2Tuple_u32TxOutZZ_free(struct LDKCVec_C2Tuple_u32TxOutZZ _res);
- export function CVec_C2Tuple_u32TxOutZZ_free(_res: number[]): void {
+ // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_NodeInfoDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_C2Tuple_u32TxOutZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(struct LDKThirtyTwoBytes a, struct LDKCVec_C2Tuple_u32TxOutZZ b);
- export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a: Uint8Array, b: number[]): number {
+ // void CResult_NodeInfoDecodeErrorZ_free(struct LDKCResult_NodeInfoDecodeErrorZ _res);
+ export function CResult_NodeInfoDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(encodeArray(a), b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_free(_res);
+ // debug statements here
}
- // void C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(struct LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res);
- export function C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res: number): void {
+ // struct LDKCResult_NodeInfoDecodeErrorZ CResult_NodeInfoDecodeErrorZ_clone(const struct LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_NodeInfoDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_NodeInfoDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // void CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res);
- export function CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res: number[]): void {
+ // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_ok(struct LDKNetworkGraph o);
+ export function CResult_NetworkGraphDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKC2Tuple_BlockHashChannelMonitorZ C2Tuple_BlockHashChannelMonitorZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelMonitor b);
- export function C2Tuple_BlockHashChannelMonitorZ_new(a: Uint8Array, b: number): number {
+ // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_NetworkGraphDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_new(encodeArray(a), b);
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void C2Tuple_BlockHashChannelMonitorZ_free(struct LDKC2Tuple_BlockHashChannelMonitorZ _res);
- export function C2Tuple_BlockHashChannelMonitorZ_free(_res: number): void {
+ // void CResult_NetworkGraphDecodeErrorZ_free(struct LDKCResult_NetworkGraphDecodeErrorZ _res);
+ export function CResult_NetworkGraphDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelMonitorZ o);
- export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_clone(const struct LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_NetworkGraphDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_ok(struct LDKInitFeatures o);
+ export function CResult_InitFeaturesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // void CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res);
- export function CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res: number): void {
+ // struct LDKCResult_InitFeaturesDecodeErrorZ CResult_InitFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_InitFeaturesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_SpendableOutputDescriptorZ_free(struct LDKCVec_SpendableOutputDescriptorZ _res);
- export function CVec_SpendableOutputDescriptorZ_free(_res: number[]): void {
+ // void CResult_InitFeaturesDecodeErrorZ_free(struct LDKCResult_InitFeaturesDecodeErrorZ _res);
+ export function CResult_InitFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_SpendableOutputDescriptorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_InitFeaturesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_ok(struct LDKTxOut o);
- export function CResult_TxOutAccessErrorZ_ok(o: number): number {
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_ok(struct LDKNodeFeatures o);
+ export function CResult_NodeFeaturesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_err(enum LDKAccessError e);
- export function CResult_TxOutAccessErrorZ_err(e: LDKAccessError): number {
+ // struct LDKCResult_NodeFeaturesDecodeErrorZ CResult_NodeFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_NodeFeaturesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_TxOutAccessErrorZ_free(struct LDKCResult_TxOutAccessErrorZ _res);
- export function CResult_TxOutAccessErrorZ_free(_res: number): void {
+ // void CResult_NodeFeaturesDecodeErrorZ_free(struct LDKCResult_NodeFeaturesDecodeErrorZ _res);
+ export function CResult_NodeFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NodeFeaturesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_TxOutAccessErrorZ CResult_TxOutAccessErrorZ_clone(const struct LDKCResult_TxOutAccessErrorZ *NONNULL_PTR orig);
- export function CResult_TxOutAccessErrorZ_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone(orig);
- return nativeResponseValue;
- }
- // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
- export function CResult_NoneAPIErrorZ_ok(): number {
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_ok(struct LDKChannelFeatures o);
+ export function CResult_ChannelFeaturesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_ok();
+ const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
- export function CResult_NoneAPIErrorZ_err(e: number): number {
+ // struct LDKCResult_ChannelFeaturesDecodeErrorZ CResult_ChannelFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelFeaturesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
- export function CResult_NoneAPIErrorZ_free(_res: number): void {
+ // void CResult_ChannelFeaturesDecodeErrorZ_free(struct LDKCResult_ChannelFeaturesDecodeErrorZ _res);
+ export function CResult_ChannelFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
- export function CResult_NoneAPIErrorZ_clone(orig: number): number {
+ // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
+ export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
- export function CVec_CResult_NoneAPIErrorZZ_free(_res: number[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_CResult_NoneAPIErrorZZ_free(_res);
- // debug statements here
- }
- // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
- export function CVec_APIErrorZ_free(_res: number[]): void {
+ // struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_APIErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res);
- export function CVec_ChannelDetailsZ_free(_res: number[]): void {
+ // void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
+ export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_ChannelDetailsZ_free(_res);
+ const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
- export function CResult_NonePaymentSendFailureZ_ok(): number {
+ // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
+ export function CResult_NetAddressu8Z_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_ok();
+ const nativeResponseValue = wasm.CResult_NetAddressu8Z_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
- export function CResult_NonePaymentSendFailureZ_err(e: number): number {
+ // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
+ export function CResult_NetAddressu8Z_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_err(e);
+ const nativeResponseValue = wasm.CResult_NetAddressu8Z_err(e);
return nativeResponseValue;
}
- // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
- export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
+ // void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
+ export function CResult_NetAddressu8Z_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NetAddressu8Z_free(_res);
// debug statements here
}
- // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
- export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
+ // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
+ export function CResult_NetAddressu8Z_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NetAddressu8Z_clone(orig);
return nativeResponseValue;
}
- // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
- export function CVec_ChannelMonitorZ_free(_res: number[]): void {
+ // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
+ export function CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_ChannelMonitorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
- export function C2Tuple_BlockHashChannelManagerZ_new(a: Uint8Array, b: number): number {
+ // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_new(encodeArray(a), b);
+ const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
- export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
+ // void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
+ export function CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_free(_res);
+ const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
- return nativeResponseValue;
- }
- // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
- export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
+ // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
+ export function CVec_UpdateAddHTLCZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_UpdateAddHTLCZ_free(_res);
// debug statements here
}
- // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
- export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
+ // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
+ export function CVec_UpdateFulfillHTLCZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_UpdateFulfillHTLCZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
+ // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
+ export function CVec_UpdateFailHTLCZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_UpdateFailHTLCZ_free(_res);
+ // debug statements here
}
- // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
- export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
+ // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
+ export function CVec_UpdateFailMalformedHTLCZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_UpdateFailMalformedHTLCZ_free(_res);
// debug statements here
}
- // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
+ export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
- export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
+ // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
- export function C2Tuple_SignatureCVec_SignatureZZ_new(a: Uint8Array, b: Uint8Array[]): number {
+ // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
+ export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_new(encodeArray(a), b);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_free(_res);
+ // debug statements here
}
- // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
- export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
+ // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
- export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
+ // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
- export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
+ // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
- export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
+ // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
- export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
+ // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
- export function CResult_SignatureNoneZ_ok(o: Uint8Array): number {
+ // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
+ export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignatureNoneZ_ok(encodeArray(o));
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
- export function CResult_SignatureNoneZ_err(): number {
+ // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignatureNoneZ_err();
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
- export function CResult_SignatureNoneZ_free(_res: number): void {
+ // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
+ export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignatureNoneZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
- export function CResult_SignatureNoneZ_clone(orig: number): number {
+ // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignatureNoneZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
- export function CResult_SignDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
+ export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_SignDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
- export function CResult_SignDecodeErrorZ_free(_res: number): void {
+ // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
+ export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_SignDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
- export function CVec_CVec_u8ZZ_free(_res: Uint8Array[]): void {
+ // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
+ export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_CVec_u8ZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
- export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: Uint8Array[]): number {
+ // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_ok(o);
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
- export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
+ // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
+ export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_err();
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
- export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
+ // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
+ export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
- export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
+ // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
- export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
+ // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
+ export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
- export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
+ // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
+ export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
- export function CVec_TxOutZ_free(_res: number[]): void {
+ // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
+ export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_TxOutZ_free(_res);
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
- export function CResult_TransactionNoneZ_ok(o: Uint8Array): number {
+ // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TransactionNoneZ_ok(encodeArray(o));
+ const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
- export function CResult_TransactionNoneZ_err(): number {
+ // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
+ export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TransactionNoneZ_err();
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
- export function CResult_TransactionNoneZ_free(_res: number): void {
+ // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_TransactionNoneZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res);
- export function CVec_RouteHopZ_free(_res: number[]): void {
+ // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
+ export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_RouteHopZ_free(_res);
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_free(_res);
// debug statements here
}
- // void CVec_CVec_RouteHopZZ_free(struct LDKCVec_CVec_RouteHopZZ _res);
- export function CVec_CVec_RouteHopZZ_free(_res: number[][]): void {
+ // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_CVec_RouteHopZZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_ok(struct LDKRoute o);
- export function CResult_RouteDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
+ export function CResult_InitDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_RouteDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_InitDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_RouteDecodeErrorZ_free(struct LDKCResult_RouteDecodeErrorZ _res);
- export function CResult_RouteDecodeErrorZ_free(_res: number): void {
+ // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
+ export function CResult_InitDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_RouteDecodeErrorZ CResult_RouteDecodeErrorZ_clone(const struct LDKCResult_RouteDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_RouteDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_InitDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CVec_RouteHintZ_free(struct LDKCVec_RouteHintZ _res);
- export function CVec_RouteHintZ_free(_res: number[]): void {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CVec_RouteHintZ_free(_res);
- // debug statements here
- }
- // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_ok(struct LDKRoute o);
- export function CResult_RouteLightningErrorZ_ok(o: number): number {
+ // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
+ export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_err(struct LDKLightningError e);
- export function CResult_RouteLightningErrorZ_err(e: number): number {
+ // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_RouteLightningErrorZ_free(struct LDKCResult_RouteLightningErrorZ _res);
- export function CResult_RouteLightningErrorZ_free(_res: number): void {
+ // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
+ export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_RouteLightningErrorZ CResult_RouteLightningErrorZ_clone(const struct LDKCResult_RouteLightningErrorZ *NONNULL_PTR orig);
- export function CResult_RouteLightningErrorZ_clone(orig: number): number {
+ // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RouteLightningErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_ok(struct LDKNetAddress o);
- export function CResult_NetAddressu8Z_ok(o: number): number {
+ // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
+ export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetAddressu8Z_ok(o);
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_err(uint8_t e);
- export function CResult_NetAddressu8Z_err(e: number): number {
+ // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetAddressu8Z_err(e);
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_NetAddressu8Z_free(struct LDKCResult_NetAddressu8Z _res);
- export function CResult_NetAddressu8Z_free(_res: number): void {
+ // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
+ export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetAddressu8Z_free(_res);
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_NetAddressu8Z CResult_NetAddressu8Z_clone(const struct LDKCResult_NetAddressu8Z *NONNULL_PTR orig);
- export function CResult_NetAddressu8Z_clone(orig: number): number {
+ // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NetAddressu8Z_clone(orig);
+ const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(struct LDKCResult_NetAddressu8Z o);
- export function CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
+ export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_CResult_NetAddressu8ZDecodeErrorZ_free(struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res);
- export function CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res: number): void {
+ // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
+ export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(const struct LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CVec_UpdateAddHTLCZ_free(struct LDKCVec_UpdateAddHTLCZ _res);
- export function CVec_UpdateAddHTLCZ_free(_res: number[]): void {
+ // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_UpdateAddHTLCZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
+ return nativeResponseValue;
}
- // void CVec_UpdateFulfillHTLCZ_free(struct LDKCVec_UpdateFulfillHTLCZ _res);
- export function CVec_UpdateFulfillHTLCZ_free(_res: number[]): void {
+ // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_UpdateFulfillHTLCZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_err(e);
+ return nativeResponseValue;
}
- // void CVec_UpdateFailHTLCZ_free(struct LDKCVec_UpdateFailHTLCZ _res);
- export function CVec_UpdateFailHTLCZ_free(_res: number[]): void {
+ // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_UpdateFailHTLCZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
// debug statements here
}
- // void CVec_UpdateFailMalformedHTLCZ_free(struct LDKCVec_UpdateFailMalformedHTLCZ _res);
- export function CVec_UpdateFailMalformedHTLCZ_free(_res: number[]): void {
+ // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CVec_UpdateFailMalformedHTLCZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
}
- // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_ok(struct LDKAcceptChannel o);
- export function CResult_AcceptChannelDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_AcceptChannelDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_AcceptChannelDecodeErrorZ_free(struct LDKCResult_AcceptChannelDecodeErrorZ _res);
- export function CResult_AcceptChannelDecodeErrorZ_free(_res: number): void {
+ // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_AcceptChannelDecodeErrorZ CResult_AcceptChannelDecodeErrorZ_clone(const struct LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_AcceptChannelDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AcceptChannelDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_ok(struct LDKAnnouncementSignatures o);
- export function CResult_AnnouncementSignaturesDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
+ export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_AnnouncementSignaturesDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_AnnouncementSignaturesDecodeErrorZ_free(struct LDKCResult_AnnouncementSignaturesDecodeErrorZ _res);
- export function CResult_AnnouncementSignaturesDecodeErrorZ_free(_res: number): void {
+ // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
+ export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_AnnouncementSignaturesDecodeErrorZ CResult_AnnouncementSignaturesDecodeErrorZ_clone(const struct LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_ok(struct LDKChannelReestablish o);
- export function CResult_ChannelReestablishDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelReestablishDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ChannelReestablishDecodeErrorZ_free(struct LDKCResult_ChannelReestablishDecodeErrorZ _res);
- export function CResult_ChannelReestablishDecodeErrorZ_free(_res: number): void {
+ // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelReestablishDecodeErrorZ CResult_ChannelReestablishDecodeErrorZ_clone(const struct LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelReestablishDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelReestablishDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_ok(struct LDKClosingSigned o);
- export function CResult_ClosingSignedDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ClosingSignedDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ClosingSignedDecodeErrorZ_free(struct LDKCResult_ClosingSignedDecodeErrorZ _res);
- export function CResult_ClosingSignedDecodeErrorZ_free(_res: number): void {
+ // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ClosingSignedDecodeErrorZ CResult_ClosingSignedDecodeErrorZ_clone(const struct LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ClosingSignedDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ClosingSignedDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_ok(struct LDKCommitmentSigned o);
- export function CResult_CommitmentSignedDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
+ export function CResult_PingDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_CommitmentSignedDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_PingDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_CommitmentSignedDecodeErrorZ_free(struct LDKCResult_CommitmentSignedDecodeErrorZ _res);
- export function CResult_CommitmentSignedDecodeErrorZ_free(_res: number): void {
+ // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
+ export function CResult_PingDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_CommitmentSignedDecodeErrorZ CResult_CommitmentSignedDecodeErrorZ_clone(const struct LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_CommitmentSignedDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_PingDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_CommitmentSignedDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_ok(struct LDKFundingCreated o);
- export function CResult_FundingCreatedDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
+ export function CResult_PongDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_FundingCreatedDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_PongDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_FundingCreatedDecodeErrorZ_free(struct LDKCResult_FundingCreatedDecodeErrorZ _res);
- export function CResult_FundingCreatedDecodeErrorZ_free(_res: number): void {
+ // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
+ export function CResult_PongDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_FundingCreatedDecodeErrorZ CResult_FundingCreatedDecodeErrorZ_clone(const struct LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_FundingCreatedDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_PongDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingCreatedDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_ok(struct LDKFundingSigned o);
- export function CResult_FundingSignedDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_FundingSignedDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_FundingSignedDecodeErrorZ_free(struct LDKCResult_FundingSignedDecodeErrorZ _res);
- export function CResult_FundingSignedDecodeErrorZ_free(_res: number): void {
+ // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_FundingSignedDecodeErrorZ CResult_FundingSignedDecodeErrorZ_clone(const struct LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_FundingSignedDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingSignedDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_ok(struct LDKFundingLocked o);
- export function CResult_FundingLockedDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_FundingLockedDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_FundingLockedDecodeErrorZ_free(struct LDKCResult_FundingLockedDecodeErrorZ _res);
- export function CResult_FundingLockedDecodeErrorZ_free(_res: number): void {
+ // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_FundingLockedDecodeErrorZ CResult_FundingLockedDecodeErrorZ_clone(const struct LDKCResult_FundingLockedDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_FundingLockedDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_FundingLockedDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_ok(struct LDKInit o);
- export function CResult_InitDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_InitDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_InitDecodeErrorZ_free(struct LDKCResult_InitDecodeErrorZ _res);
- export function CResult_InitDecodeErrorZ_free(_res: number): void {
+ // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_InitDecodeErrorZ CResult_InitDecodeErrorZ_clone(const struct LDKCResult_InitDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_InitDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_InitDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_ok(struct LDKOpenChannel o);
- export function CResult_OpenChannelDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
+ export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_OpenChannelDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_OpenChannelDecodeErrorZ_free(struct LDKCResult_OpenChannelDecodeErrorZ _res);
- export function CResult_OpenChannelDecodeErrorZ_free(_res: number): void {
+ // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
+ export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_OpenChannelDecodeErrorZ CResult_OpenChannelDecodeErrorZ_clone(const struct LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_OpenChannelDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_OpenChannelDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_ok(struct LDKRevokeAndACK o);
- export function CResult_RevokeAndACKDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
+ export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_RevokeAndACKDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_RevokeAndACKDecodeErrorZ_free(struct LDKCResult_RevokeAndACKDecodeErrorZ _res);
- export function CResult_RevokeAndACKDecodeErrorZ_free(_res: number): void {
+ // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
+ export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_RevokeAndACKDecodeErrorZ CResult_RevokeAndACKDecodeErrorZ_clone(const struct LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_RevokeAndACKDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_RevokeAndACKDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_ok(struct LDKShutdown o);
- export function CResult_ShutdownDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ShutdownDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ShutdownDecodeErrorZ_free(struct LDKCResult_ShutdownDecodeErrorZ _res);
- export function CResult_ShutdownDecodeErrorZ_free(_res: number): void {
+ // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ShutdownDecodeErrorZ CResult_ShutdownDecodeErrorZ_clone(const struct LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ShutdownDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ShutdownDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_ok(struct LDKUpdateFailHTLC o);
- export function CResult_UpdateFailHTLCDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
+ export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UpdateFailHTLCDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UpdateFailHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailHTLCDecodeErrorZ _res);
- export function CResult_UpdateFailHTLCDecodeErrorZ_free(_res: number): void {
+ // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
+ export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UpdateFailHTLCDecodeErrorZ CResult_UpdateFailHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UpdateFailHTLCDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailHTLCDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(struct LDKUpdateFailMalformedHTLC o);
- export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res);
- export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res: number): void {
+ // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_ok(struct LDKUpdateFee o);
- export function CResult_UpdateFeeDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UpdateFeeDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UpdateFeeDecodeErrorZ_free(struct LDKCResult_UpdateFeeDecodeErrorZ _res);
- export function CResult_UpdateFeeDecodeErrorZ_free(_res: number): void {
+ // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UpdateFeeDecodeErrorZ CResult_UpdateFeeDecodeErrorZ_clone(const struct LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UpdateFeeDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFeeDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_ok(struct LDKUpdateFulfillHTLC o);
- export function CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
+ export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UpdateFulfillHTLCDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UpdateFulfillHTLCDecodeErrorZ_free(struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res);
- export function CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res: number): void {
+ // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
+ export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ CResult_UpdateFulfillHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_ok(struct LDKUpdateAddHTLC o);
- export function CResult_UpdateAddHTLCDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UpdateAddHTLCDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UpdateAddHTLCDecodeErrorZ_free(struct LDKCResult_UpdateAddHTLCDecodeErrorZ _res);
- export function CResult_UpdateAddHTLCDecodeErrorZ_free(_res: number): void {
+ // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UpdateAddHTLCDecodeErrorZ CResult_UpdateAddHTLCDecodeErrorZ_clone(const struct LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UpdateAddHTLCDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UpdateAddHTLCDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_ok(struct LDKPing o);
- export function CResult_PingDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_PingDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_PingDecodeErrorZ_free(struct LDKCResult_PingDecodeErrorZ _res);
- export function CResult_PingDecodeErrorZ_free(_res: number): void {
+ // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_PingDecodeErrorZ CResult_PingDecodeErrorZ_clone(const struct LDKCResult_PingDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_PingDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PingDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_ok(struct LDKPong o);
- export function CResult_PongDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_PongDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_PongDecodeErrorZ_free(struct LDKCResult_PongDecodeErrorZ _res);
- export function CResult_PongDecodeErrorZ_free(_res: number): void {
+ // void CResult_SpendableOutputDescriptorDecodeErrorZ_free(struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_PongDecodeErrorZ CResult_PongDecodeErrorZ_clone(const struct LDKCResult_PongDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_PongDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_clone(const struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_PongDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(struct LDKUnsignedChannelAnnouncement o);
- export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o: number): number {
+ // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_clone(const struct LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR orig);
+ export function C2Tuple_SignatureCVec_SignatureZZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e: number): number {
+ // struct LDKC2Tuple_SignatureCVec_SignatureZZ C2Tuple_SignatureCVec_SignatureZZ_new(struct LDKSignature a, struct LDKCVec_SignatureZ b);
+ export function C2Tuple_SignatureCVec_SignatureZZ_new(a: Uint8Array, b: Uint8Array[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_new(encodeArray(a), b);
return nativeResponseValue;
}
- // void CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res);
- export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res: number): void {
+ // void C2Tuple_SignatureCVec_SignatureZZ_free(struct LDKC2Tuple_SignatureCVec_SignatureZZ _res);
+ export function C2Tuple_SignatureCVec_SignatureZZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_SignatureCVec_SignatureZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
- if(!isWasmInitialized) {
- throw new Error("initializeWasm() must be awaited first!");
- }
- const nativeResponseValue = wasm.CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig);
- return nativeResponseValue;
- }
- // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_ok(struct LDKChannelAnnouncement o);
- export function CResult_ChannelAnnouncementDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(struct LDKC2Tuple_SignatureCVec_SignatureZZ o);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelAnnouncementDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(void);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
return nativeResponseValue;
}
- // void CResult_ChannelAnnouncementDecodeErrorZ_free(struct LDKCResult_ChannelAnnouncementDecodeErrorZ _res);
- export function CResult_ChannelAnnouncementDecodeErrorZ_free(_res: number): void {
+ // void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelAnnouncementDecodeErrorZ CResult_ChannelAnnouncementDecodeErrorZ_clone(const struct LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelAnnouncementDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(const struct LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR orig);
+ export function CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelAnnouncementDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_ok(struct LDKUnsignedChannelUpdate o);
- export function CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_ok(struct LDKSignature o);
+ export function CResult_SignatureNoneZ_ok(o: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_ok(encodeArray(o));
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UnsignedChannelUpdateDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_err(void);
+ export function CResult_SignatureNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_err();
return nativeResponseValue;
}
- // void CResult_UnsignedChannelUpdateDecodeErrorZ_free(struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res);
- export function CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res: number): void {
+ // void CResult_SignatureNoneZ_free(struct LDKCResult_SignatureNoneZ _res);
+ export function CResult_SignatureNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ CResult_UnsignedChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_SignatureNoneZ CResult_SignatureNoneZ_clone(const struct LDKCResult_SignatureNoneZ *NONNULL_PTR orig);
+ export function CResult_SignatureNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_SignatureNoneZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_ok(struct LDKChannelUpdate o);
- export function CResult_ChannelUpdateDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_ok(struct LDKSign o);
+ export function CResult_SignDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ChannelUpdateDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_SignDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ChannelUpdateDecodeErrorZ_free(struct LDKCResult_ChannelUpdateDecodeErrorZ _res);
- export function CResult_ChannelUpdateDecodeErrorZ_free(_res: number): void {
+ // void CResult_SignDecodeErrorZ_free(struct LDKCResult_SignDecodeErrorZ _res);
+ export function CResult_SignDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ChannelUpdateDecodeErrorZ CResult_ChannelUpdateDecodeErrorZ_clone(const struct LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ChannelUpdateDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_SignDecodeErrorZ CResult_SignDecodeErrorZ_clone(const struct LDKCResult_SignDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_SignDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ChannelUpdateDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_ok(struct LDKErrorMessage o);
- export function CResult_ErrorMessageDecodeErrorZ_ok(o: number): number {
+ // void CVec_CVec_u8ZZ_free(struct LDKCVec_CVec_u8ZZ _res);
+ export function CVec_CVec_u8ZZ_free(_res: Uint8Array[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CVec_CVec_u8ZZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_ok(struct LDKCVec_CVec_u8ZZ o);
+ export function CResult_CVec_CVec_u8ZZNoneZ_ok(o: Uint8Array[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ErrorMessageDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_err(void);
+ export function CResult_CVec_CVec_u8ZZNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_err();
return nativeResponseValue;
}
- // void CResult_ErrorMessageDecodeErrorZ_free(struct LDKCResult_ErrorMessageDecodeErrorZ _res);
- export function CResult_ErrorMessageDecodeErrorZ_free(_res: number): void {
+ // void CResult_CVec_CVec_u8ZZNoneZ_free(struct LDKCResult_CVec_CVec_u8ZZNoneZ _res);
+ export function CResult_CVec_CVec_u8ZZNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ErrorMessageDecodeErrorZ CResult_ErrorMessageDecodeErrorZ_clone(const struct LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ErrorMessageDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_CVec_CVec_u8ZZNoneZ CResult_CVec_CVec_u8ZZNoneZ_clone(const struct LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR orig);
+ export function CResult_CVec_CVec_u8ZZNoneZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ErrorMessageDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(struct LDKUnsignedNodeAnnouncement o);
- export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_ok(struct LDKInMemorySigner o);
+ export function CResult_InMemorySignerDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_InMemorySignerDecodeErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res);
- export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res: number): void {
+ // void CResult_InMemorySignerDecodeErrorZ_free(struct LDKCResult_InMemorySignerDecodeErrorZ _res);
+ export function CResult_InMemorySignerDecodeErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_InMemorySignerDecodeErrorZ CResult_InMemorySignerDecodeErrorZ_clone(const struct LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR orig);
+ export function CResult_InMemorySignerDecodeErrorZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_ok(struct LDKNodeAnnouncement o);
- export function CResult_NodeAnnouncementDecodeErrorZ_ok(o: number): number {
+ // void CVec_TxOutZ_free(struct LDKCVec_TxOutZ _res);
+ export function CVec_TxOutZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_TxOutZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_NodeAnnouncementDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_ok(struct LDKTransaction o);
+ export function CResult_TransactionNoneZ_ok(o: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_ok(encodeArray(o));
return nativeResponseValue;
}
- // void CResult_NodeAnnouncementDecodeErrorZ_free(struct LDKCResult_NodeAnnouncementDecodeErrorZ _res);
- export function CResult_NodeAnnouncementDecodeErrorZ_free(_res: number): void {
+ // struct LDKCResult_TransactionNoneZ CResult_TransactionNoneZ_err(void);
+ export function CResult_TransactionNoneZ_err(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_free(_res);
- // debug statements here
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_err();
+ return nativeResponseValue;
}
- // struct LDKCResult_NodeAnnouncementDecodeErrorZ CResult_NodeAnnouncementDecodeErrorZ_clone(const struct LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_NodeAnnouncementDecodeErrorZ_clone(orig: number): number {
+ // void CResult_TransactionNoneZ_free(struct LDKCResult_TransactionNoneZ _res);
+ export function CResult_TransactionNoneZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_NodeAnnouncementDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CResult_TransactionNoneZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_ok(struct LDKQueryShortChannelIds o);
- export function CResult_QueryShortChannelIdsDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_ok(void);
+ export function CResult_NoneErrorZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_QueryShortChannelIdsDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_NoneErrorZ CResult_NoneErrorZ_err(enum LDKIOError e);
+ export function CResult_NoneErrorZ_err(e: LDKIOError): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_QueryShortChannelIdsDecodeErrorZ_free(struct LDKCResult_QueryShortChannelIdsDecodeErrorZ _res);
- export function CResult_QueryShortChannelIdsDecodeErrorZ_free(_res: number): void {
+ // void CResult_NoneErrorZ_free(struct LDKCResult_NoneErrorZ _res);
+ export function CResult_NoneErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NoneErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_QueryShortChannelIdsDecodeErrorZ CResult_QueryShortChannelIdsDecodeErrorZ_clone(const struct LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig: number): number {
+ // void CVec_C2Tuple_BlockHashChannelMonitorZZ_free(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res);
+ export function CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(struct LDKReplyShortChannelIdsEnd o);
- export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(struct LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o: number[]): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o);
return nativeResponseValue;
}
- // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(enum LDKIOError e);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e: LDKIOError): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e);
return nativeResponseValue;
}
- // void CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res);
- export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res: number): void {
+ // void CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res);
+ export function CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(const struct LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
+ export function CResult_NoneAPIErrorZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_ok(struct LDKQueryChannelRange o);
- export function CResult_QueryChannelRangeDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_err(struct LDKAPIError e);
+ export function CResult_NoneAPIErrorZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_err(e);
return nativeResponseValue;
}
- // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_QueryChannelRangeDecodeErrorZ_err(e: number): number {
+ // void CResult_NoneAPIErrorZ_free(struct LDKCResult_NoneAPIErrorZ _res);
+ export function CResult_NoneAPIErrorZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_free(_res);
+ // debug statements here
+ }
+ // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_clone(const struct LDKCResult_NoneAPIErrorZ *NONNULL_PTR orig);
+ export function CResult_NoneAPIErrorZ_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_clone(orig);
return nativeResponseValue;
}
- // void CResult_QueryChannelRangeDecodeErrorZ_free(struct LDKCResult_QueryChannelRangeDecodeErrorZ _res);
- export function CResult_QueryChannelRangeDecodeErrorZ_free(_res: number): void {
+ // void CVec_CResult_NoneAPIErrorZZ_free(struct LDKCVec_CResult_NoneAPIErrorZZ _res);
+ export function CVec_CResult_NoneAPIErrorZZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CVec_CResult_NoneAPIErrorZZ_free(_res);
// debug statements here
}
- // struct LDKCResult_QueryChannelRangeDecodeErrorZ CResult_QueryChannelRangeDecodeErrorZ_clone(const struct LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_QueryChannelRangeDecodeErrorZ_clone(orig: number): number {
+ // void CVec_APIErrorZ_free(struct LDKCVec_APIErrorZ _res);
+ export function CVec_APIErrorZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_QueryChannelRangeDecodeErrorZ_clone(orig);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_APIErrorZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_ok(struct LDKReplyChannelRange o);
- export function CResult_ReplyChannelRangeDecodeErrorZ_ok(o: number): number {
+ // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_ok(void);
+ export function CResult_NonePaymentSendFailureZ_ok(): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_ok(o);
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_ok();
return nativeResponseValue;
}
- // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_ReplyChannelRangeDecodeErrorZ_err(e: number): number {
+ // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_err(struct LDKPaymentSendFailure e);
+ export function CResult_NonePaymentSendFailureZ_err(e: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_err(e);
return nativeResponseValue;
}
- // void CResult_ReplyChannelRangeDecodeErrorZ_free(struct LDKCResult_ReplyChannelRangeDecodeErrorZ _res);
- export function CResult_ReplyChannelRangeDecodeErrorZ_free(_res: number): void {
+ // void CResult_NonePaymentSendFailureZ_free(struct LDKCResult_NonePaymentSendFailureZ _res);
+ export function CResult_NonePaymentSendFailureZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_free(_res);
// debug statements here
}
- // struct LDKCResult_ReplyChannelRangeDecodeErrorZ CResult_ReplyChannelRangeDecodeErrorZ_clone(const struct LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_ReplyChannelRangeDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_NonePaymentSendFailureZ CResult_NonePaymentSendFailureZ_clone(const struct LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR orig);
+ export function CResult_NonePaymentSendFailureZ_clone(orig: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_ReplyChannelRangeDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_NonePaymentSendFailureZ_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_ok(struct LDKGossipTimestampFilter o);
- export function CResult_GossipTimestampFilterDecodeErrorZ_ok(o: number): number {
+ // void CVec_ChannelMonitorZ_free(struct LDKCVec_ChannelMonitorZ _res);
+ export function CVec_ChannelMonitorZ_free(_res: number[]): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_ok(o);
- return nativeResponseValue;
+ const nativeResponseValue = wasm.CVec_ChannelMonitorZ_free(_res);
+ // debug statements here
}
- // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_err(struct LDKDecodeError e);
- export function CResult_GossipTimestampFilterDecodeErrorZ_err(e: number): number {
+ // struct LDKC2Tuple_BlockHashChannelManagerZ C2Tuple_BlockHashChannelManagerZ_new(struct LDKThirtyTwoBytes a, struct LDKChannelManager b);
+ export function C2Tuple_BlockHashChannelManagerZ_new(a: Uint8Array, b: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_err(e);
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_new(encodeArray(a), b);
return nativeResponseValue;
}
- // void CResult_GossipTimestampFilterDecodeErrorZ_free(struct LDKCResult_GossipTimestampFilterDecodeErrorZ _res);
- export function CResult_GossipTimestampFilterDecodeErrorZ_free(_res: number): void {
+ // void C2Tuple_BlockHashChannelManagerZ_free(struct LDKC2Tuple_BlockHashChannelManagerZ _res);
+ export function C2Tuple_BlockHashChannelManagerZ_free(_res: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_free(_res);
+ const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_free(_res);
// debug statements here
}
- // struct LDKCResult_GossipTimestampFilterDecodeErrorZ CResult_GossipTimestampFilterDecodeErrorZ_clone(const struct LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR orig);
- export function CResult_GossipTimestampFilterDecodeErrorZ_clone(orig: number): number {
+ // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(struct LDKC2Tuple_BlockHashChannelManagerZ o);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CResult_GossipTimestampFilterDecodeErrorZ_clone(orig);
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+ }
+ // struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(struct LDKDecodeError e);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e);
return nativeResponseValue;
}
+ // void CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res);
+ export function CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res);
+ // debug statements here
+ }
// void Event_free(struct LDKEvent this_ptr);
export function Event_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.Logger_free(this_ptr);
// debug statements here
}
- // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_ptr);
- export function ChannelHandshakeConfig_free(this_ptr: number): void {
+ // void ChannelHandshakeConfig_free(struct LDKChannelHandshakeConfig this_obj);
+ export function ChannelHandshakeConfig_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeConfig_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelHandshakeConfig_free(this_obj);
// debug statements here
}
// uint32_t ChannelHandshakeConfig_get_minimum_depth(const struct LDKChannelHandshakeConfig *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelHandshakeConfig_default();
return nativeResponseValue;
}
- // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_ptr);
- export function ChannelHandshakeLimits_free(this_ptr: number): void {
+ // void ChannelHandshakeLimits_free(struct LDKChannelHandshakeLimits this_obj);
+ export function ChannelHandshakeLimits_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelHandshakeLimits_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelHandshakeLimits_free(this_obj);
// debug statements here
}
// uint64_t ChannelHandshakeLimits_get_min_funding_satoshis(const struct LDKChannelHandshakeLimits *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelHandshakeLimits_default();
return nativeResponseValue;
}
- // void ChannelConfig_free(struct LDKChannelConfig this_ptr);
- export function ChannelConfig_free(this_ptr: number): void {
+ // void ChannelConfig_free(struct LDKChannelConfig this_obj);
+ export function ChannelConfig_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelConfig_free(this_obj);
// debug statements here
}
// uint32_t ChannelConfig_get_fee_proportional_millionths(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelConfig_set_fee_proportional_millionths(this_ptr, val);
// debug statements here
}
+ // uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+ export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_get_cltv_expiry_delta(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
+ export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
+ // debug statements here
+ }
// bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
// debug statements here
}
- // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
- export function ChannelConfig_new(fee_proportional_millionths_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
+ // MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
+ export function ChannelConfig_new(fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+ const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
return nativeResponseValue;
}
// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
const nativeResponseValue = wasm.ChannelConfig_read(encodeArray(ser));
return nativeResponseValue;
}
- // void UserConfig_free(struct LDKUserConfig this_ptr);
- export function UserConfig_free(this_ptr: number): void {
+ // void UserConfig_free(struct LDKUserConfig this_obj);
+ export function UserConfig_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UserConfig_free(this_ptr);
+ const nativeResponseValue = wasm.UserConfig_free(this_obj);
// debug statements here
}
// struct LDKChannelHandshakeConfig UserConfig_get_own_channel_config(const struct LDKUserConfig *NONNULL_PTR this_ptr);
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Watch_free(this_ptr);
+ const nativeResponseValue = wasm.Watch_free(this_ptr);
+ // debug statements here
+ }
+ // void Filter_free(struct LDKFilter this_ptr);
+ export function Filter_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.Filter_free(this_ptr);
+ // debug statements here
+ }
+ // void WatchedOutput_free(struct LDKWatchedOutput this_obj);
+ export function WatchedOutput_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_free(this_obj);
+ // debug statements here
+ }
+ // struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+ export function WatchedOutput_get_block_hash(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_get_block_hash(this_ptr);
+ return decodeArray(nativeResponseValue);
+ }
+ // void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+ export function WatchedOutput_set_block_hash(this_ptr: number, val: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_set_block_hash(this_ptr, encodeArray(val));
+ // debug statements here
+ }
+ // struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+ export function WatchedOutput_get_outpoint(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_get_outpoint(this_ptr);
+ return nativeResponseValue;
+ }
+ // void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+ export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_set_outpoint(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+ export function WatchedOutput_get_script_pubkey(this_ptr: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_get_script_pubkey(this_ptr);
+ return decodeArray(nativeResponseValue);
+ }
+ // void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
+ export function WatchedOutput_set_script_pubkey(this_ptr: number, val: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.WatchedOutput_set_script_pubkey(this_ptr, encodeArray(val));
// debug statements here
}
- // void Filter_free(struct LDKFilter this_ptr);
- export function Filter_free(this_ptr: number): void {
+ // MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
+ export function WatchedOutput_new(block_hash_arg: Uint8Array, outpoint_arg: number, script_pubkey_arg: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Filter_free(this_ptr);
- // debug statements here
+ const nativeResponseValue = wasm.WatchedOutput_new(encodeArray(block_hash_arg), outpoint_arg, encodeArray(script_pubkey_arg));
+ return nativeResponseValue;
}
// void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
export function BroadcasterInterface_free(this_ptr: number): void {
const nativeResponseValue = wasm.FeeEstimator_free(this_ptr);
// debug statements here
}
- // void ChainMonitor_free(struct LDKChainMonitor this_ptr);
- export function ChainMonitor_free(this_ptr: number): void {
+ // void ChainMonitor_free(struct LDKChainMonitor this_obj);
+ export function ChainMonitor_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainMonitor_free(this_ptr);
+ const nativeResponseValue = wasm.ChainMonitor_free(this_obj);
// debug statements here
}
// void ChainMonitor_block_connected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
const nativeResponseValue = wasm.ChainMonitor_block_connected(this_arg, encodeArray(header), txdata, height);
// debug statements here
}
+ // void ChainMonitor_transactions_confirmed(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
+ export function ChainMonitor_transactions_confirmed(this_arg: number, header: Uint8Array, txdata: number[], height: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainMonitor_transactions_confirmed(this_arg, encodeArray(header), txdata, height);
+ // debug statements here
+ }
+ // void ChainMonitor_update_best_block(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height);
+ export function ChainMonitor_update_best_block(this_arg: number, header: Uint8Array, height: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainMonitor_update_best_block(this_arg, encodeArray(header), height);
+ // debug statements here
+ }
// void ChainMonitor_block_disconnected(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t disconnected_height);
export function ChainMonitor_block_disconnected(this_arg: number, header: Uint8Array, disconnected_height: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChainMonitor_block_disconnected(this_arg, encodeArray(header), disconnected_height);
// debug statements here
}
+ // void ChainMonitor_transaction_unconfirmed(const struct LDKChainMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32]);
+ export function ChainMonitor_transaction_unconfirmed(this_arg: number, txid: Uint8Array): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainMonitor_transaction_unconfirmed(this_arg, encodeArray(txid));
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKCVec_TxidZ ChainMonitor_get_relevant_txids(const struct LDKChainMonitor *NONNULL_PTR this_arg);
+ export function ChainMonitor_get_relevant_txids(this_arg: number): Uint8Array[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChainMonitor_get_relevant_txids(this_arg);
+ return nativeResponseValue;
+ }
// MUST_USE_RES struct LDKChainMonitor ChainMonitor_new(struct LDKFilter *chain_source, struct LDKBroadcasterInterface broadcaster, struct LDKLogger logger, struct LDKFeeEstimator feeest, struct LDKPersist persister);
export function ChainMonitor_new(chain_source: number, broadcaster: number, logger: number, feeest: number, persister: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChainMonitor_as_EventsProvider(this_arg);
return nativeResponseValue;
}
- // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_ptr);
- export function ChannelMonitorUpdate_free(this_ptr: number): void {
+ // void ChannelMonitorUpdate_free(struct LDKChannelMonitorUpdate this_obj);
+ export function ChannelMonitorUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitorUpdate_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelMonitorUpdate_free(this_obj);
// debug statements here
}
// uint64_t ChannelMonitorUpdate_get_update_id(const struct LDKChannelMonitorUpdate *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelMonitorUpdateErr_clone(orig);
return nativeResponseValue;
}
- // void MonitorUpdateError_free(struct LDKMonitorUpdateError this_ptr);
- export function MonitorUpdateError_free(this_ptr: number): void {
+ // void MonitorUpdateError_free(struct LDKMonitorUpdateError this_obj);
+ export function MonitorUpdateError_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MonitorUpdateError_free(this_ptr);
+ const nativeResponseValue = wasm.MonitorUpdateError_free(this_obj);
// debug statements here
}
// struct LDKMonitorUpdateError MonitorUpdateError_clone(const struct LDKMonitorUpdateError *NONNULL_PTR orig);
const nativeResponseValue = wasm.MonitorEvent_clone(orig);
return nativeResponseValue;
}
- // void HTLCUpdate_free(struct LDKHTLCUpdate this_ptr);
- export function HTLCUpdate_free(this_ptr: number): void {
+ // void HTLCUpdate_free(struct LDKHTLCUpdate this_obj);
+ export function HTLCUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HTLCUpdate_free(this_ptr);
+ const nativeResponseValue = wasm.HTLCUpdate_free(this_obj);
// debug statements here
}
// struct LDKHTLCUpdate HTLCUpdate_clone(const struct LDKHTLCUpdate *NONNULL_PTR orig);
const nativeResponseValue = wasm.HTLCUpdate_read(encodeArray(ser));
return nativeResponseValue;
}
- // void ChannelMonitor_free(struct LDKChannelMonitor this_ptr);
- export function ChannelMonitor_free(this_ptr: number): void {
+ // void ChannelMonitor_free(struct LDKChannelMonitor this_obj);
+ export function ChannelMonitor_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelMonitor_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelMonitor_free(this_obj);
// debug statements here
}
// struct LDKChannelMonitor ChannelMonitor_clone(const struct LDKChannelMonitor *NONNULL_PTR orig);
const nativeResponseValue = wasm.ChannelMonitor_get_funding_txo(this_arg);
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ChannelMonitor_get_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_outputs_to_watch(this_arg: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_outputs_to_watch(this_arg);
+ return nativeResponseValue;
+ }
+ // void ChannelMonitor_load_outputs_to_watch(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKFilter *NONNULL_PTR filter);
+ export function ChannelMonitor_load_outputs_to_watch(this_arg: number, filter: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_load_outputs_to_watch(this_arg, filter);
+ // debug statements here
+ }
// MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
export function ChannelMonitor_get_and_clear_pending_monitor_events(this_arg: number): number[] {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelMonitor_block_disconnected(this_arg, encodeArray(header), height, broadcaster, fee_estimator, logger);
// debug statements here
}
+ // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_transactions_confirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+ export function ChannelMonitor_transactions_confirmed(this_arg: number, header: Uint8Array, txdata: number[], height: number, broadcaster: number, fee_estimator: number, logger: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_transactions_confirmed(this_arg, encodeArray(header), txdata, height, broadcaster, fee_estimator, logger);
+ return nativeResponseValue;
+ }
+ // void ChannelMonitor_transaction_unconfirmed(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*txid)[32], struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+ export function ChannelMonitor_transaction_unconfirmed(this_arg: number, txid: Uint8Array, broadcaster: number, fee_estimator: number, logger: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_transaction_unconfirmed(this_arg, encodeArray(txid), broadcaster, fee_estimator, logger);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_update_best_block(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger);
+ export function ChannelMonitor_update_best_block(this_arg: number, header: Uint8Array, height: number, broadcaster: number, fee_estimator: number, logger: number): number[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_update_best_block(this_arg, encodeArray(header), height, broadcaster, fee_estimator, logger);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_TxidZ ChannelMonitor_get_relevant_txids(const struct LDKChannelMonitor *NONNULL_PTR this_arg);
+ export function ChannelMonitor_get_relevant_txids(this_arg: number): Uint8Array[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelMonitor_get_relevant_txids(this_arg);
+ return nativeResponseValue;
+ }
// void Persist_free(struct LDKPersist this_ptr);
export function Persist_free(this_ptr: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.C2Tuple_BlockHashChannelMonitorZ_read(encodeArray(ser), arg);
return nativeResponseValue;
}
- // void OutPoint_free(struct LDKOutPoint this_ptr);
- export function OutPoint_free(this_ptr: number): void {
+ // void OutPoint_free(struct LDKOutPoint this_obj);
+ export function OutPoint_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OutPoint_free(this_ptr);
+ const nativeResponseValue = wasm.OutPoint_free(this_obj);
// debug statements here
}
// const uint8_t (*OutPoint_get_txid(const struct LDKOutPoint *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.OutPoint_read(encodeArray(ser));
return nativeResponseValue;
}
- // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_ptr);
- export function DelayedPaymentOutputDescriptor_free(this_ptr: number): void {
+ // void DelayedPaymentOutputDescriptor_free(struct LDKDelayedPaymentOutputDescriptor this_obj);
+ export function DelayedPaymentOutputDescriptor_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_free(this_ptr);
+ const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_free(this_obj);
// debug statements here
}
// struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_clone(orig);
return nativeResponseValue;
}
- // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_ptr);
- export function StaticPaymentOutputDescriptor_free(this_ptr: number): void {
+ // void StaticPaymentOutputDescriptor_free(struct LDKStaticPaymentOutputDescriptor this_obj);
+ export function StaticPaymentOutputDescriptor_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_free(this_ptr);
+ const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_free(this_obj);
// debug statements here
}
// struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.SpendableOutputDescriptor_read(encodeArray(ser));
return nativeResponseValue;
}
+ // void BaseSign_free(struct LDKBaseSign this_ptr);
+ export function BaseSign_free(this_ptr: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BaseSign_free(this_ptr);
+ // debug statements here
+ }
// struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig);
export function Sign_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.KeysInterface_free(this_ptr);
// debug statements here
}
- // void InMemorySigner_free(struct LDKInMemorySigner this_ptr);
- export function InMemorySigner_free(this_ptr: number): void {
+ // void InMemorySigner_free(struct LDKInMemorySigner this_obj);
+ export function InMemorySigner_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InMemorySigner_free(this_ptr);
+ const nativeResponseValue = wasm.InMemorySigner_free(this_obj);
// debug statements here
}
// const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.InMemorySigner_sign_dynamic_p2wsh_input(this_arg, encodeArray(spend_tx), input_idx, descriptor);
return nativeResponseValue;
}
+ // struct LDKBaseSign InMemorySigner_as_BaseSign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
+ export function InMemorySigner_as_BaseSign(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InMemorySigner_as_BaseSign(this_arg);
+ return nativeResponseValue;
+ }
// struct LDKSign InMemorySigner_as_Sign(const struct LDKInMemorySigner *NONNULL_PTR this_arg);
export function InMemorySigner_as_Sign(this_arg: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.InMemorySigner_read(encodeArray(ser));
return nativeResponseValue;
}
- // void KeysManager_free(struct LDKKeysManager this_ptr);
- export function KeysManager_free(this_ptr: number): void {
+ // void KeysManager_free(struct LDKKeysManager this_obj);
+ export function KeysManager_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.KeysManager_free(this_ptr);
+ const nativeResponseValue = wasm.KeysManager_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos);
const nativeResponseValue = wasm.KeysManager_as_KeysInterface(this_arg);
return nativeResponseValue;
}
- // void ChannelManager_free(struct LDKChannelManager this_ptr);
- export function ChannelManager_free(this_ptr: number): void {
+ // void ChannelManager_free(struct LDKChannelManager this_obj);
+ export function ChannelManager_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelManager_free(this_obj);
// debug statements here
}
- // void ChainParameters_free(struct LDKChainParameters this_ptr);
- export function ChainParameters_free(this_ptr: number): void {
+ // void ChainParameters_free(struct LDKChainParameters this_obj);
+ export function ChainParameters_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_free(this_ptr);
+ const nativeResponseValue = wasm.ChainParameters_free(this_obj);
// debug statements here
}
// enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChainParameters_set_network(this_ptr, val);
// debug statements here
}
- // const uint8_t (*ChainParameters_get_latest_hash(const struct LDKChainParameters *NONNULL_PTR this_ptr))[32];
- export function ChainParameters_get_latest_hash(this_ptr: number): Uint8Array {
+ // struct LDKBestBlock ChainParameters_get_best_block(const struct LDKChainParameters *NONNULL_PTR this_ptr);
+ export function ChainParameters_get_best_block(this_ptr: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_get_latest_hash(this_ptr);
- return decodeArray(nativeResponseValue);
+ const nativeResponseValue = wasm.ChainParameters_get_best_block(this_ptr);
+ return nativeResponseValue;
}
- // void ChainParameters_set_latest_hash(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
- export function ChainParameters_set_latest_hash(this_ptr: number, val: Uint8Array): void {
+ // void ChainParameters_set_best_block(struct LDKChainParameters *NONNULL_PTR this_ptr, struct LDKBestBlock val);
+ export function ChainParameters_set_best_block(this_ptr: number, val: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_set_latest_hash(this_ptr, encodeArray(val));
+ const nativeResponseValue = wasm.ChainParameters_set_best_block(this_ptr, val);
// debug statements here
}
- // uintptr_t ChainParameters_get_latest_height(const struct LDKChainParameters *NONNULL_PTR this_ptr);
- export function ChainParameters_get_latest_height(this_ptr: number): number {
+ // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKBestBlock best_block_arg);
+ export function ChainParameters_new(network_arg: LDKNetwork, best_block_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_get_latest_height(this_ptr);
+ const nativeResponseValue = wasm.ChainParameters_new(network_arg, best_block_arg);
return nativeResponseValue;
}
- // void ChainParameters_set_latest_height(struct LDKChainParameters *NONNULL_PTR this_ptr, uintptr_t val);
- export function ChainParameters_set_latest_height(this_ptr: number, val: number): void {
+ // void BestBlock_free(struct LDKBestBlock this_obj);
+ export function BestBlock_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_set_latest_height(this_ptr, val);
+ const nativeResponseValue = wasm.BestBlock_free(this_obj);
// debug statements here
}
- // MUST_USE_RES struct LDKChainParameters ChainParameters_new(enum LDKNetwork network_arg, struct LDKThirtyTwoBytes latest_hash_arg, uintptr_t latest_height_arg);
- export function ChainParameters_new(network_arg: LDKNetwork, latest_hash_arg: Uint8Array, latest_height_arg: number): number {
+ // struct LDKBestBlock BestBlock_clone(const struct LDKBestBlock *NONNULL_PTR orig);
+ export function BestBlock_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_clone(orig);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKBestBlock BestBlock_from_genesis(enum LDKNetwork network);
+ export function BestBlock_from_genesis(network: LDKNetwork): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_from_genesis(network);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKBestBlock BestBlock_new(struct LDKThirtyTwoBytes block_hash, uint32_t height);
+ export function BestBlock_new(block_hash: Uint8Array, height: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_new(encodeArray(block_hash), height);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKThirtyTwoBytes BestBlock_block_hash(const struct LDKBestBlock *NONNULL_PTR this_arg);
+ export function BestBlock_block_hash(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.BestBlock_block_hash(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES uint32_t BestBlock_height(const struct LDKBestBlock *NONNULL_PTR this_arg);
+ export function BestBlock_height(this_arg: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChainParameters_new(network_arg, encodeArray(latest_hash_arg), latest_height_arg);
+ const nativeResponseValue = wasm.BestBlock_height(this_arg);
return nativeResponseValue;
}
- // void ChannelDetails_free(struct LDKChannelDetails this_ptr);
- export function ChannelDetails_free(this_ptr: number): void {
+ // void ChannelDetails_free(struct LDKChannelDetails this_obj);
+ export function ChannelDetails_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelDetails_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelDetails_free(this_obj);
// debug statements here
}
// const uint8_t (*ChannelDetails_get_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ChannelDetails_set_channel_id(this_ptr, encodeArray(val));
// debug statements here
}
+ // struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+ export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_get_short_channel_id(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelDetails_set_short_channel_id(this_ptr, val);
+ // debug statements here
+ }
// struct LDKPublicKey ChannelDetails_get_remote_network_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
export function ChannelDetails_get_remote_network_id(this_ptr: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params);
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKUserConfig ChannelManager_get_current_default_configuration(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_get_current_default_configuration(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_get_current_default_configuration(this_arg);
+ return nativeResponseValue;
+ }
// MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_create_channel(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKPublicKey their_network_key, uint64_t channel_value_satoshis, uint64_t push_msat, uint64_t user_id, struct LDKUserConfig override_config);
export function ChannelManager_create_channel(this_arg: number, their_network_key: Uint8Array, channel_value_satoshis: number, push_msat: number, user_id: number, override_config: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_send_payment(this_arg, route, encodeArray(payment_hash), encodeArray(payment_secret));
return nativeResponseValue;
}
- // void ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKOutPoint funding_txo);
- export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: Uint8Array, funding_txo: number): void {
+ // MUST_USE_RES struct LDKCResult_NoneAPIErrorZ ChannelManager_funding_transaction_generated(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*temporary_channel_id)[32], struct LDKTransaction funding_transaction);
+ export function ChannelManager_funding_transaction_generated(this_arg: number, temporary_channel_id: Uint8Array, funding_transaction: Uint8Array): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_funding_transaction_generated(this_arg, encodeArray(temporary_channel_id), funding_txo);
- // debug statements here
+ const nativeResponseValue = wasm.ChannelManager_funding_transaction_generated(this_arg, encodeArray(temporary_channel_id), encodeArray(funding_transaction));
+ return nativeResponseValue;
}
// void ChannelManager_broadcast_node_announcement(const struct LDKChannelManager *NONNULL_PTR this_arg, struct LDKThreeBytes rgb, struct LDKThirtyTwoBytes alias, struct LDKCVec_NetAddressZ addresses);
export function ChannelManager_broadcast_node_announcement(this_arg: number, rgb: Uint8Array, alias: Uint8Array, addresses: number[]): void {
const nativeResponseValue = wasm.ChannelManager_process_pending_htlc_forwards(this_arg);
// debug statements here
}
- // void ChannelManager_timer_chan_freshness_every_min(const struct LDKChannelManager *NONNULL_PTR this_arg);
- export function ChannelManager_timer_chan_freshness_every_min(this_arg: number): void {
+ // void ChannelManager_timer_tick_occurred(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_timer_tick_occurred(this_arg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_timer_chan_freshness_every_min(this_arg);
+ const nativeResponseValue = wasm.ChannelManager_timer_tick_occurred(this_arg);
// debug statements here
}
// MUST_USE_RES bool ChannelManager_fail_htlc_backwards(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*payment_hash)[32], struct LDKThirtyTwoBytes payment_secret);
const nativeResponseValue = wasm.ChannelManager_as_Listen(this_arg);
return nativeResponseValue;
}
- // void ChannelManager_block_connected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], struct LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height);
- export function ChannelManager_block_connected(this_arg: number, header: Uint8Array, txdata: number[], height: number): void {
+ // void ChannelManager_transactions_confirmed(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKCVec_C2Tuple_usizeTransactionZZ txdata);
+ export function ChannelManager_transactions_confirmed(this_arg: number, header: Uint8Array, height: number, txdata: number[]): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_transactions_confirmed(this_arg, encodeArray(header), height, txdata);
+ // debug statements here
+ }
+ // void ChannelManager_update_best_block(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height);
+ export function ChannelManager_update_best_block(this_arg: number, header: Uint8Array, height: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_block_connected(this_arg, encodeArray(header), txdata, height);
+ const nativeResponseValue = wasm.ChannelManager_update_best_block(this_arg, encodeArray(header), height);
// debug statements here
}
- // void ChannelManager_block_disconnected(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*header)[80]);
- export function ChannelManager_block_disconnected(this_arg: number, header: Uint8Array): void {
+ // MUST_USE_RES struct LDKCVec_TxidZ ChannelManager_get_relevant_txids(const struct LDKChannelManager *NONNULL_PTR this_arg);
+ export function ChannelManager_get_relevant_txids(this_arg: number): Uint8Array[] {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_get_relevant_txids(this_arg);
+ return nativeResponseValue;
+ }
+ // void ChannelManager_transaction_unconfirmed(const struct LDKChannelManager *NONNULL_PTR this_arg, const uint8_t (*txid)[32]);
+ export function ChannelManager_transaction_unconfirmed(this_arg: number, txid: Uint8Array): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManager_block_disconnected(this_arg, encodeArray(header));
+ const nativeResponseValue = wasm.ChannelManager_transaction_unconfirmed(this_arg, encodeArray(txid));
// debug statements here
}
+ // MUST_USE_RES bool ChannelManager_await_persistable_update_timeout(const struct LDKChannelManager *NONNULL_PTR this_arg, uint64_t max_wait);
+ export function ChannelManager_await_persistable_update_timeout(this_arg: number, max_wait: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelManager_await_persistable_update_timeout(this_arg, max_wait);
+ return nativeResponseValue;
+ }
// void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
export function ChannelManager_await_persistable_update(this_arg: number): void {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelManager_write(obj);
return decodeArray(nativeResponseValue);
}
- // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_ptr);
- export function ChannelManagerReadArgs_free(this_ptr: number): void {
+ // void ChannelManagerReadArgs_free(struct LDKChannelManagerReadArgs this_obj);
+ export function ChannelManagerReadArgs_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelManagerReadArgs_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelManagerReadArgs_free(this_obj);
// debug statements here
}
// const struct LDKKeysInterface *ChannelManagerReadArgs_get_keys_manager(const struct LDKChannelManagerReadArgs *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.C2Tuple_BlockHashChannelManagerZ_read(encodeArray(ser), arg);
return nativeResponseValue;
}
- // void DecodeError_free(struct LDKDecodeError this_ptr);
- export function DecodeError_free(this_ptr: number): void {
+ // void DecodeError_free(struct LDKDecodeError this_obj);
+ export function DecodeError_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.DecodeError_free(this_ptr);
+ const nativeResponseValue = wasm.DecodeError_free(this_obj);
// debug statements here
}
// struct LDKDecodeError DecodeError_clone(const struct LDKDecodeError *NONNULL_PTR orig);
const nativeResponseValue = wasm.DecodeError_clone(orig);
return nativeResponseValue;
}
- // void Init_free(struct LDKInit this_ptr);
- export function Init_free(this_ptr: number): void {
+ // void Init_free(struct LDKInit this_obj);
+ export function Init_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Init_free(this_ptr);
+ const nativeResponseValue = wasm.Init_free(this_obj);
// debug statements here
}
// struct LDKInitFeatures Init_get_features(const struct LDKInit *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.Init_clone(orig);
return nativeResponseValue;
}
- // void ErrorMessage_free(struct LDKErrorMessage this_ptr);
- export function ErrorMessage_free(this_ptr: number): void {
+ // void ErrorMessage_free(struct LDKErrorMessage this_obj);
+ export function ErrorMessage_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ErrorMessage_free(this_ptr);
+ const nativeResponseValue = wasm.ErrorMessage_free(this_obj);
// debug statements here
}
// const uint8_t (*ErrorMessage_get_channel_id(const struct LDKErrorMessage *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ErrorMessage_clone(orig);
return nativeResponseValue;
}
- // void Ping_free(struct LDKPing this_ptr);
- export function Ping_free(this_ptr: number): void {
+ // void Ping_free(struct LDKPing this_obj);
+ export function Ping_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Ping_free(this_ptr);
+ const nativeResponseValue = wasm.Ping_free(this_obj);
// debug statements here
}
// uint16_t Ping_get_ponglen(const struct LDKPing *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.Ping_clone(orig);
return nativeResponseValue;
}
- // void Pong_free(struct LDKPong this_ptr);
- export function Pong_free(this_ptr: number): void {
+ // void Pong_free(struct LDKPong this_obj);
+ export function Pong_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Pong_free(this_ptr);
+ const nativeResponseValue = wasm.Pong_free(this_obj);
// debug statements here
}
// uint16_t Pong_get_byteslen(const struct LDKPong *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.Pong_clone(orig);
return nativeResponseValue;
}
- // void OpenChannel_free(struct LDKOpenChannel this_ptr);
- export function OpenChannel_free(this_ptr: number): void {
+ // void OpenChannel_free(struct LDKOpenChannel this_obj);
+ export function OpenChannel_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.OpenChannel_free(this_ptr);
+ const nativeResponseValue = wasm.OpenChannel_free(this_obj);
// debug statements here
}
// const uint8_t (*OpenChannel_get_chain_hash(const struct LDKOpenChannel *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.OpenChannel_clone(orig);
return nativeResponseValue;
}
- // void AcceptChannel_free(struct LDKAcceptChannel this_ptr);
- export function AcceptChannel_free(this_ptr: number): void {
+ // void AcceptChannel_free(struct LDKAcceptChannel this_obj);
+ export function AcceptChannel_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.AcceptChannel_free(this_ptr);
+ const nativeResponseValue = wasm.AcceptChannel_free(this_obj);
// debug statements here
}
// const uint8_t (*AcceptChannel_get_temporary_channel_id(const struct LDKAcceptChannel *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.AcceptChannel_clone(orig);
return nativeResponseValue;
}
- // void FundingCreated_free(struct LDKFundingCreated this_ptr);
- export function FundingCreated_free(this_ptr: number): void {
+ // void FundingCreated_free(struct LDKFundingCreated this_obj);
+ export function FundingCreated_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.FundingCreated_free(this_ptr);
+ const nativeResponseValue = wasm.FundingCreated_free(this_obj);
// debug statements here
}
// const uint8_t (*FundingCreated_get_temporary_channel_id(const struct LDKFundingCreated *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.FundingCreated_clone(orig);
return nativeResponseValue;
}
- // void FundingSigned_free(struct LDKFundingSigned this_ptr);
- export function FundingSigned_free(this_ptr: number): void {
+ // void FundingSigned_free(struct LDKFundingSigned this_obj);
+ export function FundingSigned_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.FundingSigned_free(this_ptr);
+ const nativeResponseValue = wasm.FundingSigned_free(this_obj);
// debug statements here
}
// const uint8_t (*FundingSigned_get_channel_id(const struct LDKFundingSigned *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.FundingSigned_clone(orig);
return nativeResponseValue;
}
- // void FundingLocked_free(struct LDKFundingLocked this_ptr);
- export function FundingLocked_free(this_ptr: number): void {
+ // void FundingLocked_free(struct LDKFundingLocked this_obj);
+ export function FundingLocked_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.FundingLocked_free(this_ptr);
+ const nativeResponseValue = wasm.FundingLocked_free(this_obj);
// debug statements here
}
// const uint8_t (*FundingLocked_get_channel_id(const struct LDKFundingLocked *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.FundingLocked_clone(orig);
return nativeResponseValue;
}
- // void Shutdown_free(struct LDKShutdown this_ptr);
- export function Shutdown_free(this_ptr: number): void {
+ // void Shutdown_free(struct LDKShutdown this_obj);
+ export function Shutdown_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Shutdown_free(this_ptr);
+ const nativeResponseValue = wasm.Shutdown_free(this_obj);
// debug statements here
}
// const uint8_t (*Shutdown_get_channel_id(const struct LDKShutdown *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.Shutdown_clone(orig);
return nativeResponseValue;
}
- // void ClosingSigned_free(struct LDKClosingSigned this_ptr);
- export function ClosingSigned_free(this_ptr: number): void {
+ // void ClosingSigned_free(struct LDKClosingSigned this_obj);
+ export function ClosingSigned_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ClosingSigned_free(this_ptr);
+ const nativeResponseValue = wasm.ClosingSigned_free(this_obj);
// debug statements here
}
// const uint8_t (*ClosingSigned_get_channel_id(const struct LDKClosingSigned *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ClosingSigned_clone(orig);
return nativeResponseValue;
}
- // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_ptr);
- export function UpdateAddHTLC_free(this_ptr: number): void {
+ // void UpdateAddHTLC_free(struct LDKUpdateAddHTLC this_obj);
+ export function UpdateAddHTLC_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UpdateAddHTLC_free(this_ptr);
+ const nativeResponseValue = wasm.UpdateAddHTLC_free(this_obj);
// debug statements here
}
// const uint8_t (*UpdateAddHTLC_get_channel_id(const struct LDKUpdateAddHTLC *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UpdateAddHTLC_clone(orig);
return nativeResponseValue;
}
- // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_ptr);
- export function UpdateFulfillHTLC_free(this_ptr: number): void {
+ // void UpdateFulfillHTLC_free(struct LDKUpdateFulfillHTLC this_obj);
+ export function UpdateFulfillHTLC_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UpdateFulfillHTLC_free(this_ptr);
+ const nativeResponseValue = wasm.UpdateFulfillHTLC_free(this_obj);
// debug statements here
}
// const uint8_t (*UpdateFulfillHTLC_get_channel_id(const struct LDKUpdateFulfillHTLC *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UpdateFulfillHTLC_clone(orig);
return nativeResponseValue;
}
- // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_ptr);
- export function UpdateFailHTLC_free(this_ptr: number): void {
+ // void UpdateFailHTLC_free(struct LDKUpdateFailHTLC this_obj);
+ export function UpdateFailHTLC_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UpdateFailHTLC_free(this_ptr);
+ const nativeResponseValue = wasm.UpdateFailHTLC_free(this_obj);
// debug statements here
}
// const uint8_t (*UpdateFailHTLC_get_channel_id(const struct LDKUpdateFailHTLC *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UpdateFailHTLC_clone(orig);
return nativeResponseValue;
}
- // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_ptr);
- export function UpdateFailMalformedHTLC_free(this_ptr: number): void {
+ // void UpdateFailMalformedHTLC_free(struct LDKUpdateFailMalformedHTLC this_obj);
+ export function UpdateFailMalformedHTLC_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UpdateFailMalformedHTLC_free(this_ptr);
+ const nativeResponseValue = wasm.UpdateFailMalformedHTLC_free(this_obj);
// debug statements here
}
// const uint8_t (*UpdateFailMalformedHTLC_get_channel_id(const struct LDKUpdateFailMalformedHTLC *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UpdateFailMalformedHTLC_clone(orig);
return nativeResponseValue;
}
- // void CommitmentSigned_free(struct LDKCommitmentSigned this_ptr);
- export function CommitmentSigned_free(this_ptr: number): void {
+ // void CommitmentSigned_free(struct LDKCommitmentSigned this_obj);
+ export function CommitmentSigned_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CommitmentSigned_free(this_ptr);
+ const nativeResponseValue = wasm.CommitmentSigned_free(this_obj);
// debug statements here
}
// const uint8_t (*CommitmentSigned_get_channel_id(const struct LDKCommitmentSigned *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.CommitmentSigned_clone(orig);
return nativeResponseValue;
}
- // void RevokeAndACK_free(struct LDKRevokeAndACK this_ptr);
- export function RevokeAndACK_free(this_ptr: number): void {
+ // void RevokeAndACK_free(struct LDKRevokeAndACK this_obj);
+ export function RevokeAndACK_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RevokeAndACK_free(this_ptr);
+ const nativeResponseValue = wasm.RevokeAndACK_free(this_obj);
// debug statements here
}
// const uint8_t (*RevokeAndACK_get_channel_id(const struct LDKRevokeAndACK *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.RevokeAndACK_clone(orig);
return nativeResponseValue;
}
- // void UpdateFee_free(struct LDKUpdateFee this_ptr);
- export function UpdateFee_free(this_ptr: number): void {
+ // void UpdateFee_free(struct LDKUpdateFee this_obj);
+ export function UpdateFee_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UpdateFee_free(this_ptr);
+ const nativeResponseValue = wasm.UpdateFee_free(this_obj);
// debug statements here
}
// const uint8_t (*UpdateFee_get_channel_id(const struct LDKUpdateFee *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UpdateFee_clone(orig);
return nativeResponseValue;
}
- // void DataLossProtect_free(struct LDKDataLossProtect this_ptr);
- export function DataLossProtect_free(this_ptr: number): void {
+ // void DataLossProtect_free(struct LDKDataLossProtect this_obj);
+ export function DataLossProtect_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.DataLossProtect_free(this_ptr);
+ const nativeResponseValue = wasm.DataLossProtect_free(this_obj);
// debug statements here
}
// const uint8_t (*DataLossProtect_get_your_last_per_commitment_secret(const struct LDKDataLossProtect *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.DataLossProtect_clone(orig);
return nativeResponseValue;
}
- // void ChannelReestablish_free(struct LDKChannelReestablish this_ptr);
- export function ChannelReestablish_free(this_ptr: number): void {
+ // void ChannelReestablish_free(struct LDKChannelReestablish this_obj);
+ export function ChannelReestablish_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelReestablish_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelReestablish_free(this_obj);
// debug statements here
}
// const uint8_t (*ChannelReestablish_get_channel_id(const struct LDKChannelReestablish *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ChannelReestablish_clone(orig);
return nativeResponseValue;
}
- // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_ptr);
- export function AnnouncementSignatures_free(this_ptr: number): void {
+ // void AnnouncementSignatures_free(struct LDKAnnouncementSignatures this_obj);
+ export function AnnouncementSignatures_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.AnnouncementSignatures_free(this_ptr);
+ const nativeResponseValue = wasm.AnnouncementSignatures_free(this_obj);
// debug statements here
}
// const uint8_t (*AnnouncementSignatures_get_channel_id(const struct LDKAnnouncementSignatures *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.Result_read(encodeArray(ser));
return nativeResponseValue;
}
- // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_ptr);
- export function UnsignedNodeAnnouncement_free(this_ptr: number): void {
+ // void UnsignedNodeAnnouncement_free(struct LDKUnsignedNodeAnnouncement this_obj);
+ export function UnsignedNodeAnnouncement_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UnsignedNodeAnnouncement_free(this_ptr);
+ const nativeResponseValue = wasm.UnsignedNodeAnnouncement_free(this_obj);
// debug statements here
}
// struct LDKNodeFeatures UnsignedNodeAnnouncement_get_features(const struct LDKUnsignedNodeAnnouncement *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.UnsignedNodeAnnouncement_clone(orig);
return nativeResponseValue;
}
- // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_ptr);
- export function NodeAnnouncement_free(this_ptr: number): void {
+ // void NodeAnnouncement_free(struct LDKNodeAnnouncement this_obj);
+ export function NodeAnnouncement_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeAnnouncement_free(this_ptr);
+ const nativeResponseValue = wasm.NodeAnnouncement_free(this_obj);
// debug statements here
}
// struct LDKSignature NodeAnnouncement_get_signature(const struct LDKNodeAnnouncement *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.NodeAnnouncement_clone(orig);
return nativeResponseValue;
}
- // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_ptr);
- export function UnsignedChannelAnnouncement_free(this_ptr: number): void {
+ // void UnsignedChannelAnnouncement_free(struct LDKUnsignedChannelAnnouncement this_obj);
+ export function UnsignedChannelAnnouncement_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UnsignedChannelAnnouncement_free(this_ptr);
+ const nativeResponseValue = wasm.UnsignedChannelAnnouncement_free(this_obj);
// debug statements here
}
// struct LDKChannelFeatures UnsignedChannelAnnouncement_get_features(const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.UnsignedChannelAnnouncement_clone(orig);
return nativeResponseValue;
}
- // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_ptr);
- export function ChannelAnnouncement_free(this_ptr: number): void {
+ // void ChannelAnnouncement_free(struct LDKChannelAnnouncement this_obj);
+ export function ChannelAnnouncement_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelAnnouncement_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelAnnouncement_free(this_obj);
// debug statements here
}
// struct LDKSignature ChannelAnnouncement_get_node_signature_1(const struct LDKChannelAnnouncement *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelAnnouncement_clone(orig);
return nativeResponseValue;
}
- // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_ptr);
- export function UnsignedChannelUpdate_free(this_ptr: number): void {
+ // void UnsignedChannelUpdate_free(struct LDKUnsignedChannelUpdate this_obj);
+ export function UnsignedChannelUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.UnsignedChannelUpdate_free(this_ptr);
+ const nativeResponseValue = wasm.UnsignedChannelUpdate_free(this_obj);
// debug statements here
}
// const uint8_t (*UnsignedChannelUpdate_get_chain_hash(const struct LDKUnsignedChannelUpdate *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.UnsignedChannelUpdate_clone(orig);
return nativeResponseValue;
}
- // void ChannelUpdate_free(struct LDKChannelUpdate this_ptr);
- export function ChannelUpdate_free(this_ptr: number): void {
+ // void ChannelUpdate_free(struct LDKChannelUpdate this_obj);
+ export function ChannelUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelUpdate_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelUpdate_free(this_obj);
// debug statements here
}
// struct LDKSignature ChannelUpdate_get_signature(const struct LDKChannelUpdate *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelUpdate_clone(orig);
return nativeResponseValue;
}
- // void QueryChannelRange_free(struct LDKQueryChannelRange this_ptr);
- export function QueryChannelRange_free(this_ptr: number): void {
+ // void QueryChannelRange_free(struct LDKQueryChannelRange this_obj);
+ export function QueryChannelRange_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.QueryChannelRange_free(this_ptr);
+ const nativeResponseValue = wasm.QueryChannelRange_free(this_obj);
// debug statements here
}
// const uint8_t (*QueryChannelRange_get_chain_hash(const struct LDKQueryChannelRange *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.QueryChannelRange_clone(orig);
return nativeResponseValue;
}
- // void ReplyChannelRange_free(struct LDKReplyChannelRange this_ptr);
- export function ReplyChannelRange_free(this_ptr: number): void {
+ // void ReplyChannelRange_free(struct LDKReplyChannelRange this_obj);
+ export function ReplyChannelRange_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ReplyChannelRange_free(this_ptr);
+ const nativeResponseValue = wasm.ReplyChannelRange_free(this_obj);
// debug statements here
}
// const uint8_t (*ReplyChannelRange_get_chain_hash(const struct LDKReplyChannelRange *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ReplyChannelRange_clone(orig);
return nativeResponseValue;
}
- // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_ptr);
- export function QueryShortChannelIds_free(this_ptr: number): void {
+ // void QueryShortChannelIds_free(struct LDKQueryShortChannelIds this_obj);
+ export function QueryShortChannelIds_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.QueryShortChannelIds_free(this_ptr);
+ const nativeResponseValue = wasm.QueryShortChannelIds_free(this_obj);
// debug statements here
}
// const uint8_t (*QueryShortChannelIds_get_chain_hash(const struct LDKQueryShortChannelIds *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.QueryShortChannelIds_clone(orig);
return nativeResponseValue;
}
- // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_ptr);
- export function ReplyShortChannelIdsEnd_free(this_ptr: number): void {
+ // void ReplyShortChannelIdsEnd_free(struct LDKReplyShortChannelIdsEnd this_obj);
+ export function ReplyShortChannelIdsEnd_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_free(this_ptr);
+ const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_free(this_obj);
// debug statements here
}
// const uint8_t (*ReplyShortChannelIdsEnd_get_chain_hash(const struct LDKReplyShortChannelIdsEnd *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_clone(orig);
return nativeResponseValue;
}
- // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_ptr);
- export function GossipTimestampFilter_free(this_ptr: number): void {
+ // void GossipTimestampFilter_free(struct LDKGossipTimestampFilter this_obj);
+ export function GossipTimestampFilter_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.GossipTimestampFilter_free(this_ptr);
+ const nativeResponseValue = wasm.GossipTimestampFilter_free(this_obj);
// debug statements here
}
// const uint8_t (*GossipTimestampFilter_get_chain_hash(const struct LDKGossipTimestampFilter *NONNULL_PTR this_ptr))[32];
const nativeResponseValue = wasm.ErrorAction_clone(orig);
return nativeResponseValue;
}
- // void LightningError_free(struct LDKLightningError this_ptr);
- export function LightningError_free(this_ptr: number): void {
+ // void LightningError_free(struct LDKLightningError this_obj);
+ export function LightningError_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.LightningError_free(this_ptr);
+ const nativeResponseValue = wasm.LightningError_free(this_obj);
// debug statements here
}
// struct LDKStr LightningError_get_err(const struct LDKLightningError *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.LightningError_clone(orig);
return nativeResponseValue;
}
- // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_ptr);
- export function CommitmentUpdate_free(this_ptr: number): void {
+ // void CommitmentUpdate_free(struct LDKCommitmentUpdate this_obj);
+ export function CommitmentUpdate_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CommitmentUpdate_free(this_ptr);
+ const nativeResponseValue = wasm.CommitmentUpdate_free(this_obj);
// debug statements here
}
// void CommitmentUpdate_set_update_add_htlcs(struct LDKCommitmentUpdate *NONNULL_PTR this_ptr, struct LDKCVec_UpdateAddHTLCZ val);
const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_write(obj);
return decodeArray(nativeResponseValue);
}
+ // MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
+ export function QueryChannelRange_end_blocknum(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.QueryChannelRange_end_blocknum(this_arg);
+ return nativeResponseValue;
+ }
// struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
export function QueryChannelRange_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.GossipTimestampFilter_write(obj);
return decodeArray(nativeResponseValue);
}
- // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_ptr);
- export function IgnoringMessageHandler_free(this_ptr: number): void {
+ // void IgnoringMessageHandler_free(struct LDKIgnoringMessageHandler this_obj);
+ export function IgnoringMessageHandler_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.IgnoringMessageHandler_free(this_ptr);
+ const nativeResponseValue = wasm.IgnoringMessageHandler_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void);
const nativeResponseValue = wasm.IgnoringMessageHandler_as_RoutingMessageHandler(this_arg);
return nativeResponseValue;
}
- // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_ptr);
- export function ErroringMessageHandler_free(this_ptr: number): void {
+ // void ErroringMessageHandler_free(struct LDKErroringMessageHandler this_obj);
+ export function ErroringMessageHandler_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ErroringMessageHandler_free(this_ptr);
+ const nativeResponseValue = wasm.ErroringMessageHandler_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void);
const nativeResponseValue = wasm.ErroringMessageHandler_as_ChannelMessageHandler(this_arg);
return nativeResponseValue;
}
- // void MessageHandler_free(struct LDKMessageHandler this_ptr);
- export function MessageHandler_free(this_ptr: number): void {
+ // void MessageHandler_free(struct LDKMessageHandler this_obj);
+ export function MessageHandler_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.MessageHandler_free(this_ptr);
+ const nativeResponseValue = wasm.MessageHandler_free(this_obj);
// debug statements here
}
// const struct LDKChannelMessageHandler *MessageHandler_get_chan_handler(const struct LDKMessageHandler *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.SocketDescriptor_free(this_ptr);
// debug statements here
}
- // void PeerHandleError_free(struct LDKPeerHandleError this_ptr);
- export function PeerHandleError_free(this_ptr: number): void {
+ // void PeerHandleError_free(struct LDKPeerHandleError this_obj);
+ export function PeerHandleError_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PeerHandleError_free(this_ptr);
+ const nativeResponseValue = wasm.PeerHandleError_free(this_obj);
// debug statements here
}
// bool PeerHandleError_get_no_connection_possible(const struct LDKPeerHandleError *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.PeerHandleError_clone(orig);
return nativeResponseValue;
}
- // void PeerManager_free(struct LDKPeerManager this_ptr);
- export function PeerManager_free(this_ptr: number): void {
+ // void PeerManager_free(struct LDKPeerManager this_obj);
+ export function PeerManager_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PeerManager_free(this_ptr);
+ const nativeResponseValue = wasm.PeerManager_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKPeerManager PeerManager_new(struct LDKMessageHandler message_handler, struct LDKSecretKey our_node_secret, const uint8_t (*ephemeral_random_data)[32], struct LDKLogger logger);
const nativeResponseValue = wasm.PeerManager_disconnect_by_node_id(this_arg, encodeArray(node_id), no_connection_possible);
// debug statements here
}
- // void PeerManager_timer_tick_occured(const struct LDKPeerManager *NONNULL_PTR this_arg);
- export function PeerManager_timer_tick_occured(this_arg: number): void {
+ // void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
+ export function PeerManager_timer_tick_occurred(this_arg: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.PeerManager_timer_tick_occured(this_arg);
+ const nativeResponseValue = wasm.PeerManager_timer_tick_occurred(this_arg);
// debug statements here
}
// struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
const nativeResponseValue = wasm.derive_public_revocation_key(encodeArray(per_commitment_point), encodeArray(countersignatory_revocation_base_point));
return nativeResponseValue;
}
- // void TxCreationKeys_free(struct LDKTxCreationKeys this_ptr);
- export function TxCreationKeys_free(this_ptr: number): void {
+ // void TxCreationKeys_free(struct LDKTxCreationKeys this_obj);
+ export function TxCreationKeys_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TxCreationKeys_free(this_ptr);
+ const nativeResponseValue = wasm.TxCreationKeys_free(this_obj);
// debug statements here
}
// struct LDKPublicKey TxCreationKeys_get_per_commitment_point(const struct LDKTxCreationKeys *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.TxCreationKeys_read(encodeArray(ser));
return nativeResponseValue;
}
- // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_ptr);
- export function ChannelPublicKeys_free(this_ptr: number): void {
+ // void ChannelPublicKeys_free(struct LDKChannelPublicKeys this_obj);
+ export function ChannelPublicKeys_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelPublicKeys_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelPublicKeys_free(this_obj);
// debug statements here
}
// struct LDKPublicKey ChannelPublicKeys_get_funding_pubkey(const struct LDKChannelPublicKeys *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.get_revokeable_redeemscript(encodeArray(revocation_key), contest_delay, encodeArray(broadcaster_delayed_payment_key));
return decodeArray(nativeResponseValue);
}
- // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_ptr);
- export function HTLCOutputInCommitment_free(this_ptr: number): void {
+ // void HTLCOutputInCommitment_free(struct LDKHTLCOutputInCommitment this_obj);
+ export function HTLCOutputInCommitment_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HTLCOutputInCommitment_free(this_ptr);
+ const nativeResponseValue = wasm.HTLCOutputInCommitment_free(this_obj);
// debug statements here
}
// bool HTLCOutputInCommitment_get_offered(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.HTLCOutputInCommitment_set_payment_hash(this_ptr, encodeArray(val));
// debug statements here
}
+ // struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
+ export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
+ return nativeResponseValue;
+ }
+ // void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+ export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_new(bool offered_arg, uint64_t amount_msat_arg, uint32_t cltv_expiry_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_u32Z transaction_output_index_arg);
+ export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: number, cltv_expiry_arg: number, payment_hash_arg: Uint8Array, transaction_output_index_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, encodeArray(payment_hash_arg), transaction_output_index_arg);
+ return nativeResponseValue;
+ }
// struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
export function HTLCOutputInCommitment_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.build_htlc_transaction(encodeArray(prev_hash), feerate_per_kw, contest_delay, htlc, encodeArray(broadcaster_delayed_payment_key), encodeArray(revocation_key));
return decodeArray(nativeResponseValue);
}
- // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_ptr);
- export function ChannelTransactionParameters_free(this_ptr: number): void {
+ // void ChannelTransactionParameters_free(struct LDKChannelTransactionParameters this_obj);
+ export function ChannelTransactionParameters_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelTransactionParameters_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelTransactionParameters_free(this_obj);
// debug statements here
}
// struct LDKChannelPublicKeys ChannelTransactionParameters_get_holder_pubkeys(const struct LDKChannelTransactionParameters *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelTransactionParameters_clone(orig);
return nativeResponseValue;
}
- // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_ptr);
- export function CounterpartyChannelTransactionParameters_free(this_ptr: number): void {
+ // void CounterpartyChannelTransactionParameters_free(struct LDKCounterpartyChannelTransactionParameters this_obj);
+ export function CounterpartyChannelTransactionParameters_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CounterpartyChannelTransactionParameters_free(this_ptr);
+ const nativeResponseValue = wasm.CounterpartyChannelTransactionParameters_free(this_obj);
// debug statements here
}
// struct LDKChannelPublicKeys CounterpartyChannelTransactionParameters_get_pubkeys(const struct LDKCounterpartyChannelTransactionParameters *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelTransactionParameters_read(encodeArray(ser));
return nativeResponseValue;
}
- // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_ptr);
- export function DirectedChannelTransactionParameters_free(this_ptr: number): void {
+ // void DirectedChannelTransactionParameters_free(struct LDKDirectedChannelTransactionParameters this_obj);
+ export function DirectedChannelTransactionParameters_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.DirectedChannelTransactionParameters_free(this_ptr);
+ const nativeResponseValue = wasm.DirectedChannelTransactionParameters_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKChannelPublicKeys DirectedChannelTransactionParameters_broadcaster_pubkeys(const struct LDKDirectedChannelTransactionParameters *NONNULL_PTR this_arg);
const nativeResponseValue = wasm.DirectedChannelTransactionParameters_funding_outpoint(this_arg);
return nativeResponseValue;
}
- // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_ptr);
- export function HolderCommitmentTransaction_free(this_ptr: number): void {
+ // void HolderCommitmentTransaction_free(struct LDKHolderCommitmentTransaction this_obj);
+ export function HolderCommitmentTransaction_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.HolderCommitmentTransaction_free(this_ptr);
+ const nativeResponseValue = wasm.HolderCommitmentTransaction_free(this_obj);
// debug statements here
}
// struct LDKSignature HolderCommitmentTransaction_get_counterparty_sig(const struct LDKHolderCommitmentTransaction *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.HolderCommitmentTransaction_new(commitment_tx, encodeArray(counterparty_sig), counterparty_htlc_sigs, encodeArray(holder_funding_key), encodeArray(counterparty_funding_key));
return nativeResponseValue;
}
- // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_ptr);
- export function BuiltCommitmentTransaction_free(this_ptr: number): void {
+ // void BuiltCommitmentTransaction_free(struct LDKBuiltCommitmentTransaction this_obj);
+ export function BuiltCommitmentTransaction_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.BuiltCommitmentTransaction_free(this_ptr);
+ const nativeResponseValue = wasm.BuiltCommitmentTransaction_free(this_obj);
// debug statements here
}
// struct LDKTransaction BuiltCommitmentTransaction_get_transaction(const struct LDKBuiltCommitmentTransaction *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.BuiltCommitmentTransaction_sign(this_arg, encodeArray(funding_key), encodeArray(funding_redeemscript), channel_value_satoshis);
return decodeArray(nativeResponseValue);
}
- // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_ptr);
- export function CommitmentTransaction_free(this_ptr: number): void {
+ // void CommitmentTransaction_free(struct LDKCommitmentTransaction this_obj);
+ export function CommitmentTransaction_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.CommitmentTransaction_free(this_ptr);
+ const nativeResponseValue = wasm.CommitmentTransaction_free(this_obj);
// debug statements here
}
// struct LDKCommitmentTransaction CommitmentTransaction_clone(const struct LDKCommitmentTransaction *NONNULL_PTR orig);
const nativeResponseValue = wasm.CommitmentTransaction_verify(this_arg, channel_parameters, broadcaster_keys, countersignatory_keys);
return nativeResponseValue;
}
- // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_ptr);
- export function TrustedCommitmentTransaction_free(this_ptr: number): void {
+ // void TrustedCommitmentTransaction_free(struct LDKTrustedCommitmentTransaction this_obj);
+ export function TrustedCommitmentTransaction_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.TrustedCommitmentTransaction_free(this_ptr);
+ const nativeResponseValue = wasm.TrustedCommitmentTransaction_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKThirtyTwoBytes TrustedCommitmentTransaction_txid(const struct LDKTrustedCommitmentTransaction *NONNULL_PTR this_arg);
const nativeResponseValue = wasm.ChannelFeatures_clone(orig);
return nativeResponseValue;
}
- // void InitFeatures_free(struct LDKInitFeatures this_ptr);
- export function InitFeatures_free(this_ptr: number): void {
+ // struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
+ export function InvoiceFeatures_clone(orig: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_clone(orig);
+ return nativeResponseValue;
+ }
+ // void InitFeatures_free(struct LDKInitFeatures this_obj);
+ export function InitFeatures_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InitFeatures_free(this_obj);
+ // debug statements here
+ }
+ // void NodeFeatures_free(struct LDKNodeFeatures this_obj);
+ export function NodeFeatures_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.InitFeatures_free(this_ptr);
+ const nativeResponseValue = wasm.NodeFeatures_free(this_obj);
// debug statements here
}
- // void NodeFeatures_free(struct LDKNodeFeatures this_ptr);
- export function NodeFeatures_free(this_ptr: number): void {
+ // void ChannelFeatures_free(struct LDKChannelFeatures this_obj);
+ export function ChannelFeatures_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeFeatures_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelFeatures_free(this_obj);
// debug statements here
}
- // void ChannelFeatures_free(struct LDKChannelFeatures this_ptr);
- export function ChannelFeatures_free(this_ptr: number): void {
+ // void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
+ export function InvoiceFeatures_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelFeatures_free(this_ptr);
+ const nativeResponseValue = wasm.InvoiceFeatures_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
const nativeResponseValue = wasm.ChannelFeatures_known();
return nativeResponseValue;
}
+ // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
+ export function InvoiceFeatures_empty(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_empty();
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
+ export function InvoiceFeatures_known(): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_known();
+ return nativeResponseValue;
+ }
// struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
export function InitFeatures_write(obj: number): Uint8Array {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelFeatures_write(obj);
return decodeArray(nativeResponseValue);
}
+ // struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
+ export function InvoiceFeatures_write(obj: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_write(obj);
+ return decodeArray(nativeResponseValue);
+ }
// struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
export function InitFeatures_read(ser: Uint8Array): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelFeatures_read(encodeArray(ser));
return nativeResponseValue;
}
- // void RouteHop_free(struct LDKRouteHop this_ptr);
- export function RouteHop_free(this_ptr: number): void {
+ // struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
+ export function InvoiceFeatures_read(ser: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.InvoiceFeatures_read(encodeArray(ser));
+ return nativeResponseValue;
+ }
+ // void RouteHop_free(struct LDKRouteHop this_obj);
+ export function RouteHop_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RouteHop_free(this_ptr);
+ const nativeResponseValue = wasm.RouteHop_free(this_obj);
// debug statements here
}
// struct LDKPublicKey RouteHop_get_pubkey(const struct LDKRouteHop *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.RouteHop_clone(orig);
return nativeResponseValue;
}
- // void Route_free(struct LDKRoute this_ptr);
- export function Route_free(this_ptr: number): void {
+ // void Route_free(struct LDKRoute this_obj);
+ export function Route_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.Route_free(this_ptr);
+ const nativeResponseValue = wasm.Route_free(this_obj);
// debug statements here
}
// void Route_set_paths(struct LDKRoute *NONNULL_PTR this_ptr, struct LDKCVec_CVec_RouteHopZZ val);
const nativeResponseValue = wasm.Route_read(encodeArray(ser));
return nativeResponseValue;
}
- // void RouteHint_free(struct LDKRouteHint this_ptr);
- export function RouteHint_free(this_ptr: number): void {
+ // void RouteHint_free(struct LDKRouteHint this_obj);
+ export function RouteHint_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RouteHint_free(this_ptr);
+ const nativeResponseValue = wasm.RouteHint_free(this_obj);
// debug statements here
}
// struct LDKPublicKey RouteHint_get_src_node_id(const struct LDKRouteHint *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.RouteHint_set_cltv_expiry_delta(this_ptr, val);
// debug statements here
}
+ // struct LDKCOption_u64Z RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+ export function RouteHint_get_htlc_minimum_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_get_htlc_minimum_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function RouteHint_set_htlc_minimum_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_set_htlc_minimum_msat(this_ptr, val);
+ // debug statements here
+ }
+ // struct LDKCOption_u64Z RouteHint_get_htlc_maximum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+ export function RouteHint_get_htlc_maximum_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_get_htlc_maximum_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void RouteHint_set_htlc_maximum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function RouteHint_set_htlc_maximum_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_set_htlc_maximum_msat(this_ptr, val);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, struct LDKCOption_u64Z htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg);
+ export function RouteHint_new(src_node_id_arg: Uint8Array, short_channel_id_arg: number, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.RouteHint_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
+ return nativeResponseValue;
+ }
// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
export function RouteHint_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.RouteHint_clone(orig);
return nativeResponseValue;
}
- // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
- export function get_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
+ // struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKInvoiceFeatures payee_features, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
+ export function get_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, payee_features: number, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), first_hops, last_hops, final_value_msat, final_cltv, logger);
+ const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), payee_features, first_hops, last_hops, final_value_msat, final_cltv, logger);
return nativeResponseValue;
}
- // void NetworkGraph_free(struct LDKNetworkGraph this_ptr);
- export function NetworkGraph_free(this_ptr: number): void {
+ // void NetworkGraph_free(struct LDKNetworkGraph this_obj);
+ export function NetworkGraph_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetworkGraph_free(this_ptr);
+ const nativeResponseValue = wasm.NetworkGraph_free(this_obj);
// debug statements here
}
// struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig);
const nativeResponseValue = wasm.NetworkGraph_clone(orig);
return nativeResponseValue;
}
- // void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_ptr);
- export function LockedNetworkGraph_free(this_ptr: number): void {
+ // void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_obj);
+ export function LockedNetworkGraph_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.LockedNetworkGraph_free(this_ptr);
+ const nativeResponseValue = wasm.LockedNetworkGraph_free(this_obj);
// debug statements here
}
- // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_ptr);
- export function NetGraphMsgHandler_free(this_ptr: number): void {
+ // void NetGraphMsgHandler_free(struct LDKNetGraphMsgHandler this_obj);
+ export function NetGraphMsgHandler_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NetGraphMsgHandler_free(this_ptr);
+ const nativeResponseValue = wasm.NetGraphMsgHandler_free(this_obj);
// debug statements here
}
// MUST_USE_RES struct LDKNetGraphMsgHandler NetGraphMsgHandler_new(struct LDKThirtyTwoBytes genesis_hash, struct LDKAccess *chain_access, struct LDKLogger logger);
const nativeResponseValue = wasm.NetGraphMsgHandler_as_MessageSendEventsProvider(this_arg);
return nativeResponseValue;
}
- // void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_ptr);
- export function DirectionalChannelInfo_free(this_ptr: number): void {
+ // void DirectionalChannelInfo_free(struct LDKDirectionalChannelInfo this_obj);
+ export function DirectionalChannelInfo_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.DirectionalChannelInfo_free(this_ptr);
+ const nativeResponseValue = wasm.DirectionalChannelInfo_free(this_obj);
// debug statements here
}
// uint32_t DirectionalChannelInfo_get_last_update(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr, val);
// debug statements here
}
+ // struct LDKCOption_u64Z DirectionalChannelInfo_get_htlc_maximum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
+ export function DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr);
+ return nativeResponseValue;
+ }
+ // void DirectionalChannelInfo_set_htlc_maximum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr, val);
+ // debug statements here
+ }
// struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
export function DirectionalChannelInfo_get_fees(this_ptr: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DirectionalChannelInfo_set_last_update_message(this_ptr, val);
// debug statements here
}
+ // MUST_USE_RES struct LDKDirectionalChannelInfo DirectionalChannelInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
+ export function DirectionalChannelInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number, fees_arg: number, last_update_message_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
+ return nativeResponseValue;
+ }
// struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
export function DirectionalChannelInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.DirectionalChannelInfo_read(encodeArray(ser));
return nativeResponseValue;
}
- // void ChannelInfo_free(struct LDKChannelInfo this_ptr);
- export function ChannelInfo_free(this_ptr: number): void {
+ // void ChannelInfo_free(struct LDKChannelInfo this_obj);
+ export function ChannelInfo_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.ChannelInfo_free(this_ptr);
+ const nativeResponseValue = wasm.ChannelInfo_free(this_obj);
// debug statements here
}
// struct LDKChannelFeatures ChannelInfo_get_features(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.ChannelInfo_set_two_to_one(this_ptr, val);
// debug statements here
}
+ // struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+ export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelInfo_get_capacity_sats(this_ptr);
+ return nativeResponseValue;
+ }
+ // void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+ export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelInfo_set_capacity_sats(this_ptr, val);
+ // debug statements here
+ }
// struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
export function ChannelInfo_get_announcement_message(this_ptr: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelInfo_set_announcement_message(this_ptr, val);
// debug statements here
}
+ // MUST_USE_RES struct LDKChannelInfo ChannelInfo_new(struct LDKChannelFeatures features_arg, struct LDKPublicKey node_one_arg, struct LDKDirectionalChannelInfo one_to_two_arg, struct LDKPublicKey node_two_arg, struct LDKDirectionalChannelInfo two_to_one_arg, struct LDKCOption_u64Z capacity_sats_arg, struct LDKChannelAnnouncement announcement_message_arg);
+ export function ChannelInfo_new(features_arg: number, node_one_arg: Uint8Array, one_to_two_arg: number, node_two_arg: Uint8Array, two_to_one_arg: number, capacity_sats_arg: number, announcement_message_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.ChannelInfo_new(features_arg, encodeArray(node_one_arg), one_to_two_arg, encodeArray(node_two_arg), two_to_one_arg, capacity_sats_arg, announcement_message_arg);
+ return nativeResponseValue;
+ }
// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
export function ChannelInfo_clone(orig: number): number {
if(!isWasmInitialized) {
const nativeResponseValue = wasm.ChannelInfo_read(encodeArray(ser));
return nativeResponseValue;
}
- // void RoutingFees_free(struct LDKRoutingFees this_ptr);
- export function RoutingFees_free(this_ptr: number): void {
+ // void RoutingFees_free(struct LDKRoutingFees this_obj);
+ export function RoutingFees_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.RoutingFees_free(this_ptr);
+ const nativeResponseValue = wasm.RoutingFees_free(this_obj);
// debug statements here
}
// uint32_t RoutingFees_get_base_msat(const struct LDKRoutingFees *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.RoutingFees_write(obj);
return decodeArray(nativeResponseValue);
}
- // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_ptr);
- export function NodeAnnouncementInfo_free(this_ptr: number): void {
+ // void NodeAnnouncementInfo_free(struct LDKNodeAnnouncementInfo this_obj);
+ export function NodeAnnouncementInfo_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeAnnouncementInfo_free(this_ptr);
+ const nativeResponseValue = wasm.NodeAnnouncementInfo_free(this_obj);
// debug statements here
}
// struct LDKNodeFeatures NodeAnnouncementInfo_get_features(const struct LDKNodeAnnouncementInfo *NONNULL_PTR this_ptr);
const nativeResponseValue = wasm.NodeAnnouncementInfo_read(encodeArray(ser));
return nativeResponseValue;
}
- // void NodeInfo_free(struct LDKNodeInfo this_ptr);
- export function NodeInfo_free(this_ptr: number): void {
+ // void NodeInfo_free(struct LDKNodeInfo this_obj);
+ export function NodeInfo_free(this_obj: number): void {
if(!isWasmInitialized) {
throw new Error("initializeWasm() must be awaited first!");
}
- const nativeResponseValue = wasm.NodeInfo_free(this_ptr);
+ const nativeResponseValue = wasm.NodeInfo_free(this_obj);
// debug statements here
}
// void NodeInfo_set_channels(struct LDKNodeInfo *NONNULL_PTR this_ptr, struct LDKCVec_u64Z val);
const nativeResponseValue = wasm.NetworkGraph_update_channel_unsigned(this_arg, msg);
return nativeResponseValue;
}
+ // void FilesystemPersister_free(struct LDKFilesystemPersister this_obj);
+ export function FilesystemPersister_free(this_obj: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_free(this_obj);
+ // debug statements here
+ }
+ // MUST_USE_RES struct LDKFilesystemPersister FilesystemPersister_new(struct LDKCVec_u8Z path_to_channel_data);
+ export function FilesystemPersister_new(path_to_channel_data: Uint8Array): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_new(encodeArray(path_to_channel_data));
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCVec_u8Z FilesystemPersister_get_data_dir(const struct LDKFilesystemPersister *NONNULL_PTR this_arg);
+ export function FilesystemPersister_get_data_dir(this_arg: number): Uint8Array {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_get_data_dir(this_arg);
+ return decodeArray(nativeResponseValue);
+ }
+ // MUST_USE_RES struct LDKCResult_NoneErrorZ FilesystemPersister_persist_manager(struct LDKCVec_u8Z data_dir, const struct LDKChannelManager *NONNULL_PTR manager);
+ export function FilesystemPersister_persist_manager(data_dir: Uint8Array, manager: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_persist_manager(encodeArray(data_dir), manager);
+ return nativeResponseValue;
+ }
+ // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ FilesystemPersister_read_channelmonitors(const struct LDKFilesystemPersister *NONNULL_PTR this_arg, struct LDKKeysInterface keys_manager);
+ export function FilesystemPersister_read_channelmonitors(this_arg: number, keys_manager: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_read_channelmonitors(this_arg, keys_manager);
+ return nativeResponseValue;
+ }
+ // struct LDKPersist FilesystemPersister_as_Persist(const struct LDKFilesystemPersister *NONNULL_PTR this_arg);
+ export function FilesystemPersister_as_Persist(this_arg: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.FilesystemPersister_as_Persist(this_arg);
+ return nativeResponseValue;
+ }
export async function initializeWasm(allowDoubleInitialization: boolean = false): Promise<void> {
if(isWasmInitialized && !allowDoubleInitialization) {
projects / ldk-java / blobdiff