+ const nativeResponseValue = wasm.TS_EventHandler_free(this_ptr);
+ // debug statements here
+}
+ // void ChannelDerivationParameters_free(struct LDKChannelDerivationParameters this_obj);
+/* @internal */
+export function ChannelDerivationParameters_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_free(this_obj);
+ // debug statements here
+}
+ // uint64_t ChannelDerivationParameters_get_value_satoshis(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelDerivationParameters_get_value_satoshis(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_value_satoshis(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelDerivationParameters_set_value_satoshis(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function ChannelDerivationParameters_set_value_satoshis(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_value_satoshis(this_ptr, val);
+ // debug statements here
+}
+ // const uint8_t (*ChannelDerivationParameters_get_keys_id(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr))[32];
+/* @internal */
+export function ChannelDerivationParameters_get_keys_id(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_keys_id(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelDerivationParameters_set_keys_id(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+/* @internal */
+export function ChannelDerivationParameters_set_keys_id(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_keys_id(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKChannelTransactionParameters ChannelDerivationParameters_get_transaction_parameters(const struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr);
+/* @internal */
+export function ChannelDerivationParameters_get_transaction_parameters(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_get_transaction_parameters(this_ptr);
+ return nativeResponseValue;
+}
+ // void ChannelDerivationParameters_set_transaction_parameters(struct LDKChannelDerivationParameters *NONNULL_PTR this_ptr, struct LDKChannelTransactionParameters val);
+/* @internal */
+export function ChannelDerivationParameters_set_transaction_parameters(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_set_transaction_parameters(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKChannelDerivationParameters ChannelDerivationParameters_new(uint64_t value_satoshis_arg, struct LDKThirtyTwoBytes keys_id_arg, struct LDKChannelTransactionParameters transaction_parameters_arg);
+/* @internal */
+export function ChannelDerivationParameters_new(value_satoshis_arg: bigint, keys_id_arg: number, transaction_parameters_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg, transaction_parameters_arg);
+ return nativeResponseValue;
+}
+ // uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg);
+/* @internal */
+export function ChannelDerivationParameters_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKChannelDerivationParameters ChannelDerivationParameters_clone(const struct LDKChannelDerivationParameters *NONNULL_PTR orig);
+/* @internal */
+export function ChannelDerivationParameters_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_clone(orig);
+ return nativeResponseValue;
+}
+ // bool ChannelDerivationParameters_eq(const struct LDKChannelDerivationParameters *NONNULL_PTR a, const struct LDKChannelDerivationParameters *NONNULL_PTR b);
+/* @internal */
+export function ChannelDerivationParameters_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z ChannelDerivationParameters_write(const struct LDKChannelDerivationParameters *NONNULL_PTR obj);
+/* @internal */
+export function ChannelDerivationParameters_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ChannelDerivationParametersDecodeErrorZ ChannelDerivationParameters_read(struct LDKu8slice ser);
+/* @internal */
+export function ChannelDerivationParameters_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ChannelDerivationParameters_read(ser);
+ return nativeResponseValue;
+}
+ // void AnchorDescriptor_free(struct LDKAnchorDescriptor this_obj);
+/* @internal */
+export function AnchorDescriptor_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_free(this_obj);
+ // debug statements here
+}
+ // struct LDKChannelDerivationParameters AnchorDescriptor_get_channel_derivation_parameters(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function AnchorDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_get_channel_derivation_parameters(this_ptr);
+ return nativeResponseValue;
+}
+ // void AnchorDescriptor_set_channel_derivation_parameters(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
+/* @internal */
+export function AnchorDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_set_channel_derivation_parameters(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKOutPoint AnchorDescriptor_get_outpoint(const struct LDKAnchorDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function AnchorDescriptor_get_outpoint(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_get_outpoint(this_ptr);
+ return nativeResponseValue;
+}
+ // void AnchorDescriptor_set_outpoint(struct LDKAnchorDescriptor *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+/* @internal */
+export function AnchorDescriptor_set_outpoint(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_set_outpoint(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKAnchorDescriptor AnchorDescriptor_new(struct LDKChannelDerivationParameters channel_derivation_parameters_arg, struct LDKOutPoint outpoint_arg);
+/* @internal */
+export function AnchorDescriptor_new(channel_derivation_parameters_arg: bigint, outpoint_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_new(channel_derivation_parameters_arg, outpoint_arg);
+ return nativeResponseValue;
+}
+ // uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg);
+/* @internal */
+export function AnchorDescriptor_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKAnchorDescriptor AnchorDescriptor_clone(const struct LDKAnchorDescriptor *NONNULL_PTR orig);
+/* @internal */
+export function AnchorDescriptor_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_clone(orig);
+ return nativeResponseValue;
+}
+ // bool AnchorDescriptor_eq(const struct LDKAnchorDescriptor *NONNULL_PTR a, const struct LDKAnchorDescriptor *NONNULL_PTR b);
+/* @internal */
+export function AnchorDescriptor_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTxOut AnchorDescriptor_previous_utxo(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function AnchorDescriptor_previous_utxo(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_previous_utxo(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTxIn AnchorDescriptor_unsigned_tx_input(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function AnchorDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_unsigned_tx_input(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_u8Z AnchorDescriptor_witness_script(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function AnchorDescriptor_witness_script(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_witness_script(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKWitness AnchorDescriptor_tx_input_witness(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature);
+/* @internal */
+export function AnchorDescriptor_tx_input_witness(this_arg: bigint, signature: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_tx_input_witness(this_arg, signature);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner AnchorDescriptor_derive_channel_signer(const struct LDKAnchorDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
+/* @internal */
+export function AnchorDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_AnchorDescriptor_derive_channel_signer(this_arg, signer_provider);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_free(struct LDKHTLCDescriptor this_obj);
+/* @internal */
+export function HTLCDescriptor_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_free(this_obj);
+ // debug statements here
+}
+ // struct LDKChannelDerivationParameters HTLCDescriptor_get_channel_derivation_parameters(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_channel_derivation_parameters(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_channel_derivation_parameters(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_channel_derivation_parameters(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKChannelDerivationParameters val);
+/* @internal */
+export function HTLCDescriptor_set_channel_derivation_parameters(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_channel_derivation_parameters(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t HTLCDescriptor_get_per_commitment_number(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_per_commitment_number(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_number(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_per_commitment_number(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function HTLCDescriptor_set_per_commitment_number(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_number(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKPublicKey HTLCDescriptor_get_per_commitment_point(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_per_commitment_point(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_per_commitment_point(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_per_commitment_point(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function HTLCDescriptor_set_per_commitment_point(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_per_commitment_point(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKHTLCOutputInCommitment HTLCDescriptor_get_htlc(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_htlc(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_htlc(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_htlc(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKHTLCOutputInCommitment val);
+/* @internal */
+export function HTLCDescriptor_set_htlc(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_htlc(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_ThirtyTwoBytesZ HTLCDescriptor_get_preimage(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_preimage(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_preimage(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_preimage(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKCOption_ThirtyTwoBytesZ val);
+/* @internal */
+export function HTLCDescriptor_set_preimage(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_preimage(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKECDSASignature HTLCDescriptor_get_counterparty_sig(const struct LDKHTLCDescriptor *NONNULL_PTR this_ptr);
+/* @internal */
+export function HTLCDescriptor_get_counterparty_sig(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_get_counterparty_sig(this_ptr);
+ return nativeResponseValue;
+}
+ // void HTLCDescriptor_set_counterparty_sig(struct LDKHTLCDescriptor *NONNULL_PTR this_ptr, struct LDKECDSASignature val);
+/* @internal */
+export function HTLCDescriptor_set_counterparty_sig(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_set_counterparty_sig(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg);
+/* @internal */
+export function HTLCDescriptor_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKHTLCDescriptor HTLCDescriptor_clone(const struct LDKHTLCDescriptor *NONNULL_PTR orig);
+/* @internal */
+export function HTLCDescriptor_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_clone(orig);
+ return nativeResponseValue;
+}
+ // bool HTLCDescriptor_eq(const struct LDKHTLCDescriptor *NONNULL_PTR a, const struct LDKHTLCDescriptor *NONNULL_PTR b);
+/* @internal */
+export function HTLCDescriptor_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z HTLCDescriptor_write(const struct LDKHTLCDescriptor *NONNULL_PTR obj);
+/* @internal */
+export function HTLCDescriptor_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HTLCDescriptorDecodeErrorZ HTLCDescriptor_read(struct LDKu8slice ser);
+/* @internal */
+export function HTLCDescriptor_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_read(ser);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOutPoint HTLCDescriptor_outpoint(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function HTLCDescriptor_outpoint(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_outpoint(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTxOut HTLCDescriptor_previous_utxo(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function HTLCDescriptor_previous_utxo(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_previous_utxo(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTxIn HTLCDescriptor_unsigned_tx_input(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function HTLCDescriptor_unsigned_tx_input(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_unsigned_tx_input(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTxOut HTLCDescriptor_tx_output(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function HTLCDescriptor_tx_output(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_output(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_u8Z HTLCDescriptor_witness_script(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg);
+/* @internal */
+export function HTLCDescriptor_witness_script(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_witness_script(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKWitness HTLCDescriptor_tx_input_witness(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, struct LDKECDSASignature signature, struct LDKu8slice witness_script);
+/* @internal */
+export function HTLCDescriptor_tx_input_witness(this_arg: bigint, signature: number, witness_script: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_tx_input_witness(this_arg, signature, witness_script);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKWriteableEcdsaChannelSigner HTLCDescriptor_derive_channel_signer(const struct LDKHTLCDescriptor *NONNULL_PTR this_arg, const struct LDKSignerProvider *NONNULL_PTR signer_provider);
+/* @internal */
+export function HTLCDescriptor_derive_channel_signer(this_arg: bigint, signer_provider: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_HTLCDescriptor_derive_channel_signer(this_arg, signer_provider);
+ return nativeResponseValue;
+}
+ // void BumpTransactionEvent_free(struct LDKBumpTransactionEvent this_ptr);
+/* @internal */
+export function BumpTransactionEvent_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg);
+/* @internal */
+export function BumpTransactionEvent_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBumpTransactionEvent BumpTransactionEvent_clone(const struct LDKBumpTransactionEvent *NONNULL_PTR orig);
+/* @internal */
+export function BumpTransactionEvent_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKBumpTransactionEvent BumpTransactionEvent_channel_close(struct LDKThirtyTwoBytes claim_id, uint32_t package_target_feerate_sat_per_1000_weight, struct LDKTransaction commitment_tx, uint64_t commitment_tx_fee_satoshis, struct LDKAnchorDescriptor anchor_descriptor, struct LDKCVec_HTLCOutputInCommitmentZ pending_htlcs);
+/* @internal */
+export function BumpTransactionEvent_channel_close(claim_id: number, package_target_feerate_sat_per_1000_weight: number, commitment_tx: number, commitment_tx_fee_satoshis: bigint, anchor_descriptor: bigint, pending_htlcs: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_channel_close(claim_id, package_target_feerate_sat_per_1000_weight, commitment_tx, commitment_tx_fee_satoshis, anchor_descriptor, pending_htlcs);
+ return nativeResponseValue;
+}
+ // struct LDKBumpTransactionEvent BumpTransactionEvent_htlcresolution(struct LDKThirtyTwoBytes claim_id, uint32_t target_feerate_sat_per_1000_weight, struct LDKCVec_HTLCDescriptorZ htlc_descriptors, uint32_t tx_lock_time);
+/* @internal */
+export function BumpTransactionEvent_htlcresolution(claim_id: number, target_feerate_sat_per_1000_weight: number, htlc_descriptors: number, tx_lock_time: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_htlcresolution(claim_id, target_feerate_sat_per_1000_weight, htlc_descriptors, tx_lock_time);
+ return nativeResponseValue;
+}
+ // bool BumpTransactionEvent_eq(const struct LDKBumpTransactionEvent *NONNULL_PTR a, const struct LDKBumpTransactionEvent *NONNULL_PTR b);
+/* @internal */
+export function BumpTransactionEvent_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEvent_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Input_free(struct LDKInput this_obj);
+/* @internal */
+export function Input_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_free(this_obj);
+ // debug statements here
+}
+ // struct LDKOutPoint Input_get_outpoint(const struct LDKInput *NONNULL_PTR this_ptr);
+/* @internal */
+export function Input_get_outpoint(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_get_outpoint(this_ptr);
+ return nativeResponseValue;
+}
+ // void Input_set_outpoint(struct LDKInput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+/* @internal */
+export function Input_set_outpoint(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_set_outpoint(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKTxOut Input_get_previous_utxo(const struct LDKInput *NONNULL_PTR this_ptr);
+/* @internal */
+export function Input_get_previous_utxo(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_get_previous_utxo(this_ptr);
+ return nativeResponseValue;
+}
+ // void Input_set_previous_utxo(struct LDKInput *NONNULL_PTR this_ptr, struct LDKTxOut val);
+/* @internal */
+export function Input_set_previous_utxo(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_set_previous_utxo(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t Input_get_satisfaction_weight(const struct LDKInput *NONNULL_PTR this_ptr);
+/* @internal */
+export function Input_get_satisfaction_weight(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_get_satisfaction_weight(this_ptr);
+ return nativeResponseValue;
+}
+ // void Input_set_satisfaction_weight(struct LDKInput *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function Input_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_set_satisfaction_weight(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKInput Input_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut previous_utxo_arg, uint64_t satisfaction_weight_arg);
+/* @internal */
+export function Input_new(outpoint_arg: bigint, previous_utxo_arg: bigint, satisfaction_weight_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_new(outpoint_arg, previous_utxo_arg, satisfaction_weight_arg);
+ return nativeResponseValue;
+}
+ // uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg);
+/* @internal */
+export function Input_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKInput Input_clone(const struct LDKInput *NONNULL_PTR orig);
+/* @internal */
+export function Input_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Input_hash(const struct LDKInput *NONNULL_PTR o);
+/* @internal */
+export function Input_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_hash(o);
+ return nativeResponseValue;
+}
+ // bool Input_eq(const struct LDKInput *NONNULL_PTR a, const struct LDKInput *NONNULL_PTR b);
+/* @internal */
+export function Input_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Input_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Utxo_free(struct LDKUtxo this_obj);
+/* @internal */
+export function Utxo_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_free(this_obj);
+ // debug statements here
+}
+ // struct LDKOutPoint Utxo_get_outpoint(const struct LDKUtxo *NONNULL_PTR this_ptr);
+/* @internal */
+export function Utxo_get_outpoint(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_get_outpoint(this_ptr);
+ return nativeResponseValue;
+}
+ // void Utxo_set_outpoint(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+/* @internal */
+export function Utxo_set_outpoint(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_set_outpoint(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKTxOut Utxo_get_output(const struct LDKUtxo *NONNULL_PTR this_ptr);
+/* @internal */
+export function Utxo_get_output(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_get_output(this_ptr);
+ return nativeResponseValue;
+}
+ // void Utxo_set_output(struct LDKUtxo *NONNULL_PTR this_ptr, struct LDKTxOut val);
+/* @internal */
+export function Utxo_set_output(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_set_output(this_ptr, val);
+ // debug statements here
+}
+ // uint64_t Utxo_get_satisfaction_weight(const struct LDKUtxo *NONNULL_PTR this_ptr);
+/* @internal */
+export function Utxo_get_satisfaction_weight(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_get_satisfaction_weight(this_ptr);
+ return nativeResponseValue;
+}
+ // void Utxo_set_satisfaction_weight(struct LDKUtxo *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function Utxo_set_satisfaction_weight(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_set_satisfaction_weight(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKUtxo Utxo_new(struct LDKOutPoint outpoint_arg, struct LDKTxOut output_arg, uint64_t satisfaction_weight_arg);
+/* @internal */
+export function Utxo_new(outpoint_arg: bigint, output_arg: bigint, satisfaction_weight_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_new(outpoint_arg, output_arg, satisfaction_weight_arg);
+ return nativeResponseValue;
+}
+ // uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg);
+/* @internal */
+export function Utxo_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUtxo Utxo_clone(const struct LDKUtxo *NONNULL_PTR orig);
+/* @internal */
+export function Utxo_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Utxo_hash(const struct LDKUtxo *NONNULL_PTR o);
+/* @internal */
+export function Utxo_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_hash(o);
+ return nativeResponseValue;
+}
+ // bool Utxo_eq(const struct LDKUtxo *NONNULL_PTR a, const struct LDKUtxo *NONNULL_PTR b);
+/* @internal */
+export function Utxo_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKUtxo Utxo_new_p2pkh(struct LDKOutPoint outpoint, uint64_t value, const uint8_t (*pubkey_hash)[20]);
+/* @internal */
+export function Utxo_new_p2pkh(outpoint: bigint, value: bigint, pubkey_hash: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Utxo_new_p2pkh(outpoint, value, pubkey_hash);
+ return nativeResponseValue;
+}
+ // void CoinSelection_free(struct LDKCoinSelection this_obj);
+/* @internal */
+export function CoinSelection_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_free(this_obj);
+ // debug statements here
+}
+ // struct LDKCVec_UtxoZ CoinSelection_get_confirmed_utxos(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
+/* @internal */
+export function CoinSelection_get_confirmed_utxos(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_get_confirmed_utxos(this_ptr);
+ return nativeResponseValue;
+}
+ // void CoinSelection_set_confirmed_utxos(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCVec_UtxoZ val);
+/* @internal */
+export function CoinSelection_set_confirmed_utxos(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_set_confirmed_utxos(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKCOption_TxOutZ CoinSelection_get_change_output(const struct LDKCoinSelection *NONNULL_PTR this_ptr);
+/* @internal */
+export function CoinSelection_get_change_output(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_get_change_output(this_ptr);
+ return nativeResponseValue;
+}
+ // void CoinSelection_set_change_output(struct LDKCoinSelection *NONNULL_PTR this_ptr, struct LDKCOption_TxOutZ val);
+/* @internal */
+export function CoinSelection_set_change_output(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_set_change_output(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCoinSelection CoinSelection_new(struct LDKCVec_UtxoZ confirmed_utxos_arg, struct LDKCOption_TxOutZ change_output_arg);
+/* @internal */
+export function CoinSelection_new(confirmed_utxos_arg: number, change_output_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_new(confirmed_utxos_arg, change_output_arg);
+ return nativeResponseValue;
+}
+ // uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg);
+/* @internal */
+export function CoinSelection_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCoinSelection CoinSelection_clone(const struct LDKCoinSelection *NONNULL_PTR orig);
+/* @internal */
+export function CoinSelection_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelection_clone(orig);
+ return nativeResponseValue;
+}
+ // void CoinSelectionSource_free(struct LDKCoinSelectionSource this_ptr);
+/* @internal */
+export function CoinSelectionSource_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CoinSelectionSource_free(this_ptr);
+ // debug statements here
+}
+ // void WalletSource_free(struct LDKWalletSource this_ptr);
+/* @internal */
+export function WalletSource_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_WalletSource_free(this_ptr);
+ // debug statements here
+}
+ // void Wallet_free(struct LDKWallet this_obj);
+/* @internal */
+export function Wallet_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Wallet_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKWallet Wallet_new(struct LDKWalletSource source, struct LDKLogger logger);
+/* @internal */
+export function Wallet_new(source: bigint, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Wallet_new(source, logger);
+ return nativeResponseValue;
+}
+ // struct LDKCoinSelectionSource Wallet_as_CoinSelectionSource(const struct LDKWallet *NONNULL_PTR this_arg);
+/* @internal */
+export function Wallet_as_CoinSelectionSource(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Wallet_as_CoinSelectionSource(this_arg);
+ return nativeResponseValue;
+}
+ // void BumpTransactionEventHandler_free(struct LDKBumpTransactionEventHandler this_obj);
+/* @internal */
+export function BumpTransactionEventHandler_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKBumpTransactionEventHandler BumpTransactionEventHandler_new(struct LDKBroadcasterInterface broadcaster, struct LDKCoinSelectionSource utxo_source, struct LDKSignerProvider signer_provider, struct LDKLogger logger);
+/* @internal */
+export function BumpTransactionEventHandler_new(broadcaster: bigint, utxo_source: bigint, signer_provider: bigint, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_new(broadcaster, utxo_source, signer_provider, logger);
+ return nativeResponseValue;
+}
+ // void BumpTransactionEventHandler_handle_event(const struct LDKBumpTransactionEventHandler *NONNULL_PTR this_arg, const struct LDKBumpTransactionEvent *NONNULL_PTR event);
+/* @internal */
+export function BumpTransactionEventHandler_handle_event(this_arg: bigint, event: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BumpTransactionEventHandler_handle_event(this_arg, event);
+ // debug statements here
+}
+ // void GossipSync_free(struct LDKGossipSync this_ptr);
+/* @internal */
+export function GossipSync_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GossipSync_free(this_ptr);
+ // debug statements here
+}
+ // struct LDKGossipSync GossipSync_p2_p(const struct LDKP2PGossipSync *NONNULL_PTR a);
+/* @internal */
+export function GossipSync_p2_p(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GossipSync_p2_p(a);
+ return nativeResponseValue;
+}
+ // struct LDKGossipSync GossipSync_rapid(const struct LDKRapidGossipSync *NONNULL_PTR a);
+/* @internal */
+export function GossipSync_rapid(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GossipSync_rapid(a);
+ return nativeResponseValue;
+}
+ // struct LDKGossipSync GossipSync_none(void);
+/* @internal */
+export function GossipSync_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GossipSync_none();
+ return nativeResponseValue;
+}
+ // void RapidGossipSync_free(struct LDKRapidGossipSync this_obj);
+/* @internal */
+export function RapidGossipSync_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RapidGossipSync_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKRapidGossipSync RapidGossipSync_new(const struct LDKNetworkGraph *NONNULL_PTR network_graph, struct LDKLogger logger);
+/* @internal */
+export function RapidGossipSync_new(network_graph: bigint, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RapidGossipSync_new(network_graph, logger);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_u32GraphSyncErrorZ RapidGossipSync_update_network_graph_no_std(const struct LDKRapidGossipSync *NONNULL_PTR this_arg, struct LDKu8slice update_data, struct LDKCOption_u64Z current_time_unix);
+/* @internal */
+export function RapidGossipSync_update_network_graph_no_std(this_arg: bigint, update_data: number, current_time_unix: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RapidGossipSync_update_network_graph_no_std(this_arg, update_data, current_time_unix);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool RapidGossipSync_is_initial_sync_complete(const struct LDKRapidGossipSync *NONNULL_PTR this_arg);
+/* @internal */
+export function RapidGossipSync_is_initial_sync_complete(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RapidGossipSync_is_initial_sync_complete(this_arg);
+ return nativeResponseValue;
+}
+ // void GraphSyncError_free(struct LDKGraphSyncError this_ptr);
+/* @internal */
+export function GraphSyncError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GraphSyncError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg);
+/* @internal */
+export function GraphSyncError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GraphSyncError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKGraphSyncError GraphSyncError_clone(const struct LDKGraphSyncError *NONNULL_PTR orig);
+/* @internal */
+export function GraphSyncError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GraphSyncError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKGraphSyncError GraphSyncError_decode_error(struct LDKDecodeError a);
+/* @internal */
+export function GraphSyncError_decode_error(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GraphSyncError_decode_error(a);
+ return nativeResponseValue;
+}
+ // struct LDKGraphSyncError GraphSyncError_lightning_error(struct LDKLightningError a);
+/* @internal */
+export function GraphSyncError_lightning_error(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_GraphSyncError_lightning_error(a);
+ return nativeResponseValue;
+}
+ // void Bolt11ParseError_free(struct LDKBolt11ParseError this_ptr);
+/* @internal */
+export function Bolt11ParseError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg);
+/* @internal */
+export function Bolt11ParseError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_clone(const struct LDKBolt11ParseError *NONNULL_PTR orig);
+/* @internal */
+export function Bolt11ParseError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_bech32_error(struct LDKBech32Error a);
+/* @internal */
+export function Bolt11ParseError_bech32_error(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_bech32_error(a);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_parse_amount_error(struct LDKError a);
+/* @internal */
+export function Bolt11ParseError_parse_amount_error(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_parse_amount_error(a);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_malformed_signature(enum LDKSecp256k1Error a);
+/* @internal */
+export function Bolt11ParseError_malformed_signature(a: Secp256k1Error): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_signature(a);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_bad_prefix(void);
+/* @internal */
+export function Bolt11ParseError_bad_prefix(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_bad_prefix();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_unknown_currency(void);
+/* @internal */
+export function Bolt11ParseError_unknown_currency(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_currency();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_unknown_si_prefix(void);
+/* @internal */
+export function Bolt11ParseError_unknown_si_prefix(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_unknown_si_prefix();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_malformed_hrp(void);
+/* @internal */
+export function Bolt11ParseError_malformed_hrp(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_malformed_hrp();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_too_short_data_part(void);
+/* @internal */
+export function Bolt11ParseError_too_short_data_part(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_too_short_data_part();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_unexpected_end_of_tagged_fields(void);
+/* @internal */
+export function Bolt11ParseError_unexpected_end_of_tagged_fields(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_unexpected_end_of_tagged_fields();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_description_decode_error(struct LDKError a);
+/* @internal */
+export function Bolt11ParseError_description_decode_error(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_description_decode_error(a);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_padding_error(void);
+/* @internal */
+export function Bolt11ParseError_padding_error(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_padding_error();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_integer_overflow_error(void);
+/* @internal */
+export function Bolt11ParseError_integer_overflow_error(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_integer_overflow_error();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_invalid_seg_wit_program_length(void);
+/* @internal */
+export function Bolt11ParseError_invalid_seg_wit_program_length(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_seg_wit_program_length();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_invalid_pub_key_hash_length(void);
+/* @internal */
+export function Bolt11ParseError_invalid_pub_key_hash_length(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_pub_key_hash_length();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_invalid_script_hash_length(void);
+/* @internal */
+export function Bolt11ParseError_invalid_script_hash_length(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_script_hash_length();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_invalid_recovery_id(void);
+/* @internal */
+export function Bolt11ParseError_invalid_recovery_id(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_recovery_id();
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_invalid_slice_length(struct LDKStr a);
+/* @internal */
+export function Bolt11ParseError_invalid_slice_length(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_invalid_slice_length(a);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11ParseError Bolt11ParseError_skip(void);
+/* @internal */
+export function Bolt11ParseError_skip(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_skip();
+ return nativeResponseValue;
+}
+ // bool Bolt11ParseError_eq(const struct LDKBolt11ParseError *NONNULL_PTR a, const struct LDKBolt11ParseError *NONNULL_PTR b);
+/* @internal */
+export function Bolt11ParseError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_eq(a, b);
+ return nativeResponseValue;
+}
+ // void ParseOrSemanticError_free(struct LDKParseOrSemanticError this_ptr);
+/* @internal */
+export function ParseOrSemanticError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg);
+/* @internal */
+export function ParseOrSemanticError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKParseOrSemanticError ParseOrSemanticError_clone(const struct LDKParseOrSemanticError *NONNULL_PTR orig);
+/* @internal */
+export function ParseOrSemanticError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKParseOrSemanticError ParseOrSemanticError_parse_error(struct LDKBolt11ParseError a);
+/* @internal */
+export function ParseOrSemanticError_parse_error(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_parse_error(a);
+ return nativeResponseValue;
+}
+ // struct LDKParseOrSemanticError ParseOrSemanticError_semantic_error(enum LDKBolt11SemanticError a);
+/* @internal */
+export function ParseOrSemanticError_semantic_error(a: Bolt11SemanticError): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_semantic_error(a);
+ return nativeResponseValue;
+}
+ // bool ParseOrSemanticError_eq(const struct LDKParseOrSemanticError *NONNULL_PTR a, const struct LDKParseOrSemanticError *NONNULL_PTR b);
+/* @internal */
+export function ParseOrSemanticError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Bolt11Invoice_free(struct LDKBolt11Invoice this_obj);
+/* @internal */
+export function Bolt11Invoice_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_free(this_obj);
+ // debug statements here
+}
+ // bool Bolt11Invoice_eq(const struct LDKBolt11Invoice *NONNULL_PTR a, const struct LDKBolt11Invoice *NONNULL_PTR b);
+/* @internal */
+export function Bolt11Invoice_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg);
+/* @internal */
+export function Bolt11Invoice_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11Invoice Bolt11Invoice_clone(const struct LDKBolt11Invoice *NONNULL_PTR orig);
+/* @internal */
+export function Bolt11Invoice_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Bolt11Invoice_hash(const struct LDKBolt11Invoice *NONNULL_PTR o);
+/* @internal */
+export function Bolt11Invoice_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_hash(o);
+ return nativeResponseValue;
+}
+ // void SignedRawBolt11Invoice_free(struct LDKSignedRawBolt11Invoice this_obj);
+/* @internal */
+export function SignedRawBolt11Invoice_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_free(this_obj);
+ // debug statements here
+}
+ // bool SignedRawBolt11Invoice_eq(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR a, const struct LDKSignedRawBolt11Invoice *NONNULL_PTR b);
+/* @internal */
+export function SignedRawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg);
+/* @internal */
+export function SignedRawBolt11Invoice_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSignedRawBolt11Invoice SignedRawBolt11Invoice_clone(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR orig);
+/* @internal */
+export function SignedRawBolt11Invoice_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t SignedRawBolt11Invoice_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
+/* @internal */
+export function SignedRawBolt11Invoice_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_hash(o);
+ return nativeResponseValue;
+}
+ // void RawBolt11Invoice_free(struct LDKRawBolt11Invoice this_obj);
+/* @internal */
+export function RawBolt11Invoice_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_free(this_obj);
+ // debug statements here
+}
+ // struct LDKRawDataPart RawBolt11Invoice_get_data(const struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr);
+/* @internal */
+export function RawBolt11Invoice_get_data(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_get_data(this_ptr);
+ return nativeResponseValue;
+}
+ // void RawBolt11Invoice_set_data(struct LDKRawBolt11Invoice *NONNULL_PTR this_ptr, struct LDKRawDataPart val);
+/* @internal */
+export function RawBolt11Invoice_set_data(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_set_data(this_ptr, val);
+ // debug statements here
+}
+ // bool RawBolt11Invoice_eq(const struct LDKRawBolt11Invoice *NONNULL_PTR a, const struct LDKRawBolt11Invoice *NONNULL_PTR b);
+/* @internal */
+export function RawBolt11Invoice_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg);
+/* @internal */
+export function RawBolt11Invoice_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKRawBolt11Invoice RawBolt11Invoice_clone(const struct LDKRawBolt11Invoice *NONNULL_PTR orig);
+/* @internal */
+export function RawBolt11Invoice_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t RawBolt11Invoice_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR o);
+/* @internal */
+export function RawBolt11Invoice_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_hash(o);
+ return nativeResponseValue;
+}
+ // void RawDataPart_free(struct LDKRawDataPart this_obj);
+/* @internal */
+export function RawDataPart_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPositiveTimestamp RawDataPart_get_timestamp(const struct LDKRawDataPart *NONNULL_PTR this_ptr);
+/* @internal */
+export function RawDataPart_get_timestamp(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_get_timestamp(this_ptr);
+ return nativeResponseValue;
+}
+ // void RawDataPart_set_timestamp(struct LDKRawDataPart *NONNULL_PTR this_ptr, struct LDKPositiveTimestamp val);
+/* @internal */
+export function RawDataPart_set_timestamp(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_set_timestamp(this_ptr, val);
+ // debug statements here
+}
+ // bool RawDataPart_eq(const struct LDKRawDataPart *NONNULL_PTR a, const struct LDKRawDataPart *NONNULL_PTR b);
+/* @internal */
+export function RawDataPart_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg);
+/* @internal */
+export function RawDataPart_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKRawDataPart RawDataPart_clone(const struct LDKRawDataPart *NONNULL_PTR orig);
+/* @internal */
+export function RawDataPart_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t RawDataPart_hash(const struct LDKRawDataPart *NONNULL_PTR o);
+/* @internal */
+export function RawDataPart_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawDataPart_hash(o);
+ return nativeResponseValue;
+}
+ // void PositiveTimestamp_free(struct LDKPositiveTimestamp this_obj);
+/* @internal */
+export function PositiveTimestamp_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_free(this_obj);
+ // debug statements here
+}
+ // bool PositiveTimestamp_eq(const struct LDKPositiveTimestamp *NONNULL_PTR a, const struct LDKPositiveTimestamp *NONNULL_PTR b);
+/* @internal */
+export function PositiveTimestamp_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg);
+/* @internal */
+export function PositiveTimestamp_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKPositiveTimestamp PositiveTimestamp_clone(const struct LDKPositiveTimestamp *NONNULL_PTR orig);
+/* @internal */
+export function PositiveTimestamp_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t PositiveTimestamp_hash(const struct LDKPositiveTimestamp *NONNULL_PTR o);
+/* @internal */
+export function PositiveTimestamp_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_hash(o);
+ return nativeResponseValue;
+}
+ // enum LDKSiPrefix SiPrefix_clone(const enum LDKSiPrefix *NONNULL_PTR orig);
+/* @internal */
+export function SiPrefix_clone(orig: bigint): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKSiPrefix SiPrefix_milli(void);
+/* @internal */
+export function SiPrefix_milli(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_milli();
+ return nativeResponseValue;
+}
+ // enum LDKSiPrefix SiPrefix_micro(void);
+/* @internal */
+export function SiPrefix_micro(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_micro();
+ return nativeResponseValue;
+}
+ // enum LDKSiPrefix SiPrefix_nano(void);
+/* @internal */
+export function SiPrefix_nano(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_nano();
+ return nativeResponseValue;
+}
+ // enum LDKSiPrefix SiPrefix_pico(void);
+/* @internal */
+export function SiPrefix_pico(): SiPrefix {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_pico();
+ return nativeResponseValue;
+}
+ // bool SiPrefix_eq(const enum LDKSiPrefix *NONNULL_PTR a, const enum LDKSiPrefix *NONNULL_PTR b);
+/* @internal */
+export function SiPrefix_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t SiPrefix_hash(const enum LDKSiPrefix *NONNULL_PTR o);
+/* @internal */
+export function SiPrefix_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_hash(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t SiPrefix_multiplier(const enum LDKSiPrefix *NONNULL_PTR this_arg);
+/* @internal */
+export function SiPrefix_multiplier(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_multiplier(this_arg);
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_clone(const enum LDKCurrency *NONNULL_PTR orig);
+/* @internal */
+export function Currency_clone(orig: bigint): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_bitcoin(void);
+/* @internal */
+export function Currency_bitcoin(): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_bitcoin();
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_bitcoin_testnet(void);
+/* @internal */
+export function Currency_bitcoin_testnet(): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_bitcoin_testnet();
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_regtest(void);
+/* @internal */
+export function Currency_regtest(): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_regtest();
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_simnet(void);
+/* @internal */
+export function Currency_simnet(): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_simnet();
+ return nativeResponseValue;
+}
+ // enum LDKCurrency Currency_signet(void);
+/* @internal */
+export function Currency_signet(): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_signet();
+ return nativeResponseValue;
+}
+ // uint64_t Currency_hash(const enum LDKCurrency *NONNULL_PTR o);
+/* @internal */
+export function Currency_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_hash(o);
+ return nativeResponseValue;
+}
+ // bool Currency_eq(const enum LDKCurrency *NONNULL_PTR a, const enum LDKCurrency *NONNULL_PTR b);
+/* @internal */
+export function Currency_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Sha256_free(struct LDKSha256 this_obj);
+/* @internal */
+export function Sha256_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg);
+/* @internal */
+export function Sha256_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSha256 Sha256_clone(const struct LDKSha256 *NONNULL_PTR orig);
+/* @internal */
+export function Sha256_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Sha256_hash(const struct LDKSha256 *NONNULL_PTR o);
+/* @internal */
+export function Sha256_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_hash(o);
+ return nativeResponseValue;
+}
+ // bool Sha256_eq(const struct LDKSha256 *NONNULL_PTR a, const struct LDKSha256 *NONNULL_PTR b);
+/* @internal */
+export function Sha256_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSha256 Sha256_from_bytes(const uint8_t (*bytes)[32]);
+/* @internal */
+export function Sha256_from_bytes(bytes: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Sha256_from_bytes(bytes);
+ return nativeResponseValue;
+}
+ // void Description_free(struct LDKDescription this_obj);
+/* @internal */
+export function Description_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg);
+/* @internal */
+export function Description_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKDescription Description_clone(const struct LDKDescription *NONNULL_PTR orig);
+/* @internal */
+export function Description_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Description_hash(const struct LDKDescription *NONNULL_PTR o);
+/* @internal */
+export function Description_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_hash(o);
+ return nativeResponseValue;
+}
+ // bool Description_eq(const struct LDKDescription *NONNULL_PTR a, const struct LDKDescription *NONNULL_PTR b);
+/* @internal */
+export function Description_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_eq(a, b);
+ return nativeResponseValue;
+}
+ // void PayeePubKey_free(struct LDKPayeePubKey this_obj);
+/* @internal */
+export function PayeePubKey_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_free(this_obj);
+ // debug statements here
+}
+ // struct LDKPublicKey PayeePubKey_get_a(const struct LDKPayeePubKey *NONNULL_PTR this_ptr);
+/* @internal */
+export function PayeePubKey_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void PayeePubKey_set_a(struct LDKPayeePubKey *NONNULL_PTR this_ptr, struct LDKPublicKey val);
+/* @internal */
+export function PayeePubKey_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKPayeePubKey PayeePubKey_new(struct LDKPublicKey a_arg);
+/* @internal */
+export function PayeePubKey_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg);
+/* @internal */
+export function PayeePubKey_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKPayeePubKey PayeePubKey_clone(const struct LDKPayeePubKey *NONNULL_PTR orig);
+/* @internal */
+export function PayeePubKey_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t PayeePubKey_hash(const struct LDKPayeePubKey *NONNULL_PTR o);
+/* @internal */
+export function PayeePubKey_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_hash(o);
+ return nativeResponseValue;
+}
+ // bool PayeePubKey_eq(const struct LDKPayeePubKey *NONNULL_PTR a, const struct LDKPayeePubKey *NONNULL_PTR b);
+/* @internal */
+export function PayeePubKey_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PayeePubKey_eq(a, b);
+ return nativeResponseValue;
+}
+ // void ExpiryTime_free(struct LDKExpiryTime this_obj);
+/* @internal */
+export function ExpiryTime_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_free(this_obj);
+ // debug statements here
+}
+ // uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg);
+/* @internal */
+export function ExpiryTime_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKExpiryTime ExpiryTime_clone(const struct LDKExpiryTime *NONNULL_PTR orig);
+/* @internal */
+export function ExpiryTime_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t ExpiryTime_hash(const struct LDKExpiryTime *NONNULL_PTR o);
+/* @internal */
+export function ExpiryTime_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_hash(o);
+ return nativeResponseValue;
+}
+ // bool ExpiryTime_eq(const struct LDKExpiryTime *NONNULL_PTR a, const struct LDKExpiryTime *NONNULL_PTR b);
+/* @internal */
+export function ExpiryTime_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_eq(a, b);
+ return nativeResponseValue;
+}
+ // void MinFinalCltvExpiryDelta_free(struct LDKMinFinalCltvExpiryDelta this_obj);
+/* @internal */
+export function MinFinalCltvExpiryDelta_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_free(this_obj);
+ // debug statements here
+}
+ // uint64_t MinFinalCltvExpiryDelta_get_a(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr);
+/* @internal */
+export function MinFinalCltvExpiryDelta_get_a(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void MinFinalCltvExpiryDelta_set_a(struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function MinFinalCltvExpiryDelta_set_a(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_new(uint64_t a_arg);
+/* @internal */
+export function MinFinalCltvExpiryDelta_new(a_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg);
+/* @internal */
+export function MinFinalCltvExpiryDelta_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKMinFinalCltvExpiryDelta MinFinalCltvExpiryDelta_clone(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR orig);
+/* @internal */
+export function MinFinalCltvExpiryDelta_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t MinFinalCltvExpiryDelta_hash(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR o);
+/* @internal */
+export function MinFinalCltvExpiryDelta_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_hash(o);
+ return nativeResponseValue;
+}
+ // bool MinFinalCltvExpiryDelta_eq(const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR a, const struct LDKMinFinalCltvExpiryDelta *NONNULL_PTR b);
+/* @internal */
+export function MinFinalCltvExpiryDelta_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MinFinalCltvExpiryDelta_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Fallback_free(struct LDKFallback this_ptr);
+/* @internal */
+export function Fallback_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg);
+/* @internal */
+export function Fallback_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKFallback Fallback_clone(const struct LDKFallback *NONNULL_PTR orig);
+/* @internal */
+export function Fallback_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKFallback Fallback_seg_wit_program(struct LDKWitnessVersion version, struct LDKCVec_u8Z program);
+/* @internal */
+export function Fallback_seg_wit_program(version: number, program: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_seg_wit_program(version, program);
+ return nativeResponseValue;
+}
+ // struct LDKFallback Fallback_pub_key_hash(struct LDKTwentyBytes a);
+/* @internal */
+export function Fallback_pub_key_hash(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_pub_key_hash(a);
+ return nativeResponseValue;
+}
+ // struct LDKFallback Fallback_script_hash(struct LDKTwentyBytes a);
+/* @internal */
+export function Fallback_script_hash(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_script_hash(a);
+ return nativeResponseValue;
+}
+ // uint64_t Fallback_hash(const struct LDKFallback *NONNULL_PTR o);
+/* @internal */
+export function Fallback_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_hash(o);
+ return nativeResponseValue;
+}
+ // bool Fallback_eq(const struct LDKFallback *NONNULL_PTR a, const struct LDKFallback *NONNULL_PTR b);
+/* @internal */
+export function Fallback_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Fallback_eq(a, b);
+ return nativeResponseValue;
+}
+ // void Bolt11InvoiceSignature_free(struct LDKBolt11InvoiceSignature this_obj);
+/* @internal */
+export function Bolt11InvoiceSignature_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg);
+/* @internal */
+export function Bolt11InvoiceSignature_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBolt11InvoiceSignature Bolt11InvoiceSignature_clone(const struct LDKBolt11InvoiceSignature *NONNULL_PTR orig);
+/* @internal */
+export function Bolt11InvoiceSignature_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Bolt11InvoiceSignature_hash(const struct LDKBolt11InvoiceSignature *NONNULL_PTR o);
+/* @internal */
+export function Bolt11InvoiceSignature_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_hash(o);
+ return nativeResponseValue;
+}
+ // bool Bolt11InvoiceSignature_eq(const struct LDKBolt11InvoiceSignature *NONNULL_PTR a, const struct LDKBolt11InvoiceSignature *NONNULL_PTR b);
+/* @internal */
+export function Bolt11InvoiceSignature_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11InvoiceSignature_eq(a, b);
+ return nativeResponseValue;
+}
+ // void PrivateRoute_free(struct LDKPrivateRoute this_obj);
+/* @internal */
+export function PrivateRoute_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_free(this_obj);
+ // debug statements here
+}
+ // uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg);
+/* @internal */
+export function PrivateRoute_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKPrivateRoute PrivateRoute_clone(const struct LDKPrivateRoute *NONNULL_PTR orig);
+/* @internal */
+export function PrivateRoute_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t PrivateRoute_hash(const struct LDKPrivateRoute *NONNULL_PTR o);
+/* @internal */
+export function PrivateRoute_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_hash(o);
+ return nativeResponseValue;
+}
+ // bool PrivateRoute_eq(const struct LDKPrivateRoute *NONNULL_PTR a, const struct LDKPrivateRoute *NONNULL_PTR b);
+/* @internal */
+export function PrivateRoute_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ SignedRawBolt11Invoice_into_parts(struct LDKSignedRawBolt11Invoice this_arg);
+/* @internal */
+export function SignedRawBolt11Invoice_into_parts(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_into_parts(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKRawBolt11Invoice SignedRawBolt11Invoice_raw_invoice(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function SignedRawBolt11Invoice_raw_invoice(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_raw_invoice(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES const uint8_t (*SignedRawBolt11Invoice_signable_hash(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg))[32];
+/* @internal */
+export function SignedRawBolt11Invoice_signable_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signable_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBolt11InvoiceSignature SignedRawBolt11Invoice_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function SignedRawBolt11Invoice_signature(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_signature(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_PayeePubKeySecp256k1ErrorZ SignedRawBolt11Invoice_recover_payee_pub_key(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function SignedRawBolt11Invoice_recover_payee_pub_key(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_recover_payee_pub_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool SignedRawBolt11Invoice_check_signature(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function SignedRawBolt11Invoice_check_signature(this_arg: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_check_signature(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes RawBolt11Invoice_signable_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_signable_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_signable_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_payment_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_payment_hash(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKDescription RawBolt11Invoice_description(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_description(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_description(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPayeePubKey RawBolt11Invoice_payee_pub_key(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_payee_pub_key(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_payee_pub_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSha256 RawBolt11Invoice_description_hash(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_description_hash(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_description_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKExpiryTime RawBolt11Invoice_expiry_time(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_expiry_time(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_expiry_time(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKMinFinalCltvExpiryDelta RawBolt11Invoice_min_final_cltv_expiry_delta(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_min_final_cltv_expiry_delta(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_ThirtyTwoBytesZ RawBolt11Invoice_payment_secret(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_payment_secret(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_secret(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ RawBolt11Invoice_payment_metadata(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_payment_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_payment_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBolt11InvoiceFeatures RawBolt11Invoice_features(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_PrivateRouteZ RawBolt11Invoice_private_routes(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_private_routes(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_private_routes(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z RawBolt11Invoice_amount_pico_btc(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_amount_pico_btc(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_amount_pico_btc(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES enum LDKCurrency RawBolt11Invoice_currency(const struct LDKRawBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function RawBolt11Invoice_currency(this_arg: bigint): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_RawBolt11Invoice_currency(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_unix_timestamp(uint64_t unix_seconds);
+/* @internal */
+export function PositiveTimestamp_from_unix_timestamp(unix_seconds: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_from_unix_timestamp(unix_seconds);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_PositiveTimestampCreationErrorZ PositiveTimestamp_from_duration_since_epoch(uint64_t duration);
+/* @internal */
+export function PositiveTimestamp_from_duration_since_epoch(duration: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_from_duration_since_epoch(duration);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t PositiveTimestamp_as_unix_timestamp(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
+/* @internal */
+export function PositiveTimestamp_as_unix_timestamp(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_as_unix_timestamp(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t PositiveTimestamp_as_duration_since_epoch(const struct LDKPositiveTimestamp *NONNULL_PTR this_arg);
+/* @internal */
+export function PositiveTimestamp_as_duration_since_epoch(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PositiveTimestamp_as_duration_since_epoch(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKThirtyTwoBytes Bolt11Invoice_signable_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_signable_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_signable_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKSignedRawBolt11Invoice Bolt11Invoice_into_signed_raw(struct LDKBolt11Invoice this_arg);
+/* @internal */
+export function Bolt11Invoice_into_signed_raw(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_into_signed_raw(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneBolt11SemanticErrorZ Bolt11Invoice_check_signature(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_check_signature(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_check_signature(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ Bolt11Invoice_from_signed(struct LDKSignedRawBolt11Invoice signed_invoice);
+/* @internal */
+export function Bolt11Invoice_from_signed(signed_invoice: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_from_signed(signed_invoice);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt11Invoice_duration_since_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_duration_since_epoch(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_duration_since_epoch(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_hash(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
+/* @internal */
+export function Bolt11Invoice_payment_hash(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_hash(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_payee_pub_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_payee_pub_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES const uint8_t (*Bolt11Invoice_payment_secret(const struct LDKBolt11Invoice *NONNULL_PTR this_arg))[32];
+/* @internal */
+export function Bolt11Invoice_payment_secret(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_secret(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_CVec_u8ZZ Bolt11Invoice_payment_metadata(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_payment_metadata(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_payment_metadata(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBolt11InvoiceFeatures Bolt11Invoice_features(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_features(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_features(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKPublicKey Bolt11Invoice_recover_payee_pub_key(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_recover_payee_pub_key(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_recover_payee_pub_key(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_expires_at(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_expires_at(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_expires_at(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt11Invoice_expiry_time(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_expiry_time(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_expiry_time(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt11Invoice_expiration_remaining_from_epoch(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t time);
+/* @internal */
+export function Bolt11Invoice_expiration_remaining_from_epoch(this_arg: bigint, time: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_expiration_remaining_from_epoch(this_arg, time);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool Bolt11Invoice_would_expire(const struct LDKBolt11Invoice *NONNULL_PTR this_arg, uint64_t at_time);
+/* @internal */
+export function Bolt11Invoice_would_expire(this_arg: bigint, at_time: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_would_expire(this_arg, at_time);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t Bolt11Invoice_min_final_cltv_expiry_delta(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_min_final_cltv_expiry_delta(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_min_final_cltv_expiry_delta(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_StrZ Bolt11Invoice_fallback_addresses(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_fallback_addresses(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_fallback_addresses(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_PrivateRouteZ Bolt11Invoice_private_routes(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_private_routes(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_private_routes(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_RouteHintZ Bolt11Invoice_route_hints(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_route_hints(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_route_hints(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES enum LDKCurrency Bolt11Invoice_currency(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_currency(this_arg: bigint): Currency {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_currency(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCOption_u64Z Bolt11Invoice_amount_milli_satoshis(const struct LDKBolt11Invoice *NONNULL_PTR this_arg);
+/* @internal */
+export function Bolt11Invoice_amount_milli_satoshis(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_amount_milli_satoshis(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_DescriptionCreationErrorZ Description_new(struct LDKStr description);
+/* @internal */
+export function Description_new(description: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_new(description);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKStr Description_into_inner(struct LDKDescription this_arg);
+/* @internal */
+export function Description_into_inner(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Description_into_inner(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_seconds(uint64_t seconds);
+/* @internal */
+export function ExpiryTime_from_seconds(seconds: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_from_seconds(seconds);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKExpiryTime ExpiryTime_from_duration(uint64_t duration);
+/* @internal */
+export function ExpiryTime_from_duration(duration: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_from_duration(duration);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t ExpiryTime_as_seconds(const struct LDKExpiryTime *NONNULL_PTR this_arg);
+/* @internal */
+export function ExpiryTime_as_seconds(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_as_seconds(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint64_t ExpiryTime_as_duration(const struct LDKExpiryTime *NONNULL_PTR this_arg);
+/* @internal */
+export function ExpiryTime_as_duration(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ExpiryTime_as_duration(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_PrivateRouteCreationErrorZ PrivateRoute_new(struct LDKRouteHint hops);
+/* @internal */
+export function PrivateRoute_new(hops: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_new(hops);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKRouteHint PrivateRoute_into_inner(struct LDKPrivateRoute this_arg);
+/* @internal */
+export function PrivateRoute_into_inner(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrivateRoute_into_inner(this_arg);
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_clone(const enum LDKCreationError *NONNULL_PTR orig);
+/* @internal */
+export function CreationError_clone(orig: bigint): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_description_too_long(void);
+/* @internal */
+export function CreationError_description_too_long(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_description_too_long();
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_route_too_long(void);
+/* @internal */
+export function CreationError_route_too_long(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_route_too_long();
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_timestamp_out_of_bounds(void);
+/* @internal */
+export function CreationError_timestamp_out_of_bounds(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_timestamp_out_of_bounds();
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_invalid_amount(void);
+/* @internal */
+export function CreationError_invalid_amount(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_invalid_amount();
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_missing_route_hints(void);
+/* @internal */
+export function CreationError_missing_route_hints(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_missing_route_hints();
+ return nativeResponseValue;
+}
+ // enum LDKCreationError CreationError_min_final_cltv_expiry_delta_too_short(void);
+/* @internal */
+export function CreationError_min_final_cltv_expiry_delta_too_short(): CreationError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_min_final_cltv_expiry_delta_too_short();
+ return nativeResponseValue;
+}
+ // bool CreationError_eq(const enum LDKCreationError *NONNULL_PTR a, const enum LDKCreationError *NONNULL_PTR b);
+/* @internal */
+export function CreationError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKStr CreationError_to_str(const enum LDKCreationError *NONNULL_PTR o);
+/* @internal */
+export function CreationError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CreationError_to_str(o);
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_clone(const enum LDKBolt11SemanticError *NONNULL_PTR orig);
+/* @internal */
+export function Bolt11SemanticError_clone(orig: bigint): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_hash(void);
+/* @internal */
+export function Bolt11SemanticError_no_payment_hash(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_hash();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_hashes(void);
+/* @internal */
+export function Bolt11SemanticError_multiple_payment_hashes(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_hashes();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_no_description(void);
+/* @internal */
+export function Bolt11SemanticError_no_description(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_description();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_descriptions(void);
+/* @internal */
+export function Bolt11SemanticError_multiple_descriptions(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_descriptions();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_no_payment_secret(void);
+/* @internal */
+export function Bolt11SemanticError_no_payment_secret(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_no_payment_secret();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_multiple_payment_secrets(void);
+/* @internal */
+export function Bolt11SemanticError_multiple_payment_secrets(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_multiple_payment_secrets();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_features(void);
+/* @internal */
+export function Bolt11SemanticError_invalid_features(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_features();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_recovery_id(void);
+/* @internal */
+export function Bolt11SemanticError_invalid_recovery_id(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_recovery_id();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_invalid_signature(void);
+/* @internal */
+export function Bolt11SemanticError_invalid_signature(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_invalid_signature();
+ return nativeResponseValue;
+}
+ // enum LDKBolt11SemanticError Bolt11SemanticError_imprecise_amount(void);
+/* @internal */
+export function Bolt11SemanticError_imprecise_amount(): Bolt11SemanticError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_imprecise_amount();
+ return nativeResponseValue;
+}
+ // bool Bolt11SemanticError_eq(const enum LDKBolt11SemanticError *NONNULL_PTR a, const enum LDKBolt11SemanticError *NONNULL_PTR b);
+/* @internal */
+export function Bolt11SemanticError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKStr Bolt11SemanticError_to_str(const enum LDKBolt11SemanticError *NONNULL_PTR o);
+/* @internal */
+export function Bolt11SemanticError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11SemanticError_to_str(o);
+ return nativeResponseValue;
+}
+ // void SignOrCreationError_free(struct LDKSignOrCreationError this_ptr);
+/* @internal */
+export function SignOrCreationError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg);
+/* @internal */
+export function SignOrCreationError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSignOrCreationError SignOrCreationError_clone(const struct LDKSignOrCreationError *NONNULL_PTR orig);
+/* @internal */
+export function SignOrCreationError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKSignOrCreationError SignOrCreationError_sign_error(void);
+/* @internal */
+export function SignOrCreationError_sign_error(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_sign_error();
+ return nativeResponseValue;
+}
+ // struct LDKSignOrCreationError SignOrCreationError_creation_error(enum LDKCreationError a);
+/* @internal */
+export function SignOrCreationError_creation_error(a: CreationError): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_creation_error(a);
+ return nativeResponseValue;
+}
+ // bool SignOrCreationError_eq(const struct LDKSignOrCreationError *NONNULL_PTR a, const struct LDKSignOrCreationError *NONNULL_PTR b);
+/* @internal */
+export function SignOrCreationError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKStr SignOrCreationError_to_str(const struct LDKSignOrCreationError *NONNULL_PTR o);
+/* @internal */
+export function SignOrCreationError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignOrCreationError_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
+/* @internal */
+export function pay_invoice(invoice: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_pay_invoice(invoice, retry_strategy, channelmanager);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NonePaymentErrorZ pay_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
+/* @internal */
+export function pay_invoice_with_id(invoice: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_pay_invoice_with_id(invoice, payment_id, retry_strategy, channelmanager);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_ThirtyTwoBytesPaymentErrorZ pay_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
+/* @internal */
+export function pay_zero_value_invoice(invoice: bigint, amount_msats: bigint, retry_strategy: bigint, channelmanager: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_pay_zero_value_invoice(invoice, amount_msats, retry_strategy, channelmanager);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_NonePaymentErrorZ pay_zero_value_invoice_with_id(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msats, struct LDKThirtyTwoBytes payment_id, struct LDKRetry retry_strategy, const struct LDKChannelManager *NONNULL_PTR channelmanager);
+/* @internal */
+export function pay_zero_value_invoice_with_id(invoice: bigint, amount_msats: bigint, payment_id: number, retry_strategy: bigint, channelmanager: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_pay_zero_value_invoice_with_id(invoice, amount_msats, payment_id, retry_strategy, channelmanager);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
+/* @internal */
+export function preflight_probe_invoice(invoice: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_preflight_probe_invoice(invoice, channelmanager, liquidity_limit_multiplier);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ preflight_probe_zero_value_invoice(const struct LDKBolt11Invoice *NONNULL_PTR invoice, uint64_t amount_msat, const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKCOption_u64Z liquidity_limit_multiplier);
+/* @internal */
+export function preflight_probe_zero_value_invoice(invoice: bigint, amount_msat: bigint, channelmanager: bigint, liquidity_limit_multiplier: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_preflight_probe_zero_value_invoice(invoice, amount_msat, channelmanager, liquidity_limit_multiplier);
+ return nativeResponseValue;
+}
+ // void PaymentError_free(struct LDKPaymentError this_ptr);
+/* @internal */
+export function PaymentError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg);
+/* @internal */
+export function PaymentError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKPaymentError PaymentError_clone(const struct LDKPaymentError *NONNULL_PTR orig);
+/* @internal */
+export function PaymentError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKPaymentError PaymentError_invoice(struct LDKStr a);
+/* @internal */
+export function PaymentError_invoice(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_invoice(a);
+ return nativeResponseValue;
+}
+ // struct LDKPaymentError PaymentError_sending(enum LDKRetryableSendFailure a);
+/* @internal */
+export function PaymentError_sending(a: RetryableSendFailure): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_sending(a);
+ return nativeResponseValue;
+}
+ // bool PaymentError_eq(const struct LDKPaymentError *NONNULL_PTR a, const struct LDKPaymentError *NONNULL_PTR b);
+/* @internal */
+export function PaymentError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PaymentError_eq(a, b);
+ return nativeResponseValue;
+}
+ // void ProbingError_free(struct LDKProbingError this_ptr);
+/* @internal */
+export function ProbingError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t ProbingError_clone_ptr(LDKProbingError *NONNULL_PTR arg);
+/* @internal */
+export function ProbingError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKProbingError ProbingError_clone(const struct LDKProbingError *NONNULL_PTR orig);
+/* @internal */
+export function ProbingError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKProbingError ProbingError_invoice(struct LDKStr a);
+/* @internal */
+export function ProbingError_invoice(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_invoice(a);
+ return nativeResponseValue;
+}
+ // struct LDKProbingError ProbingError_sending(struct LDKProbeSendFailure a);
+/* @internal */
+export function ProbingError_sending(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_sending(a);
+ return nativeResponseValue;
+}
+ // bool ProbingError_eq(const struct LDKProbingError *NONNULL_PTR a, const struct LDKProbingError *NONNULL_PTR b);
+/* @internal */
+export function ProbingError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ProbingError_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ payment_hash, struct LDKStr description, uint32_t invoice_expiry_delta_secs, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
+/* @internal */
+export function create_phantom_invoice(amt_msat: bigint, payment_hash: bigint, description: number, invoice_expiry_delta_secs: number, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_create_phantom_invoice(amt_msat, payment_hash, description, invoice_expiry_delta_secs, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_phantom_invoice_with_description_hash(struct LDKCOption_u64Z amt_msat, struct LDKCOption_ThirtyTwoBytesZ payment_hash, uint32_t invoice_expiry_delta_secs, struct LDKSha256 description_hash, struct LDKCVec_PhantomRouteHintsZ phantom_route_hints, struct LDKEntropySource entropy_source, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u16Z min_final_cltv_expiry_delta, uint64_t duration_since_epoch);
+/* @internal */
+export function create_phantom_invoice_with_description_hash(amt_msat: bigint, payment_hash: bigint, invoice_expiry_delta_secs: number, description_hash: bigint, phantom_route_hints: number, entropy_source: bigint, node_signer: bigint, logger: bigint, network: Currency, min_final_cltv_expiry_delta: bigint, duration_since_epoch: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_create_phantom_invoice_with_description_hash(amt_msat, payment_hash, invoice_expiry_delta_secs, description_hash, phantom_route_hints, entropy_source, node_signer, logger, network, min_final_cltv_expiry_delta, duration_since_epoch);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKSha256 description_hash, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
+/* @internal */
+export function create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description_hash: bigint, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description_hash, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
+/* @internal */
+export function create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, min_final_cltv_expiry_delta: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, min_final_cltv_expiry_delta);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceSignOrCreationErrorZ create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(const struct LDKChannelManager *NONNULL_PTR channelmanager, struct LDKNodeSigner node_signer, struct LDKLogger logger, enum LDKCurrency network, struct LDKCOption_u64Z amt_msat, struct LDKStr description, uint64_t duration_since_epoch, uint32_t invoice_expiry_delta_secs, struct LDKThirtyTwoBytes payment_hash, struct LDKCOption_u16Z min_final_cltv_expiry_delta);
+/* @internal */
+export function create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager: bigint, node_signer: bigint, logger: bigint, network: Currency, amt_msat: bigint, description: number, duration_since_epoch: bigint, invoice_expiry_delta_secs: number, payment_hash: number, min_final_cltv_expiry_delta: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_create_invoice_from_channelmanager_and_duration_since_epoch_with_payment_hash(channelmanager, node_signer, logger, network, amt_msat, description, duration_since_epoch, invoice_expiry_delta_secs, payment_hash, min_final_cltv_expiry_delta);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SiPrefixBolt11ParseErrorZ SiPrefix_from_str(struct LDKStr s);
+/* @internal */
+export function SiPrefix_from_str(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_from_str(s);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ Bolt11Invoice_from_str(struct LDKStr s);
+/* @internal */
+export function Bolt11Invoice_from_str(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_from_str(s);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ SignedRawBolt11Invoice_from_str(struct LDKStr s);
+/* @internal */
+export function SignedRawBolt11Invoice_from_str(s: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_from_str(s);
+ return nativeResponseValue;
+}
+ // struct LDKStr Bolt11ParseError_to_str(const struct LDKBolt11ParseError *NONNULL_PTR o);
+/* @internal */
+export function Bolt11ParseError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11ParseError_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr ParseOrSemanticError_to_str(const struct LDKParseOrSemanticError *NONNULL_PTR o);
+/* @internal */
+export function ParseOrSemanticError_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ParseOrSemanticError_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr Bolt11Invoice_to_str(const struct LDKBolt11Invoice *NONNULL_PTR o);
+/* @internal */
+export function Bolt11Invoice_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Bolt11Invoice_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr SignedRawBolt11Invoice_to_str(const struct LDKSignedRawBolt11Invoice *NONNULL_PTR o);
+/* @internal */
+export function SignedRawBolt11Invoice_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SignedRawBolt11Invoice_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr Currency_to_str(const enum LDKCurrency *NONNULL_PTR o);
+/* @internal */
+export function Currency_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Currency_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr SiPrefix_to_str(const enum LDKSiPrefix *NONNULL_PTR o);
+/* @internal */
+export function SiPrefix_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SiPrefix_to_str(o);
+ return nativeResponseValue;
+}
+
+
+js_invoke = function(obj_ptr: number, fn_id: number, arg1: bigint|number, arg2: bigint|number, arg3: bigint|number, arg4: bigint|number, arg5: bigint|number, arg6: bigint|number, arg7: bigint|number, arg8: bigint|number, arg9: bigint|number, arg10: bigint|number) {
+ const weak: WeakRef<object>|undefined = js_objs[obj_ptr];
+ if (weak == null || weak == undefined) {
+ console.error("Got function call on unknown/free'd JS object!");
+ throw new Error("Got function call on unknown/free'd JS object!");
+ }
+ const obj = weak.deref();
+ if (obj == null || obj == undefined) {
+ console.error("Got function call on GC'd JS object!");
+ throw new Error("Got function call on GC'd JS object!");
+ }
+ var fn;
+ switch (fn_id) {
+ case 0: fn = Object.getOwnPropertyDescriptor(obj, "get_per_commitment_point"); break;
+ case 1: fn = Object.getOwnPropertyDescriptor(obj, "release_commitment_secret"); break;
+ case 2: fn = Object.getOwnPropertyDescriptor(obj, "validate_holder_commitment"); break;
+ case 3: fn = Object.getOwnPropertyDescriptor(obj, "channel_keys_id"); break;
+ case 4: fn = Object.getOwnPropertyDescriptor(obj, "provide_channel_parameters"); break;
+ case 5: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_commitment"); break;
+ case 6: fn = Object.getOwnPropertyDescriptor(obj, "validate_counterparty_revocation"); break;
+ case 7: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_commitment_and_htlcs"); break;
+ case 8: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_output"); break;
+ case 9: fn = Object.getOwnPropertyDescriptor(obj, "sign_justice_revoked_htlc"); break;
+ case 10: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_htlc_transaction"); break;
+ case 11: fn = Object.getOwnPropertyDescriptor(obj, "sign_counterparty_htlc_transaction"); break;
+ case 12: fn = Object.getOwnPropertyDescriptor(obj, "sign_closing_transaction"); break;
+ case 13: fn = Object.getOwnPropertyDescriptor(obj, "sign_holder_anchor_input"); break;
+ case 14: fn = Object.getOwnPropertyDescriptor(obj, "sign_channel_announcement_with_funding_key"); break;
+ case 15: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 16: fn = Object.getOwnPropertyDescriptor(obj, "log"); break;
+ case 17: fn = Object.getOwnPropertyDescriptor(obj, "get_utxo"); break;
+ case 18: fn = Object.getOwnPropertyDescriptor(obj, "watch_channel"); break;
+ case 19: fn = Object.getOwnPropertyDescriptor(obj, "update_channel"); break;
+ case 20: fn = Object.getOwnPropertyDescriptor(obj, "release_pending_monitor_events"); break;
+ case 21: fn = Object.getOwnPropertyDescriptor(obj, "broadcast_transactions"); break;
+ case 22: fn = Object.getOwnPropertyDescriptor(obj, "get_secure_random_bytes"); break;
+ case 23: fn = Object.getOwnPropertyDescriptor(obj, "get_inbound_payment_key_material"); break;
+ case 24: fn = Object.getOwnPropertyDescriptor(obj, "get_node_id"); break;
+ case 25: fn = Object.getOwnPropertyDescriptor(obj, "ecdh"); break;
+ case 26: fn = Object.getOwnPropertyDescriptor(obj, "sign_invoice"); break;
+ case 27: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice_request"); break;
+ case 28: fn = Object.getOwnPropertyDescriptor(obj, "sign_bolt12_invoice"); break;
+ case 29: fn = Object.getOwnPropertyDescriptor(obj, "sign_gossip_message"); break;
+ case 30: fn = Object.getOwnPropertyDescriptor(obj, "generate_channel_keys_id"); break;
+ case 31: fn = Object.getOwnPropertyDescriptor(obj, "derive_channel_signer"); break;
+ case 32: fn = Object.getOwnPropertyDescriptor(obj, "read_chan_signer"); break;
+ case 33: fn = Object.getOwnPropertyDescriptor(obj, "get_destination_script"); break;
+ case 34: fn = Object.getOwnPropertyDescriptor(obj, "get_shutdown_scriptpubkey"); break;
+ case 35: fn = Object.getOwnPropertyDescriptor(obj, "get_est_sat_per_1000_weight"); break;
+ case 36: fn = Object.getOwnPropertyDescriptor(obj, "find_route"); break;
+ case 37: fn = Object.getOwnPropertyDescriptor(obj, "find_route_with_id"); break;
+ case 38: fn = Object.getOwnPropertyDescriptor(obj, "type_id"); break;
+ case 39: fn = Object.getOwnPropertyDescriptor(obj, "debug_str"); break;
+ case 40: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 41: fn = Object.getOwnPropertyDescriptor(obj, "tlv_type"); break;
+ case 42: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 43: fn = Object.getOwnPropertyDescriptor(obj, "register_tx"); break;
+ case 44: fn = Object.getOwnPropertyDescriptor(obj, "register_output"); break;
+ case 45: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
+ case 46: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 47: fn = Object.getOwnPropertyDescriptor(obj, "remove"); break;
+ case 48: fn = Object.getOwnPropertyDescriptor(obj, "list"); break;
+ case 49: fn = Object.getOwnPropertyDescriptor(obj, "channel_penalty_msat"); break;
+ case 50: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_failed"); break;
+ case 51: fn = Object.getOwnPropertyDescriptor(obj, "payment_path_successful"); break;
+ case 52: fn = Object.getOwnPropertyDescriptor(obj, "probe_failed"); break;
+ case 53: fn = Object.getOwnPropertyDescriptor(obj, "probe_successful"); break;
+ case 54: fn = Object.getOwnPropertyDescriptor(obj, "read_lock"); break;
+ case 55: fn = Object.getOwnPropertyDescriptor(obj, "write_lock"); break;
+ case 56: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 57: fn = Object.getOwnPropertyDescriptor(obj, "persist_manager"); break;
+ case 58: fn = Object.getOwnPropertyDescriptor(obj, "persist_graph"); break;
+ case 59: fn = Object.getOwnPropertyDescriptor(obj, "persist_scorer"); break;
+ case 60: fn = Object.getOwnPropertyDescriptor(obj, "persist_new_channel"); break;
+ case 61: fn = Object.getOwnPropertyDescriptor(obj, "update_persisted_channel"); break;
+ case 62: fn = Object.getOwnPropertyDescriptor(obj, "call"); break;
+ case 63: fn = Object.getOwnPropertyDescriptor(obj, "filtered_block_connected"); break;
+ case 64: fn = Object.getOwnPropertyDescriptor(obj, "block_connected"); break;
+ case 65: fn = Object.getOwnPropertyDescriptor(obj, "block_disconnected"); break;
+ case 66: fn = Object.getOwnPropertyDescriptor(obj, "transactions_confirmed"); break;
+ case 67: fn = Object.getOwnPropertyDescriptor(obj, "transaction_unconfirmed"); break;
+ case 68: fn = Object.getOwnPropertyDescriptor(obj, "best_block_updated"); break;
+ case 69: fn = Object.getOwnPropertyDescriptor(obj, "get_relevant_txids"); break;
+ case 70: fn = Object.getOwnPropertyDescriptor(obj, "handle_event"); break;
+ case 71: fn = Object.getOwnPropertyDescriptor(obj, "process_pending_events"); break;
+ case 72: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg_events"); break;
+ case 73: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel"); break;
+ case 74: fn = Object.getOwnPropertyDescriptor(obj, "handle_open_channel_v2"); break;
+ case 75: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel"); break;
+ case 76: fn = Object.getOwnPropertyDescriptor(obj, "handle_accept_channel_v2"); break;
+ case 77: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_created"); break;
+ case 78: fn = Object.getOwnPropertyDescriptor(obj, "handle_funding_signed"); break;
+ case 79: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_ready"); break;
+ case 80: fn = Object.getOwnPropertyDescriptor(obj, "handle_shutdown"); break;
+ case 81: fn = Object.getOwnPropertyDescriptor(obj, "handle_closing_signed"); break;
+ case 82: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_input"); break;
+ case 83: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_add_output"); break;
+ case 84: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_input"); break;
+ case 85: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_remove_output"); break;
+ case 86: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_complete"); break;
+ case 87: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_signatures"); break;
+ case 88: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_init_rbf"); break;
+ case 89: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_ack_rbf"); break;
+ case 90: fn = Object.getOwnPropertyDescriptor(obj, "handle_tx_abort"); break;
+ case 91: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_add_htlc"); break;
+ case 92: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fulfill_htlc"); break;
+ case 93: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_htlc"); break;
+ case 94: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fail_malformed_htlc"); break;
+ case 95: fn = Object.getOwnPropertyDescriptor(obj, "handle_commitment_signed"); break;
+ case 96: fn = Object.getOwnPropertyDescriptor(obj, "handle_revoke_and_ack"); break;
+ case 97: fn = Object.getOwnPropertyDescriptor(obj, "handle_update_fee"); break;
+ case 98: fn = Object.getOwnPropertyDescriptor(obj, "handle_announcement_signatures"); break;
+ case 99: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
+ case 100: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
+ case 101: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_reestablish"); break;
+ case 102: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
+ case 103: fn = Object.getOwnPropertyDescriptor(obj, "handle_error"); break;
+ case 104: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+ case 105: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+ case 106: fn = Object.getOwnPropertyDescriptor(obj, "get_genesis_hashes"); break;
+ case 107: fn = Object.getOwnPropertyDescriptor(obj, "handle_node_announcement"); break;
+ case 108: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_announcement"); break;
+ case 109: fn = Object.getOwnPropertyDescriptor(obj, "handle_channel_update"); break;
+ case 110: fn = Object.getOwnPropertyDescriptor(obj, "get_next_channel_announcement"); break;
+ case 111: fn = Object.getOwnPropertyDescriptor(obj, "get_next_node_announcement"); break;
+ case 112: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
+ case 113: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_channel_range"); break;
+ case 114: fn = Object.getOwnPropertyDescriptor(obj, "handle_reply_short_channel_ids_end"); break;
+ case 115: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_channel_range"); break;
+ case 116: fn = Object.getOwnPropertyDescriptor(obj, "handle_query_short_channel_ids"); break;
+ case 117: fn = Object.getOwnPropertyDescriptor(obj, "processing_queue_high"); break;
+ case 118: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+ case 119: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+ case 120: fn = Object.getOwnPropertyDescriptor(obj, "next_onion_message_for_peer"); break;
+ case 121: fn = Object.getOwnPropertyDescriptor(obj, "handle_onion_message"); break;
+ case 122: fn = Object.getOwnPropertyDescriptor(obj, "peer_connected"); break;
+ case 123: fn = Object.getOwnPropertyDescriptor(obj, "peer_disconnected"); break;
+ case 124: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+ case 125: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+ case 126: fn = Object.getOwnPropertyDescriptor(obj, "read"); break;
+ case 127: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
+ case 128: fn = Object.getOwnPropertyDescriptor(obj, "get_and_clear_pending_msg"); break;
+ case 129: fn = Object.getOwnPropertyDescriptor(obj, "provided_node_features"); break;
+ case 130: fn = Object.getOwnPropertyDescriptor(obj, "provided_init_features"); break;
+ case 131: fn = Object.getOwnPropertyDescriptor(obj, "handle_message"); break;
+ case 132: fn = Object.getOwnPropertyDescriptor(obj, "handle_custom_message"); break;
+ case 133: fn = Object.getOwnPropertyDescriptor(obj, "read_custom_message"); break;
+ case 134: fn = Object.getOwnPropertyDescriptor(obj, "send_data"); break;
+ case 135: fn = Object.getOwnPropertyDescriptor(obj, "disconnect_socket"); break;
+ case 136: fn = Object.getOwnPropertyDescriptor(obj, "eq"); break;
+ case 137: fn = Object.getOwnPropertyDescriptor(obj, "hash"); break;
+ case 138: fn = Object.getOwnPropertyDescriptor(obj, "write"); break;
+ case 139: fn = Object.getOwnPropertyDescriptor(obj, "find_path"); break;
+ case 140: fn = Object.getOwnPropertyDescriptor(obj, "select_confirmed_utxos"); break;
+ case 141: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
+ case 142: fn = Object.getOwnPropertyDescriptor(obj, "list_confirmed_utxos"); break;
+ case 143: fn = Object.getOwnPropertyDescriptor(obj, "get_change_script"); break;
+ case 144: fn = Object.getOwnPropertyDescriptor(obj, "sign_tx"); break;
+ default:
+ console.error("Got unknown function call with id " + fn_id + " from C!");
+ throw new Error("Got unknown function call with id " + fn_id + " from C!");
+ }
+ if (fn == null || fn == undefined) {
+ console.error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
+ throw new Error("Got function call with id " + fn_id + " on incorrect JS object: " + obj);
+ }
+ var ret;
+ try {
+ ret = fn.value.bind(obj)(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+ } catch (e) {
+ console.error("Got an exception calling function with id " + fn_id + "! This is fatal.");
+ console.error(e);
+ throw e;
+ }
+ if (ret === undefined || ret === null) return BigInt(0);
+ return BigInt(ret);
+}
\ No newline at end of file