X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=ts%2Fbindings.ts;h=3a8bfbe90632e3ad68be620b0462efab08df1827;hb=7cede693022f65adf9b93bfda7a462481e30c1ef;hp=64cc2939a80b053d4921f1ee33180b523ac6b625;hpb=9e8763c71cd61d55be7c869d973524f75209a3f3;p=ldk-java diff --git a/ts/bindings.ts b/ts/bindings.ts index 64cc2939..3a8bfbe9 100644 --- a/ts/bindings.ts +++ b/ts/bindings.ts @@ -167,6 +167,19 @@ public static native long new_empty_slice_vec(); 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); @@ -191,39 +204,6 @@ public static native long new_empty_slice_vec(); 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_CVec_u8ZPeerHandleErrorZ_result_ok(long arg); - public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg); - public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg); - public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg); - public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg); - public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg); - 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_boolLightningErrorZ_result_ok(long arg); - public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg); - public static native number LDKCResult_boolLightningErrorZ_get_err(long arg); - public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c); - public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr); - public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr); - public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr); - public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems); - public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems); - public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg); - public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg); - public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg); public static class LDKErrorAction { private LDKErrorAction() {} export class DisconnectPeer extends LDKErrorAction { @@ -350,11 +330,65 @@ public static native long new_empty_slice_vec(); 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 LDKMessageSendEvent LDKMessageSendEvent_ref_from_ptr(long ptr); public static native long LDKCVec_MessageSendEventZ_new(number[] elems); + public static native boolean LDKCResult_boolLightningErrorZ_result_ok(long arg); + public static native boolean LDKCResult_boolLightningErrorZ_get_ok(long arg); + public static native number LDKCResult_boolLightningErrorZ_get_err(long arg); + public static native long LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(number a, number b, number c); + public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(long ptr); + public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(long ptr); + public static native number LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(long ptr); + public static native long LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(number[] elems); + public static native long LDKCVec_NodeAnnouncementZ_new(number[] elems); + public static native boolean LDKCResult_NoneLightningErrorZ_result_ok(long arg); + public static native void LDKCResult_NoneLightningErrorZ_get_ok(long arg); + public static native number LDKCResult_NoneLightningErrorZ_get_err(long arg); + public static native boolean LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(long arg); + public static native Uint8Array LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(long arg); + public static native number LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(long arg); + public static native boolean LDKCResult_NonePeerHandleErrorZ_result_ok(long arg); + public static native void LDKCResult_NonePeerHandleErrorZ_get_ok(long arg); + public static native number LDKCResult_NonePeerHandleErrorZ_get_err(long arg); + 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_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_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 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 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); @@ -410,10 +444,21 @@ public static native long new_empty_slice_vec(); 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 { + 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 native long LDKC2Tuple_u64u64Z_new(number a, number b); - public static native number LDKC2Tuple_u64u64Z_get_a(long ptr); - public static native number LDKC2Tuple_u64u64Z_get_b(long ptr); public static class LDKSpendableOutputDescriptor { private LDKSpendableOutputDescriptor() {} export class StaticOutput extends LDKSpendableOutputDescriptor { @@ -421,20 +466,13 @@ public static native long new_empty_slice_vec(); public number output; StaticOutput(number outpoint, number output) { this.outpoint = outpoint; this.output = output; } } - export class DynamicOutputP2WSH extends LDKSpendableOutputDescriptor { - public number outpoint; - public Uint8Array per_commitment_point; - public number to_self_delay; - public number output; - public number key_derivation_params; - public Uint8Array revocation_pubkey; - DynamicOutputP2WSH(number outpoint, Uint8Array per_commitment_point, number to_self_delay, number output, number key_derivation_params, Uint8Array revocation_pubkey) { this.outpoint = outpoint; this.per_commitment_point = per_commitment_point; this.to_self_delay = to_self_delay; this.output = output; this.key_derivation_params = key_derivation_params; this.revocation_pubkey = revocation_pubkey; } + export class DelayedPaymentOutput extends LDKSpendableOutputDescriptor { + public number delayed_payment_output; + DelayedPaymentOutput(number delayed_payment_output) { this.delayed_payment_output = delayed_payment_output; } } - export class StaticOutputCounterpartyPayment extends LDKSpendableOutputDescriptor { - public number outpoint; - public number output; - public number key_derivation_params; - StaticOutputCounterpartyPayment(number outpoint, number output, number key_derivation_params) { this.outpoint = outpoint; this.output = output; this.key_derivation_params = key_derivation_params; } + 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(); } @@ -498,6 +536,14 @@ public static native long new_empty_slice_vec(); 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 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); @@ -520,10 +566,10 @@ public static native long new_empty_slice_vec(); // OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START - export interface LDKChannelKeys { + export interface LDKSign { get_per_commitment_point (idx: number): Uint8Array; release_commitment_secret (idx: number): Uint8Array; - key_derivation_params (): number; + 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; @@ -534,107 +580,107 @@ public static native long new_empty_slice_vec(); write (): Uint8Array; } - export function LDKChannelKeys_new(impl: LDKChannelKeys, pubkeys: number): number { + export function LDKSign_new(impl: LDKSign, pubkeys: number): number { throw new Error('unimplemented'); // TODO: bind to WASM } // OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END - // LDKPublicKey ChannelKeys_get_per_commitment_point LDKChannelKeys* this_arg, uint64_t idx - export function ChannelKeys_get_per_commitment_point(this_arg: number, idx: number): Uint8Array { + // LDKPublicKey Sign_get_per_commitment_point LDKSign *NONNULL_PTR 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.ChannelKeys_get_per_commitment_point(this_arg, idx); + const nativeResponseValue = wasm.Sign_get_per_commitment_point(this_arg, idx); return decodeArray(nativeResponseValue); } - // LDKThirtyTwoBytes ChannelKeys_release_commitment_secret LDKChannelKeys* this_arg, uint64_t idx - export function ChannelKeys_release_commitment_secret(this_arg: number, idx: number): Uint8Array { + // LDKThirtyTwoBytes Sign_release_commitment_secret LDKSign *NONNULL_PTR 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.ChannelKeys_release_commitment_secret(this_arg, idx); + const nativeResponseValue = wasm.Sign_release_commitment_secret(this_arg, idx); return decodeArray(nativeResponseValue); } - // LDKC2Tuple_u64u64Z ChannelKeys_key_derivation_params LDKChannelKeys* this_arg - export function ChannelKeys_key_derivation_params(this_arg: number): number { + // LDKThirtyTwoBytes Sign_channel_keys_id LDKSign *NONNULL_PTR 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.ChannelKeys_key_derivation_params(this_arg); - return nativeResponseValue; + const nativeResponseValue = wasm.Sign_channel_keys_id(this_arg); + return decodeArray(nativeResponseValue); } - // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ChannelKeys_sign_counterparty_commitment LDKChannelKeys* this_arg, const struct LDKCommitmentTransaction *NONNULL_PTR commitment_tx - export function ChannelKeys_sign_counterparty_commitment(this_arg: number, commitment_tx: number): number { + // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_counterparty_commitment LDKSign *NONNULL_PTR 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.ChannelKeys_sign_counterparty_commitment(this_arg, commitment_tx); + const nativeResponseValue = wasm.Sign_sign_counterparty_commitment(this_arg, commitment_tx); return nativeResponseValue; } - // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ChannelKeys_sign_holder_commitment_and_htlcs LDKChannelKeys* this_arg, const struct LDKHolderCommitmentTransaction *NONNULL_PTR commitment_tx - export function ChannelKeys_sign_holder_commitment_and_htlcs(this_arg: number, commitment_tx: number): number { + // LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ Sign_sign_holder_commitment_and_htlcs LDKSign *NONNULL_PTR 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.ChannelKeys_sign_holder_commitment_and_htlcs(this_arg, commitment_tx); + const nativeResponseValue = wasm.Sign_sign_holder_commitment_and_htlcs(this_arg, commitment_tx); return nativeResponseValue; } - // LDKCResult_SignatureNoneZ ChannelKeys_sign_justice_transaction LDKChannelKeys* 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 ChannelKeys_sign_justice_transaction(this_arg: number, justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number { + // LDKCResult_SignatureNoneZ Sign_sign_justice_transaction LDKSign *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 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.ChannelKeys_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc); + const nativeResponseValue = wasm.Sign_sign_justice_transaction(this_arg, encodeArray(justice_tx), input, amount, encodeArray(per_commitment_key), htlc); return nativeResponseValue; } - // LDKCResult_SignatureNoneZ ChannelKeys_sign_counterparty_htlc_transaction LDKChannelKeys* 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 ChannelKeys_sign_counterparty_htlc_transaction(this_arg: number, htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number { + // LDKCResult_SignatureNoneZ Sign_sign_counterparty_htlc_transaction LDKSign *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 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.ChannelKeys_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc); + const nativeResponseValue = wasm.Sign_sign_counterparty_htlc_transaction(this_arg, encodeArray(htlc_tx), input, amount, encodeArray(per_commitment_point), htlc); return nativeResponseValue; } - // LDKCResult_SignatureNoneZ ChannelKeys_sign_closing_transaction LDKChannelKeys* this_arg, struct LDKTransaction closing_tx - export function ChannelKeys_sign_closing_transaction(this_arg: number, closing_tx: Uint8Array): number { + // LDKCResult_SignatureNoneZ Sign_sign_closing_transaction LDKSign *NONNULL_PTR 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.ChannelKeys_sign_closing_transaction(this_arg, encodeArray(closing_tx)); + const nativeResponseValue = wasm.Sign_sign_closing_transaction(this_arg, encodeArray(closing_tx)); return nativeResponseValue; } - // LDKCResult_SignatureNoneZ ChannelKeys_sign_channel_announcement LDKChannelKeys* this_arg, const struct LDKUnsignedChannelAnnouncement *NONNULL_PTR msg - export function ChannelKeys_sign_channel_announcement(this_arg: number, msg: number): number { + // LDKCResult_SignatureNoneZ Sign_sign_channel_announcement LDKSign *NONNULL_PTR 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.ChannelKeys_sign_channel_announcement(this_arg, msg); + const nativeResponseValue = wasm.Sign_sign_channel_announcement(this_arg, msg); return nativeResponseValue; } - // void ChannelKeys_ready_channel LDKChannelKeys* this_arg, const struct LDKChannelTransactionParameters *NONNULL_PTR channel_parameters - export function ChannelKeys_ready_channel(this_arg: number, channel_parameters: number): void { + // void Sign_ready_channel LDKSign *NONNULL_PTR 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.ChannelKeys_ready_channel(this_arg, channel_parameters); + const nativeResponseValue = wasm.Sign_ready_channel(this_arg, channel_parameters); // debug statements here } - // LDKCVec_u8Z ChannelKeys_write LDKChannelKeys* this_arg - export function ChannelKeys_write(this_arg: number): Uint8Array { + // 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.ChannelKeys_write(this_arg); + const nativeResponseValue = wasm.Sign_write(this_arg); return decodeArray(nativeResponseValue); } - // LDKChannelPublicKeys ChannelKeys_get_pubkeys LDKChannelKeys* this_arg - export function ChannelKeys_get_pubkeys(this_arg: number): number { + // LDKChannelPublicKeys Sign_get_pubkeys LDKSign *NONNULL_PTR this_arg + export function Sign_get_pubkeys(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.ChannelKeys_get_pubkeys(this_arg); + const nativeResponseValue = wasm.Sign_get_pubkeys(this_arg); return nativeResponseValue; } public static native long LDKC2Tuple_BlockHashChannelMonitorZ_new(Uint8Array a, number b); @@ -646,6 +692,19 @@ public static native long new_empty_slice_vec(); 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 class LDKAPIError { private LDKAPIError() {} export class APIMisuseError extends LDKAPIError { @@ -675,7 +734,31 @@ public static native long new_empty_slice_vec(); public static native boolean LDKCResult_NoneAPIErrorZ_result_ok(long arg); public static native void LDKCResult_NoneAPIErrorZ_get_ok(long arg); 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 { + public number parameter_error; + ParameterError(number parameter_error) { this.parameter_error = parameter_error; } + } + export class PathParameterError extends LDKPaymentSendFailure { + public number[] path_parameter_error; + PathParameterError(number[] path_parameter_error) { this.path_parameter_error = path_parameter_error; } + } + export class AllFailedRetrySafe extends LDKPaymentSendFailure { + 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 { + public number[] partial_failure; + PartialFailure(number[] partial_failure) { this.partial_failure = partial_failure; } + } + static native void init(); + } + static { LDKPaymentSendFailure.init(); } + public static native LDKPaymentSendFailure LDKPaymentSendFailure_ref_from_ptr(long ptr); public static native boolean LDKCResult_NonePaymentSendFailureZ_result_ok(long arg); public static native void LDKCResult_NonePaymentSendFailureZ_get_ok(long arg); public static native number LDKCResult_NonePaymentSendFailureZ_get_err(long arg); @@ -698,7 +781,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -706,7 +789,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -714,7 +797,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -738,7 +821,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -746,9 +829,9 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.BroadcasterInterface_broadcast_transaction(this_arg, encodeArray(tx)); // debug statements here } - public static native boolean LDKCResult_ChannelKeysDecodeErrorZ_result_ok(long arg); - public static native number LDKCResult_ChannelKeysDecodeErrorZ_get_ok(long arg); - public static native number LDKCResult_ChannelKeysDecodeErrorZ_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); @@ -758,7 +841,7 @@ public static native long new_empty_slice_vec(); get_node_secret (): Uint8Array; get_destination_script (): Uint8Array; get_shutdown_pubkey (): Uint8Array; - get_channel_keys (inbound: boolean, channel_value_satoshis: number): number; + get_channel_signer (inbound: boolean, channel_value_satoshis: number): number; get_secure_random_bytes (): Uint8Array; read_chan_signer (reader: Uint8Array): number; } @@ -770,7 +853,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -778,7 +861,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -786,7 +869,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -794,15 +877,15 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.KeysInterface_get_shutdown_pubkey(this_arg); return decodeArray(nativeResponseValue); } - // LDKChannelKeys KeysInterface_get_channel_keys LDKKeysInterface* this_arg, bool inbound, uint64_t channel_value_satoshis - export function KeysInterface_get_channel_keys(this_arg: number, inbound: boolean, channel_value_satoshis: number): number { + // 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_keys(this_arg, inbound, channel_value_satoshis); + 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!"); @@ -810,7 +893,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.KeysInterface_get_secure_random_bytes(this_arg); return decodeArray(nativeResponseValue); } - // LDKCResult_ChannelKeysDecodeErrorZ 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!"); @@ -834,7 +917,7 @@ public static native long new_empty_slice_vec(); // OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END - // uint32_t FeeEstimator_get_est_sat_per_1000_weight LDKFeeEstimator* this_arg, enum LDKConfirmationTarget confirmation_target + // 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!"); @@ -867,9 +950,16 @@ public static native long new_empty_slice_vec(); 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_InMemoryChannelKeysDecodeErrorZ_result_ok(long arg); - public static native number LDKCResult_InMemoryChannelKeysDecodeErrorZ_get_ok(long arg); - public static native number LDKCResult_InMemoryChannelKeysDecodeErrorZ_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); @@ -997,7 +1087,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1021,7 +1111,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1045,7 +1135,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1056,11 +1146,44 @@ public static native long new_empty_slice_vec(); +// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START + + export interface LDKListen { + block_connected (block: Uint8Array, height: number): void; + block_disconnected (header: Uint8Array, height: number): void; + } + + export function LDKListen_new(impl: LDKListen): number { + throw new Error('unimplemented'); // TODO: bind to WASM + } + +// OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: END + + + // 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 *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!"); + } + const nativeResponseValue = wasm.Listen_block_disconnected(this_arg, encodeArray(header), height); + // debug statements here + } + + + // OUT_TYPESCRIPT_BINDINGS :: MAP_TRAIT :: START 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 { @@ -1070,7 +1193,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1078,13 +1201,13 @@ public static native long new_empty_slice_vec(); 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; } @@ -1103,7 +1226,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1111,7 +1234,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1130,7 +1253,7 @@ public static native long new_empty_slice_vec(); handle_funding_created (their_node_id: Uint8Array, msg: number): void; handle_funding_signed (their_node_id: Uint8Array, msg: number): void; handle_funding_locked (their_node_id: Uint8Array, msg: number): void; - handle_shutdown (their_node_id: Uint8Array, msg: number): void; + handle_shutdown (their_node_id: Uint8Array, their_features: number, msg: number): void; handle_closing_signed (their_node_id: Uint8Array, msg: number): void; handle_update_add_htlc (their_node_id: Uint8Array, msg: number): void; handle_update_fulfill_htlc (their_node_id: Uint8Array, msg: number): void; @@ -1143,6 +1266,7 @@ public static native long new_empty_slice_vec(); 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; } @@ -1153,7 +1277,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1161,7 +1285,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1169,7 +1293,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1177,7 +1301,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1185,7 +1309,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1193,15 +1317,15 @@ public static native long new_empty_slice_vec(); 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 LDKShutdown *NONNULL_PTR msg - export function ChannelMessageHandler_handle_shutdown(this_arg: number, their_node_id: Uint8Array, msg: number): void { + // 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), msg); + 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!"); @@ -1209,7 +1333,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1217,7 +1341,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1225,7 +1349,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1233,7 +1357,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1241,7 +1365,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1249,7 +1373,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1257,7 +1381,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1265,7 +1389,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1273,7 +1397,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1281,7 +1405,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1289,7 +1413,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1297,7 +1421,15 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1331,7 +1463,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1339,7 +1471,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1347,7 +1479,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1355,7 +1487,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1363,7 +1495,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1371,7 +1503,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1379,7 +1511,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1387,7 +1519,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1395,7 +1527,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1403,7 +1535,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1411,7 +1543,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1438,7 +1570,7 @@ public static native long new_empty_slice_vec(); // 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!"); @@ -1446,7 +1578,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1454,7 +1586,7 @@ public static native long new_empty_slice_vec(); 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!"); @@ -1622,6 +1754,38 @@ public static native long new_empty_slice_vec(); 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) { @@ -1878,6 +2042,118 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_CVec_SignatureZNoneZ_clone(orig); return nativeResponseValue; } + // 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.CVec_MessageSendEventZ_free(_res); + // debug statements here + } + // 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_boolLightningErrorZ_ok(o); + return nativeResponseValue; + } + // 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_boolLightningErrorZ_err(e); + return nativeResponseValue; + } + // 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_boolLightningErrorZ_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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig); + return nativeResponseValue; + } + // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig); + return nativeResponseValue; + } + // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c); + return nativeResponseValue; + } + // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res); + // debug statements here + } + // 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.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res); + // debug statements here + } + // 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_NodeAnnouncementZ_free(_res); + // debug statements here + } + // 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_NoneLightningErrorZ_ok(); + return nativeResponseValue; + } + // 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_NoneLightningErrorZ_err(e); + 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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CResult_NoneLightningErrorZ_clone(orig); + return nativeResponseValue; + } // void CVec_PublicKeyZ_free(struct LDKCVec_PublicKeyZ _res); export function CVec_PublicKeyZ_free(_res: Uint8Array[]): void { if(!isWasmInitialized) { @@ -2062,150 +2338,94 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_free(_res); // debug statements here } - // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o); - export function CResult_ChannelConfigDecodeErrorZ_ok(o: 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_ChannelConfigDecodeErrorZ_ok(o); + const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_ok(o); return nativeResponseValue; } - // struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_err(struct LDKDecodeError e); - export function CResult_ChannelConfigDecodeErrorZ_err(e: number): number { + // 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.CResult_ChannelConfigDecodeErrorZ_err(e); + const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_err(e); return nativeResponseValue; } - // void CResult_ChannelConfigDecodeErrorZ_free(struct LDKCResult_ChannelConfigDecodeErrorZ _res); - export function CResult_ChannelConfigDecodeErrorZ_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.CResult_ChannelConfigDecodeErrorZ_free(_res); + const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_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_boolLightningErrorZ CResult_boolLightningErrorZ_ok(bool o); - export function CResult_boolLightningErrorZ_ok(o: boolean): number { + // 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_boolLightningErrorZ_ok(o); + const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_ok(o); return nativeResponseValue; } - // struct LDKCResult_boolLightningErrorZ CResult_boolLightningErrorZ_err(struct LDKLightningError e); - export function CResult_boolLightningErrorZ_err(e: number): number { + // 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_boolLightningErrorZ_err(e); + const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_err(e); return nativeResponseValue; } - // void CResult_boolLightningErrorZ_free(struct LDKCResult_boolLightningErrorZ _res); - export function CResult_boolLightningErrorZ_free(_res: number): void { + // 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_boolLightningErrorZ_free(_res); + const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_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 { - if(!isWasmInitialized) { - throw new Error("initializeWasm() must be awaited first!"); - } - const nativeResponseValue = wasm.CResult_boolLightningErrorZ_clone(orig); - return nativeResponseValue; - } - // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig); - return nativeResponseValue; - } - // 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 { + // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a, b, c); + const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig); return nativeResponseValue; } - // 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.C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res); - // debug statements here - } - // 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.CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res); - // debug statements here - } - // 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_NodeAnnouncementZ_free(_res); - // debug statements here - } - // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_ok(void); - export function CResult_NoneLightningErrorZ_ok(): 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_NoneLightningErrorZ_ok(); + const nativeResponseValue = wasm.COption_u64Z_some(o); return nativeResponseValue; } - // struct LDKCResult_NoneLightningErrorZ CResult_NoneLightningErrorZ_err(struct LDKLightningError e); - export function CResult_NoneLightningErrorZ_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_NoneLightningErrorZ_err(e); + const nativeResponseValue = wasm.COption_u64Z_none(); return nativeResponseValue; } - // void CResult_NoneLightningErrorZ_free(struct LDKCResult_NoneLightningErrorZ _res); - export function CResult_NoneLightningErrorZ_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_NoneLightningErrorZ_free(_res); + const nativeResponseValue = wasm.COption_u64Z_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 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_NoneLightningErrorZ_clone(orig); + const nativeResponseValue = wasm.COption_u64Z_clone(orig); return nativeResponseValue; } - // 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.CVec_MessageSendEventZ_free(_res); - // debug statements here - } // struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o); export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number { if(!isWasmInitialized) { @@ -2262,6 +2482,14 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CResult_ChannelInfoDecodeErrorZ_clone(orig); + return nativeResponseValue; + } // struct LDKCResult_RoutingFeesDecodeErrorZ CResult_RoutingFeesDecodeErrorZ_ok(struct LDKRoutingFees o); export function CResult_RoutingFeesDecodeErrorZ_ok(o: number): number { if(!isWasmInitialized) { @@ -2398,6 +2626,14 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CResult_NetworkGraphDecodeErrorZ_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 { if(!isWasmInitialized) { @@ -2622,6 +2858,62 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.C2Tuple_OutPointScriptZ_free(_res); // debug statements here } + // struct LDKC2Tuple_u32ScriptZ C2Tuple_u32ScriptZ_clone(const struct LDKC2Tuple_u32ScriptZ *NONNULL_PTR orig); + export function C2Tuple_u32ScriptZ_clone(orig: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.C2Tuple_u32ScriptZ_clone(orig); + return nativeResponseValue; + } + // 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.C2Tuple_u32ScriptZ_new(a, encodeArray(b)); + return nativeResponseValue; + } + // 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.C2Tuple_u32ScriptZ_free(_res); + // debug statements here + } + // 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.CVec_C2Tuple_u32ScriptZZ_free(_res); + // debug statements here + } + // 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.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(encodeArray(a), b); + return nativeResponseValue; + } + // 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.C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res); + // debug statements here + } + // 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.CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res); + // debug statements here + } // void CVec_TransactionZ_free(struct LDKCVec_TransactionZ _res); export function CVec_TransactionZ_free(_res: Uint8Array[]): void { if(!isWasmInitialized) { @@ -2766,6 +3058,30 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone(orig); return nativeResponseValue; } + // 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.COption_C2Tuple_usizeTransactionZZ_some(o); + return nativeResponseValue; + } + // 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.COption_C2Tuple_usizeTransactionZZ_none(); + return nativeResponseValue; + } + // 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.COption_C2Tuple_usizeTransactionZZ_free(_res); + // debug statements here + } // struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void); export function CResult_NoneAPIErrorZ_ok(): number { if(!isWasmInitialized) { @@ -2798,6 +3114,22 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_NoneAPIErrorZ_clone(orig); 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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CVec_APIErrorZ_free(_res); + // debug statements here + } // void CVec_ChannelDetailsZ_free(struct LDKCVec_ChannelDetailsZ _res); export function CVec_ChannelDetailsZ_free(_res: number[]): void { if(!isWasmInitialized) { @@ -2875,39 +3207,15 @@ public static native long new_empty_slice_vec(); 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 - } - // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_clone(const struct LDKC2Tuple_u64u64Z *NONNULL_PTR orig); - export function C2Tuple_u64u64Z_clone(orig: number): number { - if(!isWasmInitialized) { - throw new Error("initializeWasm() must be awaited first!"); - } - const nativeResponseValue = wasm.C2Tuple_u64u64Z_clone(orig); - return nativeResponseValue; - } - // struct LDKC2Tuple_u64u64Z C2Tuple_u64u64Z_new(uint64_t a, uint64_t b); - export function C2Tuple_u64u64Z_new(a: number, b: number): number { - if(!isWasmInitialized) { - throw new Error("initializeWasm() must be awaited first!"); - } - const nativeResponseValue = wasm.C2Tuple_u64u64Z_new(a, b); + const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e); return nativeResponseValue; } - // void C2Tuple_u64u64Z_free(struct LDKC2Tuple_u64u64Z _res); - export function C2Tuple_u64u64Z_free(_res: number): void { + // 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.C2Tuple_u64u64Z_free(_res); + const nativeResponseValue = wasm.CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res); // debug statements here } // struct LDKCResult_SpendableOutputDescriptorDecodeErrorZ CResult_SpendableOutputDescriptorDecodeErrorZ_ok(struct LDKSpendableOutputDescriptor o); @@ -3030,70 +3338,142 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.CResult_SignatureNoneZ_clone(orig); return nativeResponseValue; } - // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_ok(struct LDKChannelKeys o); - export function CResult_ChannelKeysDecodeErrorZ_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_SignDecodeErrorZ_ok(o); + return nativeResponseValue; + } + // 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_SignDecodeErrorZ_err(e); + return nativeResponseValue; + } + // 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_SignDecodeErrorZ_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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.CResult_SignDecodeErrorZ_clone(orig); + return nativeResponseValue; + } + // 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.CResult_ChannelKeysDecodeErrorZ_ok(o); + 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_CVec_CVec_u8ZZNoneZ_ok(o); return nativeResponseValue; } - // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_err(struct LDKDecodeError e); - export function CResult_ChannelKeysDecodeErrorZ_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_ChannelKeysDecodeErrorZ_err(e); + const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_err(); return nativeResponseValue; } - // void CResult_ChannelKeysDecodeErrorZ_free(struct LDKCResult_ChannelKeysDecodeErrorZ _res); - export function CResult_ChannelKeysDecodeErrorZ_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_ChannelKeysDecodeErrorZ_free(_res); + const nativeResponseValue = wasm.CResult_CVec_CVec_u8ZZNoneZ_free(_res); // debug statements here } - // struct LDKCResult_ChannelKeysDecodeErrorZ CResult_ChannelKeysDecodeErrorZ_clone(const struct LDKCResult_ChannelKeysDecodeErrorZ *NONNULL_PTR orig); - export function CResult_ChannelKeysDecodeErrorZ_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_CVec_CVec_u8ZZNoneZ_clone(orig); + return nativeResponseValue; + } + // 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_ChannelKeysDecodeErrorZ_clone(orig); + const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_ok(o); return nativeResponseValue; } - // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_ok(struct LDKInMemoryChannelKeys o); - export function CResult_InMemoryChannelKeysDecodeErrorZ_ok(o: 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_InMemoryChannelKeysDecodeErrorZ_ok(o); + const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_err(e); return nativeResponseValue; } - // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_err(struct LDKDecodeError e); - export function CResult_InMemoryChannelKeysDecodeErrorZ_err(e: number): number { + // 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_InMemorySignerDecodeErrorZ_free(_res); + // debug statements here + } + // 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_InMemoryChannelKeysDecodeErrorZ_err(e); + const nativeResponseValue = wasm.CResult_InMemorySignerDecodeErrorZ_clone(orig); return nativeResponseValue; } - // void CResult_InMemoryChannelKeysDecodeErrorZ_free(struct LDKCResult_InMemoryChannelKeysDecodeErrorZ _res); - export function CResult_InMemoryChannelKeysDecodeErrorZ_free(_res: number): void { + // 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_InMemoryChannelKeysDecodeErrorZ_free(_res); + const nativeResponseValue = wasm.CVec_TxOutZ_free(_res); // debug statements here } - // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ CResult_InMemoryChannelKeysDecodeErrorZ_clone(const struct LDKCResult_InMemoryChannelKeysDecodeErrorZ *NONNULL_PTR orig); - export function CResult_InMemoryChannelKeysDecodeErrorZ_clone(orig: 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_TransactionNoneZ_ok(encodeArray(o)); + return nativeResponseValue; + } + // 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_InMemoryChannelKeysDecodeErrorZ_clone(orig); + const nativeResponseValue = wasm.CResult_TransactionNoneZ_err(); return nativeResponseValue; } + // 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_TransactionNoneZ_free(_res); + // debug statements here + } // void CVec_RouteHopZ_free(struct LDKCVec_RouteHopZ _res); export function CVec_RouteHopZ_free(_res: number[]): void { if(!isWasmInitialized) { @@ -4366,12 +4746,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4446,12 +4826,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4638,12 +5018,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4662,6 +5042,22 @@ public static native long new_empty_slice_vec(); 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) { @@ -4694,12 +5090,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4734,12 +5130,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4830,6 +5226,14 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.Access_free(this_ptr); // debug statements here } + // void Listen_free(struct LDKListen this_ptr); + export function Listen_free(this_ptr: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.Listen_free(this_ptr); + // debug statements here + } // void Watch_free(struct LDKWatch this_ptr); export function Watch_free(this_ptr: number): void { if(!isWasmInitialized) { @@ -4846,6 +5250,70 @@ public static native long new_empty_slice_vec(); 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 + } + // 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.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 { if(!isWasmInitialized) { @@ -4870,12 +5338,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4918,12 +5386,12 @@ public static native long new_empty_slice_vec(); 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); @@ -4974,12 +5442,12 @@ public static native long new_empty_slice_vec(); 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); @@ -5006,12 +5474,12 @@ public static native long new_empty_slice_vec(); 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); @@ -5038,12 +5506,12 @@ public static native long new_empty_slice_vec(); 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); @@ -5062,7 +5530,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_write(obj); return decodeArray(nativeResponseValue); } - // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger); + // MUST_USE_RES struct LDKCResult_NoneMonitorUpdateErrorZ ChannelMonitor_update_monitor(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKChannelMonitorUpdate *NONNULL_PTR updates, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, const struct LDKLogger *NONNULL_PTR logger); export function ChannelMonitor_update_monitor(this_arg: number, updates: number, broadcaster: number, fee_estimator: number, logger: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); @@ -5086,7 +5554,23 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_get_funding_txo(this_arg); return nativeResponseValue; } - // MUST_USE_RES struct LDKCVec_MonitorEventZ ChannelMonitor_get_and_clear_pending_monitor_events(struct LDKChannelMonitor *NONNULL_PTR this_arg); + // 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) { throw new Error("initializeWasm() must be awaited first!"); @@ -5094,7 +5578,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_monitor_events(this_arg); return nativeResponseValue; } - // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(struct LDKChannelMonitor *NONNULL_PTR this_arg); + // MUST_USE_RES struct LDKCVec_EventZ ChannelMonitor_get_and_clear_pending_events(const struct LDKChannelMonitor *NONNULL_PTR this_arg); export function ChannelMonitor_get_and_clear_pending_events(this_arg: number): number[] { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); @@ -5102,7 +5586,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_get_and_clear_pending_events(this_arg); return nativeResponseValue; } - // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger); + // MUST_USE_RES struct LDKCVec_TransactionZ ChannelMonitor_get_latest_holder_commitment_txn(const struct LDKChannelMonitor *NONNULL_PTR this_arg, const struct LDKLogger *NONNULL_PTR logger); export function ChannelMonitor_get_latest_holder_commitment_txn(this_arg: number, logger: number): Uint8Array[] { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); @@ -5110,7 +5594,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_get_latest_holder_commitment_txn(this_arg, logger); return nativeResponseValue; } - // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(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); + // MUST_USE_RES struct LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ChannelMonitor_block_connected(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_block_connected(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!"); @@ -5118,7 +5602,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelMonitor_block_connected(this_arg, encodeArray(header), txdata, height, broadcaster, fee_estimator, logger); return nativeResponseValue; } - // void ChannelMonitor_block_disconnected(struct LDKChannelMonitor *NONNULL_PTR this_arg, const uint8_t (*header)[80], uint32_t height, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKLogger logger); + // void ChannelMonitor_block_disconnected(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_block_disconnected(this_arg: number, header: Uint8Array, height: number, broadcaster: number, fee_estimator: number, logger: number): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); @@ -5142,12 +5626,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -5190,36 +5674,244 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.OutPoint_new(encodeArray(txid_arg), index_arg); return nativeResponseValue; } - // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig); - export function OutPoint_clone(orig: number): number { + // struct LDKOutPoint OutPoint_clone(const struct LDKOutPoint *NONNULL_PTR orig); + export function OutPoint_clone(orig: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.OutPoint_clone(orig); + return nativeResponseValue; + } + // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg); + export function OutPoint_to_channel_id(this_arg: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.OutPoint_to_channel_id(this_arg); + return decodeArray(nativeResponseValue); + } + // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj); + export function OutPoint_write(obj: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.OutPoint_write(obj); + return decodeArray(nativeResponseValue); + } + // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser); + export function OutPoint_read(ser: Uint8Array): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.OutPoint_read(encodeArray(ser)); + return nativeResponseValue; + } + // 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_obj); + // debug statements here + } + // struct LDKOutPoint DelayedPaymentOutputDescriptor_get_outpoint(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function DelayedPaymentOutputDescriptor_get_outpoint(this_ptr: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_outpoint(this_ptr); + return nativeResponseValue; + } + // void DelayedPaymentOutputDescriptor_set_outpoint(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val); + export function DelayedPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_outpoint(this_ptr, val); + // debug statements here + } + // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_per_commitment_point(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_per_commitment_point(this_ptr); + return decodeArray(nativeResponseValue); + } + // void DelayedPaymentOutputDescriptor_set_per_commitment_point(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val); + export function DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr: number, val: Uint8Array): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_per_commitment_point(this_ptr, encodeArray(val)); + // debug statements here + } + // uint16_t DelayedPaymentOutputDescriptor_get_to_self_delay(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_to_self_delay(this_ptr); + return nativeResponseValue; + } + // void DelayedPaymentOutputDescriptor_set_to_self_delay(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint16_t val); + export function DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_to_self_delay(this_ptr, val); + // debug statements here + } + // void DelayedPaymentOutputDescriptor_set_output(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val); + export function DelayedPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_output(this_ptr, val); + // debug statements here + } + // struct LDKPublicKey DelayedPaymentOutputDescriptor_get_revocation_pubkey(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_revocation_pubkey(this_ptr); + return decodeArray(nativeResponseValue); + } + // void DelayedPaymentOutputDescriptor_set_revocation_pubkey(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val); + export function DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr: number, val: Uint8Array): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_revocation_pubkey(this_ptr, encodeArray(val)); + // debug statements here + } + // const uint8_t (*DelayedPaymentOutputDescriptor_get_channel_keys_id(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32]; + export function DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_channel_keys_id(this_ptr); + return decodeArray(nativeResponseValue); + } + // void DelayedPaymentOutputDescriptor_set_channel_keys_id(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val); + export function DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: Uint8Array): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_channel_keys_id(this_ptr, encodeArray(val)); + // debug statements here + } + // uint64_t DelayedPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr); + return nativeResponseValue; + } + // void DelayedPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val); + export function DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val); + // debug statements here + } + // MUST_USE_RES struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKPublicKey per_commitment_point_arg, uint16_t to_self_delay_arg, struct LDKTxOut output_arg, struct LDKPublicKey revocation_pubkey_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg); + export function DelayedPaymentOutputDescriptor_new(outpoint_arg: number, per_commitment_point_arg: Uint8Array, to_self_delay_arg: number, output_arg: number, revocation_pubkey_arg: Uint8Array, channel_keys_id_arg: Uint8Array, channel_value_satoshis_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_new(outpoint_arg, encodeArray(per_commitment_point_arg), to_self_delay_arg, output_arg, encodeArray(revocation_pubkey_arg), encodeArray(channel_keys_id_arg), channel_value_satoshis_arg); + return nativeResponseValue; + } + // struct LDKDelayedPaymentOutputDescriptor DelayedPaymentOutputDescriptor_clone(const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR orig); + export function DelayedPaymentOutputDescriptor_clone(orig: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.DelayedPaymentOutputDescriptor_clone(orig); + return nativeResponseValue; + } + // 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_obj); + // debug statements here + } + // struct LDKOutPoint StaticPaymentOutputDescriptor_get_outpoint(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function StaticPaymentOutputDescriptor_get_outpoint(this_ptr: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_outpoint(this_ptr); + return nativeResponseValue; + } + // void StaticPaymentOutputDescriptor_set_outpoint(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val); + export function StaticPaymentOutputDescriptor_set_outpoint(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_outpoint(this_ptr, val); + // debug statements here + } + // void StaticPaymentOutputDescriptor_set_output(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKTxOut val); + export function StaticPaymentOutputDescriptor_set_output(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_output(this_ptr, val); + // debug statements here + } + // const uint8_t (*StaticPaymentOutputDescriptor_get_channel_keys_id(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr))[32]; + export function StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_channel_keys_id(this_ptr); + return decodeArray(nativeResponseValue); + } + // void StaticPaymentOutputDescriptor_set_channel_keys_id(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val); + export function StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr: number, val: Uint8Array): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_channel_keys_id(this_ptr, encodeArray(val)); + // debug statements here + } + // uint64_t StaticPaymentOutputDescriptor_get_channel_value_satoshis(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr); + export function StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.OutPoint_clone(orig); + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_get_channel_value_satoshis(this_ptr); return nativeResponseValue; } - // MUST_USE_RES struct LDKThirtyTwoBytes OutPoint_to_channel_id(const struct LDKOutPoint *NONNULL_PTR this_arg); - export function OutPoint_to_channel_id(this_arg: number): Uint8Array { + // void StaticPaymentOutputDescriptor_set_channel_value_satoshis(struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR this_ptr, uint64_t val); + export function StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr: number, val: number): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.OutPoint_to_channel_id(this_arg); - return decodeArray(nativeResponseValue); + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_set_channel_value_satoshis(this_ptr, val); + // debug statements here } - // struct LDKCVec_u8Z OutPoint_write(const struct LDKOutPoint *NONNULL_PTR obj); - export function OutPoint_write(obj: number): Uint8Array { + // MUST_USE_RES struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, struct LDKThirtyTwoBytes channel_keys_id_arg, uint64_t channel_value_satoshis_arg); + export function StaticPaymentOutputDescriptor_new(outpoint_arg: number, output_arg: number, channel_keys_id_arg: Uint8Array, channel_value_satoshis_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.OutPoint_write(obj); - return decodeArray(nativeResponseValue); + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_new(outpoint_arg, output_arg, encodeArray(channel_keys_id_arg), channel_value_satoshis_arg); + return nativeResponseValue; } - // struct LDKCResult_OutPointDecodeErrorZ OutPoint_read(struct LDKu8slice ser); - export function OutPoint_read(ser: Uint8Array): number { + // struct LDKStaticPaymentOutputDescriptor StaticPaymentOutputDescriptor_clone(const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR orig); + export function StaticPaymentOutputDescriptor_clone(orig: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.OutPoint_read(encodeArray(ser)); + const nativeResponseValue = wasm.StaticPaymentOutputDescriptor_clone(orig); return nativeResponseValue; } // void SpendableOutputDescriptor_free(struct LDKSpendableOutputDescriptor this_ptr); @@ -5254,20 +5946,20 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.SpendableOutputDescriptor_read(encodeArray(ser)); return nativeResponseValue; } - // struct LDKChannelKeys ChannelKeys_clone(const struct LDKChannelKeys *NONNULL_PTR orig); - export function ChannelKeys_clone(orig: number): number { + // struct LDKSign Sign_clone(const struct LDKSign *NONNULL_PTR orig); + export function Sign_clone(orig: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.ChannelKeys_clone(orig); + const nativeResponseValue = wasm.Sign_clone(orig); return nativeResponseValue; } - // void ChannelKeys_free(struct LDKChannelKeys this_ptr); - export function ChannelKeys_free(this_ptr: number): void { + // void Sign_free(struct LDKSign this_ptr); + export function Sign_free(this_ptr: number): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.ChannelKeys_free(this_ptr); + const nativeResponseValue = wasm.Sign_free(this_ptr); // debug statements here } // void KeysInterface_free(struct LDKKeysInterface this_ptr); @@ -5278,220 +5970,244 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.KeysInterface_free(this_ptr); // debug statements here } - // void InMemoryChannelKeys_free(struct LDKInMemoryChannelKeys this_ptr); - export function InMemoryChannelKeys_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.InMemoryChannelKeys_free(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_free(this_obj); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_funding_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_funding_key(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_funding_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_funding_key(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_funding_key(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_funding_key(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_funding_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val); - export function InMemoryChannelKeys_set_funding_key(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_funding_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val); + export function InMemorySigner_set_funding_key(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_funding_key(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_funding_key(this_ptr, encodeArray(val)); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_revocation_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_revocation_base_key(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_revocation_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_revocation_base_key(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_revocation_base_key(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_revocation_base_key(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_revocation_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val); - export function InMemoryChannelKeys_set_revocation_base_key(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_revocation_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val); + export function InMemorySigner_set_revocation_base_key(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_revocation_base_key(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_revocation_base_key(this_ptr, encodeArray(val)); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_payment_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_payment_key(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_payment_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_payment_key(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_payment_key(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_payment_key(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_payment_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val); - export function InMemoryChannelKeys_set_payment_key(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_payment_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val); + export function InMemorySigner_set_payment_key(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_payment_key(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_payment_key(this_ptr, encodeArray(val)); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_delayed_payment_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_delayed_payment_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_delayed_payment_base_key(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_delayed_payment_base_key(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_delayed_payment_base_key(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_delayed_payment_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val); - export function InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_delayed_payment_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val); + export function InMemorySigner_set_delayed_payment_base_key(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_delayed_payment_base_key(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_delayed_payment_base_key(this_ptr, encodeArray(val)); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_htlc_base_key(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_htlc_base_key(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_htlc_base_key(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_htlc_base_key(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_htlc_base_key(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_htlc_base_key(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_htlc_base_key(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKSecretKey val); - export function InMemoryChannelKeys_set_htlc_base_key(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_htlc_base_key(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKSecretKey val); + export function InMemorySigner_set_htlc_base_key(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_htlc_base_key(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_htlc_base_key(this_ptr, encodeArray(val)); // debug statements here } - // const uint8_t (*InMemoryChannelKeys_get_commitment_seed(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr))[32]; - export function InMemoryChannelKeys_get_commitment_seed(this_ptr: number): Uint8Array { + // const uint8_t (*InMemorySigner_get_commitment_seed(const struct LDKInMemorySigner *NONNULL_PTR this_ptr))[32]; + export function InMemorySigner_get_commitment_seed(this_ptr: number): Uint8Array { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_commitment_seed(this_ptr); + const nativeResponseValue = wasm.InMemorySigner_get_commitment_seed(this_ptr); return decodeArray(nativeResponseValue); } - // void InMemoryChannelKeys_set_commitment_seed(struct LDKInMemoryChannelKeys *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val); - export function InMemoryChannelKeys_set_commitment_seed(this_ptr: number, val: Uint8Array): void { + // void InMemorySigner_set_commitment_seed(struct LDKInMemorySigner *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val); + export function InMemorySigner_set_commitment_seed(this_ptr: number, val: Uint8Array): void { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_set_commitment_seed(this_ptr, encodeArray(val)); + const nativeResponseValue = wasm.InMemorySigner_set_commitment_seed(this_ptr, encodeArray(val)); // debug statements here } - // struct LDKInMemoryChannelKeys InMemoryChannelKeys_clone(const struct LDKInMemoryChannelKeys *NONNULL_PTR orig); - export function InMemoryChannelKeys_clone(orig: number): number { + // struct LDKInMemorySigner InMemorySigner_clone(const struct LDKInMemorySigner *NONNULL_PTR orig); + export function InMemorySigner_clone(orig: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_clone(orig); + const nativeResponseValue = wasm.InMemorySigner_clone(orig); return nativeResponseValue; } - // MUST_USE_RES struct LDKInMemoryChannelKeys InMemoryChannelKeys_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKC2Tuple_u64u64Z key_derivation_params); - export function InMemoryChannelKeys_new(funding_key: Uint8Array, revocation_base_key: Uint8Array, payment_key: Uint8Array, delayed_payment_base_key: Uint8Array, htlc_base_key: Uint8Array, commitment_seed: Uint8Array, channel_value_satoshis: number, key_derivation_params: number): number { + // MUST_USE_RES struct LDKInMemorySigner InMemorySigner_new(struct LDKSecretKey funding_key, struct LDKSecretKey revocation_base_key, struct LDKSecretKey payment_key, struct LDKSecretKey delayed_payment_base_key, struct LDKSecretKey htlc_base_key, struct LDKThirtyTwoBytes commitment_seed, uint64_t channel_value_satoshis, struct LDKThirtyTwoBytes channel_keys_id); + export function InMemorySigner_new(funding_key: Uint8Array, revocation_base_key: Uint8Array, payment_key: Uint8Array, delayed_payment_base_key: Uint8Array, htlc_base_key: Uint8Array, commitment_seed: Uint8Array, channel_value_satoshis: number, channel_keys_id: Uint8Array): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_new(encodeArray(funding_key), encodeArray(revocation_base_key), encodeArray(payment_key), encodeArray(delayed_payment_base_key), encodeArray(htlc_base_key), encodeArray(commitment_seed), channel_value_satoshis, key_derivation_params); + const nativeResponseValue = wasm.InMemorySigner_new(encodeArray(funding_key), encodeArray(revocation_base_key), encodeArray(payment_key), encodeArray(delayed_payment_base_key), encodeArray(htlc_base_key), encodeArray(commitment_seed), channel_value_satoshis, encodeArray(channel_keys_id)); return nativeResponseValue; } - // MUST_USE_RES struct LDKChannelPublicKeys InMemoryChannelKeys_counterparty_pubkeys(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_counterparty_pubkeys(this_arg: number): number { + // MUST_USE_RES struct LDKChannelPublicKeys InMemorySigner_counterparty_pubkeys(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_counterparty_pubkeys(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_counterparty_pubkeys(this_arg); + const nativeResponseValue = wasm.InMemorySigner_counterparty_pubkeys(this_arg); return nativeResponseValue; } - // MUST_USE_RES uint16_t InMemoryChannelKeys_counterparty_selected_contest_delay(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_counterparty_selected_contest_delay(this_arg: number): number { + // MUST_USE_RES uint16_t InMemorySigner_counterparty_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_counterparty_selected_contest_delay(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_counterparty_selected_contest_delay(this_arg); + const nativeResponseValue = wasm.InMemorySigner_counterparty_selected_contest_delay(this_arg); return nativeResponseValue; } - // MUST_USE_RES uint16_t InMemoryChannelKeys_holder_selected_contest_delay(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_holder_selected_contest_delay(this_arg: number): number { + // MUST_USE_RES uint16_t InMemorySigner_holder_selected_contest_delay(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_holder_selected_contest_delay(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_holder_selected_contest_delay(this_arg); + const nativeResponseValue = wasm.InMemorySigner_holder_selected_contest_delay(this_arg); return nativeResponseValue; } - // MUST_USE_RES bool InMemoryChannelKeys_is_outbound(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_is_outbound(this_arg: number): boolean { + // MUST_USE_RES bool InMemorySigner_is_outbound(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_is_outbound(this_arg: number): boolean { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_is_outbound(this_arg); + const nativeResponseValue = wasm.InMemorySigner_is_outbound(this_arg); return nativeResponseValue; } - // MUST_USE_RES struct LDKOutPoint InMemoryChannelKeys_funding_outpoint(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_funding_outpoint(this_arg: number): number { + // MUST_USE_RES struct LDKOutPoint InMemorySigner_funding_outpoint(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_funding_outpoint(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_funding_outpoint(this_arg); + const nativeResponseValue = wasm.InMemorySigner_funding_outpoint(this_arg); return nativeResponseValue; } - // MUST_USE_RES struct LDKChannelTransactionParameters InMemoryChannelKeys_get_channel_parameters(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_get_channel_parameters(this_arg: number): number { + // MUST_USE_RES struct LDKChannelTransactionParameters InMemorySigner_get_channel_parameters(const struct LDKInMemorySigner *NONNULL_PTR this_arg); + export function InMemorySigner_get_channel_parameters(this_arg: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_get_channel_parameters(this_arg); + const nativeResponseValue = wasm.InMemorySigner_get_channel_parameters(this_arg); return nativeResponseValue; } - // struct LDKChannelKeys InMemoryChannelKeys_as_ChannelKeys(const struct LDKInMemoryChannelKeys *NONNULL_PTR this_arg); - export function InMemoryChannelKeys_as_ChannelKeys(this_arg: number): number { + // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_counterparty_payment_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKStaticPaymentOutputDescriptor *NONNULL_PTR descriptor); + export function InMemorySigner_sign_counterparty_payment_input(this_arg: number, spend_tx: Uint8Array, input_idx: number, descriptor: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_as_ChannelKeys(this_arg); + const nativeResponseValue = wasm.InMemorySigner_sign_counterparty_payment_input(this_arg, encodeArray(spend_tx), input_idx, descriptor); return nativeResponseValue; } - // struct LDKCVec_u8Z InMemoryChannelKeys_write(const struct LDKInMemoryChannelKeys *NONNULL_PTR obj); - export function InMemoryChannelKeys_write(obj: number): Uint8Array { + // MUST_USE_RES struct LDKCResult_CVec_CVec_u8ZZNoneZ InMemorySigner_sign_dynamic_p2wsh_input(const struct LDKInMemorySigner *NONNULL_PTR this_arg, struct LDKTransaction spend_tx, uintptr_t input_idx, const struct LDKDelayedPaymentOutputDescriptor *NONNULL_PTR descriptor); + export function InMemorySigner_sign_dynamic_p2wsh_input(this_arg: number, spend_tx: Uint8Array, input_idx: number, descriptor: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_write(obj); + const nativeResponseValue = wasm.InMemorySigner_sign_dynamic_p2wsh_input(this_arg, encodeArray(spend_tx), input_idx, descriptor); + 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) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.InMemorySigner_as_Sign(this_arg); + return nativeResponseValue; + } + // struct LDKCVec_u8Z InMemorySigner_write(const struct LDKInMemorySigner *NONNULL_PTR obj); + export function InMemorySigner_write(obj: number): Uint8Array { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.InMemorySigner_write(obj); return decodeArray(nativeResponseValue); } - // struct LDKCResult_InMemoryChannelKeysDecodeErrorZ InMemoryChannelKeys_read(struct LDKu8slice ser); - export function InMemoryChannelKeys_read(ser: Uint8Array): number { + // struct LDKCResult_InMemorySignerDecodeErrorZ InMemorySigner_read(struct LDKu8slice ser); + export function InMemorySigner_read(ser: Uint8Array): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.InMemoryChannelKeys_read(encodeArray(ser)); + 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], enum LDKNetwork network, uint64_t starting_time_secs, uint32_t starting_time_nanos); - export function KeysManager_new(seed: Uint8Array, network: LDKNetwork, starting_time_secs: number, starting_time_nanos: number): number { + // MUST_USE_RES struct LDKKeysManager KeysManager_new(const uint8_t (*seed)[32], uint64_t starting_time_secs, uint32_t starting_time_nanos); + export function KeysManager_new(seed: Uint8Array, starting_time_secs: number, starting_time_nanos: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.KeysManager_new(encodeArray(seed), starting_time_secs, starting_time_nanos); + return nativeResponseValue; + } + // MUST_USE_RES struct LDKInMemorySigner KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, const uint8_t (*params)[32]); + export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: number, params: Uint8Array): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.KeysManager_new(encodeArray(seed), network, starting_time_secs, starting_time_nanos); + const nativeResponseValue = wasm.KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, encodeArray(params)); return nativeResponseValue; } - // MUST_USE_RES struct LDKInMemoryChannelKeys KeysManager_derive_channel_keys(const struct LDKKeysManager *NONNULL_PTR this_arg, uint64_t channel_value_satoshis, uint64_t params_1, uint64_t params_2); - export function KeysManager_derive_channel_keys(this_arg: number, channel_value_satoshis: number, params_1: number, params_2: number): number { + // MUST_USE_RES struct LDKCResult_TransactionNoneZ KeysManager_spend_spendable_outputs(const struct LDKKeysManager *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ descriptors, struct LDKCVec_TxOutZ outputs, struct LDKCVec_u8Z change_destination_script, uint32_t feerate_sat_per_1000_weight); + export function KeysManager_spend_spendable_outputs(this_arg: number, descriptors: number[], outputs: number[], change_destination_script: Uint8Array, feerate_sat_per_1000_weight: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.KeysManager_derive_channel_keys(this_arg, channel_value_satoshis, params_1, params_2); + const nativeResponseValue = wasm.KeysManager_spend_spendable_outputs(this_arg, descriptors, outputs, encodeArray(change_destination_script), feerate_sat_per_1000_weight); return nativeResponseValue; } // struct LDKKeysInterface KeysManager_as_KeysInterface(const struct LDKKeysManager *NONNULL_PTR this_arg); @@ -5502,20 +6218,84 @@ public static native long new_empty_slice_vec(); 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_obj); + // debug statements here + } + // 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_obj); + // debug statements here + } + // enum LDKNetwork ChainParameters_get_network(const struct LDKChainParameters *NONNULL_PTR this_ptr); + export function ChainParameters_get_network(this_ptr: number): LDKNetwork { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChainParameters_get_network(this_ptr); + return nativeResponseValue; + } + // void ChainParameters_set_network(struct LDKChainParameters *NONNULL_PTR this_ptr, enum LDKNetwork val); + export function ChainParameters_set_network(this_ptr: number, val: LDKNetwork): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + 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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChainParameters_get_latest_hash(this_ptr); + return decodeArray(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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChainParameters_set_latest_hash(this_ptr, encodeArray(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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChainParameters_get_latest_height(this_ptr); + 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 { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.ChannelManager_free(this_ptr); + const nativeResponseValue = wasm.ChainParameters_set_latest_height(this_ptr, val); // debug statements here } - // void ChannelDetails_free(struct LDKChannelDetails this_ptr); - export function ChannelDetails_free(this_ptr: number): void { + // 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 { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChainParameters_new(network_arg, encodeArray(latest_hash_arg), latest_height_arg); + return nativeResponseValue; + } + // 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]; @@ -5534,6 +6314,22 @@ public static native long new_empty_slice_vec(); 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) { @@ -5670,12 +6466,12 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.PaymentSendFailure_clone(orig); return nativeResponseValue; } - // MUST_USE_RES struct LDKChannelManager ChannelManager_new(enum LDKNetwork network, struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, uintptr_t current_blockchain_height); - export function ChannelManager_new(network: LDKNetwork, fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, current_blockchain_height: number): number { + // MUST_USE_RES struct LDKChannelManager ChannelManager_new(struct LDKFeeEstimator fee_est, struct LDKWatch chain_monitor, struct LDKBroadcasterInterface tx_broadcaster, struct LDKLogger logger, struct LDKKeysInterface keys_manager, struct LDKUserConfig config, struct LDKChainParameters params); + export function ChannelManager_new(fee_est: number, chain_monitor: number, tx_broadcaster: number, logger: number, keys_manager: number, config: number, params: number): number { if(!isWasmInitialized) { throw new Error("initializeWasm() must be awaited first!"); } - const nativeResponseValue = wasm.ChannelManager_new(network, fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, current_blockchain_height); + const nativeResponseValue = wasm.ChannelManager_new(fee_est, chain_monitor, tx_broadcaster, logger, keys_manager, config, params); 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); @@ -5814,6 +6610,14 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelManager_as_EventsProvider(this_arg); return nativeResponseValue; } + // struct LDKListen ChannelManager_as_Listen(const struct LDKChannelManager *NONNULL_PTR this_arg); + export function ChannelManager_as_Listen(this_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + 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 { if(!isWasmInitialized) { @@ -5830,6 +6634,22 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.ChannelManager_block_disconnected(this_arg, encodeArray(header)); // 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) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChannelManager_await_persistable_update(this_arg); + // debug statements here + } // struct LDKChannelMessageHandler ChannelManager_as_ChannelMessageHandler(const struct LDKChannelManager *NONNULL_PTR this_arg); export function ChannelManager_as_ChannelMessageHandler(this_arg: number): number { if(!isWasmInitialized) { @@ -5846,12 +6666,12 @@ public static native long new_empty_slice_vec(); 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); @@ -5966,12 +6786,12 @@ public static native long new_empty_slice_vec(); 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); @@ -5982,14 +6802,38 @@ public static native long new_empty_slice_vec(); 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); + export function Init_get_features(this_ptr: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.Init_get_features(this_ptr); + return nativeResponseValue; + } + // void Init_set_features(struct LDKInit *NONNULL_PTR this_ptr, struct LDKInitFeatures val); + export function Init_set_features(this_ptr: number, val: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.Init_set_features(this_ptr, val); + // debug statements here + } + // MUST_USE_RES struct LDKInit Init_new(struct LDKInitFeatures features_arg); + export function Init_new(features_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.Init_new(features_arg); + return nativeResponseValue; + } // struct LDKInit Init_clone(const struct LDKInit *NONNULL_PTR orig); export function Init_clone(orig: number): number { if(!isWasmInitialized) { @@ -5998,12 +6842,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6054,12 +6898,12 @@ public static native long new_empty_slice_vec(); 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); @@ -6110,12 +6954,12 @@ public static native long new_empty_slice_vec(); 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); @@ -6150,12 +6994,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6454,12 +7298,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6694,12 +7538,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6782,12 +7626,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6838,12 +7682,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6894,12 +7738,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -6950,12 +7794,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7022,12 +7866,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7118,12 +7962,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7190,12 +8034,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7238,12 +8082,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7302,12 +8146,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7366,12 +8210,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7438,12 +8282,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7494,12 +8338,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7550,12 +8394,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7614,12 +8458,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -7734,12 +8578,12 @@ public static native long new_empty_slice_vec(); 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); @@ -7838,12 +8682,12 @@ public static native long new_empty_slice_vec(); 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); @@ -7894,12 +8738,12 @@ public static native long new_empty_slice_vec(); 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); @@ -8022,12 +8866,12 @@ public static native long new_empty_slice_vec(); 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); @@ -8126,12 +8970,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8270,12 +9114,12 @@ public static native long new_empty_slice_vec(); 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); @@ -8326,12 +9170,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8398,12 +9242,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8494,12 +9338,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8542,12 +9386,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8598,12 +9442,12 @@ public static native long new_empty_slice_vec(); 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]; @@ -8686,12 +9530,12 @@ public static native long new_empty_slice_vec(); 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); @@ -8742,12 +9586,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9310,6 +10154,14 @@ public static native long new_empty_slice_vec(); 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) { @@ -9358,12 +10210,76 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.GossipTimestampFilter_write(obj); return decodeArray(nativeResponseValue); } - // void MessageHandler_free(struct LDKMessageHandler this_ptr); - export function MessageHandler_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_obj); + // debug statements here + } + // MUST_USE_RES struct LDKIgnoringMessageHandler IgnoringMessageHandler_new(void); + export function IgnoringMessageHandler_new(): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.IgnoringMessageHandler_new(); + return nativeResponseValue; + } + // struct LDKMessageSendEventsProvider IgnoringMessageHandler_as_MessageSendEventsProvider(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg); + export function IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.IgnoringMessageHandler_as_MessageSendEventsProvider(this_arg); + return nativeResponseValue; + } + // struct LDKRoutingMessageHandler IgnoringMessageHandler_as_RoutingMessageHandler(const struct LDKIgnoringMessageHandler *NONNULL_PTR this_arg); + export function IgnoringMessageHandler_as_RoutingMessageHandler(this_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.IgnoringMessageHandler_as_RoutingMessageHandler(this_arg); + return nativeResponseValue; + } + // 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_obj); + // debug statements here + } + // MUST_USE_RES struct LDKErroringMessageHandler ErroringMessageHandler_new(void); + export function ErroringMessageHandler_new(): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ErroringMessageHandler_new(); + return nativeResponseValue; + } + // struct LDKMessageSendEventsProvider ErroringMessageHandler_as_MessageSendEventsProvider(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg); + export function ErroringMessageHandler_as_MessageSendEventsProvider(this_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ErroringMessageHandler_as_MessageSendEventsProvider(this_arg); + return nativeResponseValue; + } + // struct LDKChannelMessageHandler ErroringMessageHandler_as_ChannelMessageHandler(const struct LDKErroringMessageHandler *NONNULL_PTR this_arg); + export function ErroringMessageHandler_as_ChannelMessageHandler(this_arg: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ErroringMessageHandler_as_ChannelMessageHandler(this_arg); + return nativeResponseValue; + } + // 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); @@ -9422,12 +10338,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9462,12 +10378,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9542,12 +10458,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9590,12 +10506,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9710,12 +10626,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9854,12 +10770,12 @@ public static native long new_empty_slice_vec(); 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); @@ -9926,6 +10842,30 @@ public static native long new_empty_slice_vec(); 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) { @@ -9974,12 +10914,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10078,12 +11018,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10190,12 +11130,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10238,12 +11178,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10302,12 +11242,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10390,12 +11330,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10470,12 +11410,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10542,28 +11482,44 @@ public static native long new_empty_slice_vec(); 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_ptr); + const nativeResponseValue = wasm.InitFeatures_free(this_obj); // debug statements here } - // void NodeFeatures_free(struct LDKNodeFeatures this_ptr); - export function NodeFeatures_free(this_ptr: number): void { + // 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.NodeFeatures_free(this_ptr); + const nativeResponseValue = wasm.NodeFeatures_free(this_obj); // debug statements here } - // void ChannelFeatures_free(struct LDKChannelFeatures this_ptr); - export function ChannelFeatures_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.ChannelFeatures_free(this_ptr); + const nativeResponseValue = wasm.ChannelFeatures_free(this_obj); + // debug statements here + } + // 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.InvoiceFeatures_free(this_obj); // debug statements here } // MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void); @@ -10614,6 +11570,22 @@ public static native long new_empty_slice_vec(); 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) { @@ -10638,6 +11610,14 @@ public static native long new_empty_slice_vec(); 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) { @@ -10662,12 +11642,20 @@ public static native long new_empty_slice_vec(); 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); @@ -10782,12 +11770,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10830,12 +11818,12 @@ public static native long new_empty_slice_vec(); 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); @@ -10902,7 +11890,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.RouteHint_set_cltv_expiry_delta(this_ptr, val); // debug statements here } - // uint64_t RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr); + // 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!"); @@ -10910,7 +11898,7 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.RouteHint_get_htlc_minimum_msat(this_ptr); return nativeResponseValue; } - // void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, uint64_t val); + // 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!"); @@ -10918,12 +11906,28 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.RouteHint_set_htlc_minimum_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, uint64_t htlc_minimum_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): number { + // 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); + 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); @@ -10934,36 +11938,44 @@ public static native long new_empty_slice_vec(); 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 target, 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, target: 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(target), 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 } - // void LockedNetworkGraph_free(struct LDKLockedNetworkGraph this_ptr); - export function LockedNetworkGraph_free(this_ptr: number): void { + // struct LDKNetworkGraph NetworkGraph_clone(const struct LDKNetworkGraph *NONNULL_PTR orig); + export function NetworkGraph_clone(orig: number): number { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.NetworkGraph_clone(orig); + return nativeResponseValue; + } + // 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); @@ -10982,6 +11994,14 @@ public static native long new_empty_slice_vec(); const nativeResponseValue = wasm.NetGraphMsgHandler_from_net_graph(chain_access, logger, network_graph); return nativeResponseValue; } + // void NetGraphMsgHandler_add_chain_access(struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg, struct LDKAccess *chain_access); + export function NetGraphMsgHandler_add_chain_access(this_arg: number, chain_access: number): void { + if(!isWasmInitialized) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.NetGraphMsgHandler_add_chain_access(this_arg, chain_access); + // debug statements here + } // MUST_USE_RES struct LDKLockedNetworkGraph NetGraphMsgHandler_read_locked_graph(const struct LDKNetGraphMsgHandler *NONNULL_PTR this_arg); export function NetGraphMsgHandler_read_locked_graph(this_arg: number): number { if(!isWasmInitialized) { @@ -11014,12 +12034,12 @@ public static native long new_empty_slice_vec(); 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); @@ -11086,6 +12106,22 @@ public static native long new_empty_slice_vec(); 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) { @@ -11118,6 +12154,14 @@ public static native long new_empty_slice_vec(); 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) { @@ -11142,12 +12186,12 @@ public static native long new_empty_slice_vec(); 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); @@ -11230,6 +12274,22 @@ public static native long new_empty_slice_vec(); 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) { @@ -11246,6 +12306,22 @@ public static native long new_empty_slice_vec(); 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) { + throw new Error("initializeWasm() must be awaited first!"); + } + const nativeResponseValue = wasm.ChannelInfo_clone(orig); + return nativeResponseValue; + } // struct LDKCVec_u8Z ChannelInfo_write(const struct LDKChannelInfo *NONNULL_PTR obj); export function ChannelInfo_write(obj: number): Uint8Array { if(!isWasmInitialized) { @@ -11262,12 +12338,12 @@ public static native long new_empty_slice_vec(); 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); @@ -11334,12 +12410,12 @@ public static native long new_empty_slice_vec(); 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); @@ -11462,12 +12538,12 @@ public static native long new_empty_slice_vec(); 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);