X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=ts%2Fbindings.ts;h=3a8bfbe90632e3ad68be620b0462efab08df1827;hb=7cede693022f65adf9b93bfda7a462481e30c1ef;hp=326a84e2a0e4bd9915fb80d20c202fa1ba365c80;hpb=17113550a5fefab21f39f27fbfe02646b8db53ae;p=ldk-java

diff --git a/ts/bindings.ts b/ts/bindings.ts
index 326a84e2..3a8bfbe9 100644
--- a/ts/bindings.ts
+++ b/ts/bindings.ts
@@ -167,6 +167,19 @@ public static native long new_empty_slice_vec();
 	public static native boolean LDKCResult_TxCreationKeysErrorZ_result_ok(long arg);
 	public static native number LDKCResult_TxCreationKeysErrorZ_get_ok(long arg);
 	public static native LDKSecp256k1Error LDKCResult_TxCreationKeysErrorZ_get_err(long arg);
+	public static class LDKCOption_u32Z {
+		private LDKCOption_u32Z() {}
+		export class Some extends LDKCOption_u32Z {
+			public number some;
+			Some(number some) { this.some = some; }
+		}
+		export class None extends LDKCOption_u32Z {
+			None() { }
+		}
+		static native void init();
+	}
+	static { LDKCOption_u32Z.init(); }
+	public static native LDKCOption_u32Z LDKCOption_u32Z_ref_from_ptr(long ptr);
 	public static native boolean LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(long arg);
 	public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(long arg);
 	public static native number LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(long arg);
@@ -317,6 +330,11 @@ public static native long new_empty_slice_vec();
 			public number msg;
 			SendShortIdsQuery(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
 		}
+		export class SendReplyChannelRange extends LDKMessageSendEvent {
+			public Uint8Array node_id;
+			public number msg;
+			SendReplyChannelRange(Uint8Array node_id, number msg) { this.node_id = node_id; this.msg = msg; }
+		}
 		static native void init();
 	}
 	static { LDKMessageSendEvent.init(); }
@@ -352,9 +370,25 @@ public static native long new_empty_slice_vec();
 	public static native boolean LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(long arg);
 	public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(long arg);
 	public static native number LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(long arg);
+	public static native boolean LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(long arg);
+	public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(long arg);
+	public static native number LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(long arg);
 	public static native boolean LDKCResult_ChannelConfigDecodeErrorZ_result_ok(long arg);
 	public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_ok(long arg);
 	public static native number LDKCResult_ChannelConfigDecodeErrorZ_get_err(long arg);
+	public static class LDKCOption_u64Z {
+		private LDKCOption_u64Z() {}
+		export class Some extends LDKCOption_u64Z {
+			public number some;
+			Some(number some) { this.some = some; }
+		}
+		export class None extends LDKCOption_u64Z {
+			None() { }
+		}
+		static native void init();
+	}
+	static { LDKCOption_u64Z.init(); }
+	public static native LDKCOption_u64Z LDKCOption_u64Z_ref_from_ptr(long ptr);
 	public static native boolean LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(long arg);
 	public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(long arg);
 	public static native number LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(long arg);
@@ -413,10 +447,12 @@ public static native long new_empty_slice_vec();
 	public static class LDKMonitorEvent {
 		private LDKMonitorEvent() {}
 		export class HTLCEvent extends LDKMonitorEvent {
-			HTLCEvent() { }
+			public number htlc_event;
+			HTLCEvent(number htlc_event) { this.htlc_event = htlc_event; }
 		}
 		export class CommitmentTxBroadcasted extends LDKMonitorEvent {
-			CommitmentTxBroadcasted() { }
+			public number commitment_tx_broadcasted;
+			CommitmentTxBroadcasted(number commitment_tx_broadcasted) { this.commitment_tx_broadcasted = commitment_tx_broadcasted; }
 		}
 		static native void init();
 	}
@@ -431,10 +467,12 @@ public static native long new_empty_slice_vec();
 			StaticOutput(number outpoint, number output) { this.outpoint = outpoint; this.output = output; }
 		}
 		export class DelayedPaymentOutput extends LDKSpendableOutputDescriptor {
-			DelayedPaymentOutput() { }
+			public number delayed_payment_output;
+			DelayedPaymentOutput(number delayed_payment_output) { this.delayed_payment_output = delayed_payment_output; }
 		}
 		export class StaticPaymentOutput extends LDKSpendableOutputDescriptor {
-			StaticPaymentOutput() { }
+			public number static_payment_output;
+			StaticPaymentOutput(number static_payment_output) { this.static_payment_output = static_payment_output; }
 		}
 		static native void init();
 	}
@@ -654,6 +692,19 @@ public static native long new_empty_slice_vec();
 	public static native boolean LDKCResult_TxOutAccessErrorZ_result_ok(long arg);
 	public static native number LDKCResult_TxOutAccessErrorZ_get_ok(long arg);
 	public static native LDKAccessError LDKCResult_TxOutAccessErrorZ_get_err(long arg);
+	public static class LDKCOption_C2Tuple_usizeTransactionZZ {
+		private LDKCOption_C2Tuple_usizeTransactionZZ() {}
+		export class Some extends LDKCOption_C2Tuple_usizeTransactionZZ {
+			public number some;
+			Some(number some) { this.some = some; }
+		}
+		export class None extends LDKCOption_C2Tuple_usizeTransactionZZ {
+			None() { }
+		}
+		static native void init();
+	}
+	static { LDKCOption_C2Tuple_usizeTransactionZZ.init(); }
+	public static native LDKCOption_C2Tuple_usizeTransactionZZ LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(long ptr);
 	public static class LDKAPIError {
 		private LDKAPIError() {}
 		export class APIMisuseError extends LDKAPIError {
@@ -689,16 +740,20 @@ public static native long new_empty_slice_vec();
 	public static class LDKPaymentSendFailure {
 		private LDKPaymentSendFailure() {}
 		export class ParameterError extends LDKPaymentSendFailure {
-			ParameterError() { }
+			public number parameter_error;
+			ParameterError(number parameter_error) { this.parameter_error = parameter_error; }
 		}
 		export class PathParameterError extends LDKPaymentSendFailure {
-			PathParameterError() { }
+			public number[] path_parameter_error;
+			PathParameterError(number[] path_parameter_error) { this.path_parameter_error = path_parameter_error; }
 		}
 		export class AllFailedRetrySafe extends LDKPaymentSendFailure {
-			AllFailedRetrySafe() { }
+			public number[] all_failed_retry_safe;
+			AllFailedRetrySafe(number[] all_failed_retry_safe) { this.all_failed_retry_safe = all_failed_retry_safe; }
 		}
 		export class PartialFailure extends LDKPaymentSendFailure {
-			PartialFailure() { }
+			public number[] partial_failure;
+			PartialFailure(number[] partial_failure) { this.partial_failure = partial_failure; }
 		}
 		static native void init();
 	}
@@ -1128,7 +1183,7 @@ public static native long new_empty_slice_vec();
 
 		export interface LDKFilter {
 			register_tx (txid: Uint8Array, script_pubkey: Uint8Array): void;
-			register_output (outpoint: number, script_pubkey: Uint8Array): void;
+			register_output (output: number): number;
 		}
 
 		export function LDKFilter_new(impl: LDKFilter): number {
@@ -1146,13 +1201,13 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.Filter_register_tx(this_arg, encodeArray(txid), encodeArray(script_pubkey));
 		// debug statements here
 	}
-	// void Filter_register_output LDKFilter *NONNULL_PTR this_arg, const struct LDKOutPoint *NONNULL_PTR outpoint, struct LDKu8slice script_pubkey
-	export function Filter_register_output(this_arg: number, outpoint: number, script_pubkey: Uint8Array): void {
+	// LDKCOption_C2Tuple_usizeTransactionZZ Filter_register_output LDKFilter *NONNULL_PTR this_arg, struct LDKWatchedOutput output
+	export function Filter_register_output(this_arg: number, output: number): number {
 		if(!isWasmInitialized) {
 			throw new Error("initializeWasm() must be awaited first!");
 		}
-		const nativeResponseValue = wasm.Filter_register_output(this_arg, outpoint, encodeArray(script_pubkey));
-		// debug statements here
+		const nativeResponseValue = wasm.Filter_register_output(this_arg, output);
+		return nativeResponseValue;
 	}
 
 
@@ -1211,6 +1266,7 @@ public static native long new_empty_slice_vec();
 			peer_disconnected (their_node_id: Uint8Array, no_connection_possible: boolean): void;
 			peer_connected (their_node_id: Uint8Array, msg: number): void;
 			handle_channel_reestablish (their_node_id: Uint8Array, msg: number): void;
+			handle_channel_update (their_node_id: Uint8Array, msg: number): void;
 			handle_error (their_node_id: Uint8Array, msg: number): void;
 		}
 
@@ -1365,6 +1421,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_reestablish(this_arg, encodeArray(their_node_id), msg);
 		// debug statements here
 	}
+	// void ChannelMessageHandler_handle_channel_update LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKChannelUpdate *NONNULL_PTR msg
+	export function ChannelMessageHandler_handle_channel_update(this_arg: number, their_node_id: Uint8Array, msg: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelMessageHandler_handle_channel_update(this_arg, encodeArray(their_node_id), msg);
+		// debug statements here
+	}
 	// void ChannelMessageHandler_handle_error LDKChannelMessageHandler *NONNULL_PTR this_arg, struct LDKPublicKey their_node_id, const struct LDKErrorMessage *NONNULL_PTR msg
 	export function ChannelMessageHandler_handle_error(this_arg: number, their_node_id: Uint8Array, msg: number): void {
 		if(!isWasmInitialized) {
@@ -1690,6 +1754,38 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.CResult_TxCreationKeysErrorZ_free(_res);
 		// debug statements here
 	}
+	// struct LDKCOption_u32Z COption_u32Z_some(uint32_t o);
+	export function COption_u32Z_some(o: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u32Z_some(o);
+		return nativeResponseValue;
+	}
+	// struct LDKCOption_u32Z COption_u32Z_none(void);
+	export function COption_u32Z_none(): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u32Z_none();
+		return nativeResponseValue;
+	}
+	// void COption_u32Z_free(struct LDKCOption_u32Z _res);
+	export function COption_u32Z_free(_res: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u32Z_free(_res);
+		// debug statements here
+	}
+	// struct LDKCOption_u32Z COption_u32Z_clone(const struct LDKCOption_u32Z *NONNULL_PTR orig);
+	export function COption_u32Z_clone(orig: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u32Z_clone(orig);
+		return nativeResponseValue;
+	}
 	// struct LDKCResult_HTLCOutputInCommitmentDecodeErrorZ CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(struct LDKHTLCOutputInCommitment o);
 	export function CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o: number): number {
 		if(!isWasmInitialized) {
@@ -2242,6 +2338,30 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.CResult_ChannelFeaturesDecodeErrorZ_free(_res);
 		// debug statements here
 	}
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_ok(struct LDKInvoiceFeatures o);
+	export function CResult_InvoiceFeaturesDecodeErrorZ_ok(o: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_ok(o);
+		return nativeResponseValue;
+	}
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ CResult_InvoiceFeaturesDecodeErrorZ_err(struct LDKDecodeError e);
+	export function CResult_InvoiceFeaturesDecodeErrorZ_err(e: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_err(e);
+		return nativeResponseValue;
+	}
+	// void CResult_InvoiceFeaturesDecodeErrorZ_free(struct LDKCResult_InvoiceFeaturesDecodeErrorZ _res);
+	export function CResult_InvoiceFeaturesDecodeErrorZ_free(_res: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.CResult_InvoiceFeaturesDecodeErrorZ_free(_res);
+		// debug statements here
+	}
 	// struct LDKCResult_ChannelConfigDecodeErrorZ CResult_ChannelConfigDecodeErrorZ_ok(struct LDKChannelConfig o);
 	export function CResult_ChannelConfigDecodeErrorZ_ok(o: number): number {
 		if(!isWasmInitialized) {
@@ -2274,6 +2394,38 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.CResult_ChannelConfigDecodeErrorZ_clone(orig);
 		return nativeResponseValue;
 	}
+	// struct LDKCOption_u64Z COption_u64Z_some(uint64_t o);
+	export function COption_u64Z_some(o: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u64Z_some(o);
+		return nativeResponseValue;
+	}
+	// struct LDKCOption_u64Z COption_u64Z_none(void);
+	export function COption_u64Z_none(): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u64Z_none();
+		return nativeResponseValue;
+	}
+	// void COption_u64Z_free(struct LDKCOption_u64Z _res);
+	export function COption_u64Z_free(_res: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u64Z_free(_res);
+		// debug statements here
+	}
+	// struct LDKCOption_u64Z COption_u64Z_clone(const struct LDKCOption_u64Z *NONNULL_PTR orig);
+	export function COption_u64Z_clone(orig: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_u64Z_clone(orig);
+		return nativeResponseValue;
+	}
 	// struct LDKCResult_DirectionalChannelInfoDecodeErrorZ CResult_DirectionalChannelInfoDecodeErrorZ_ok(struct LDKDirectionalChannelInfo o);
 	export function CResult_DirectionalChannelInfoDecodeErrorZ_ok(o: number): number {
 		if(!isWasmInitialized) {
@@ -2906,6 +3058,30 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.CResult_TxOutAccessErrorZ_clone(orig);
 		return nativeResponseValue;
 	}
+	// struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_some(struct LDKC2Tuple_usizeTransactionZ o);
+	export function COption_C2Tuple_usizeTransactionZZ_some(o: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_some(o);
+		return nativeResponseValue;
+	}
+	// struct LDKCOption_C2Tuple_usizeTransactionZZ COption_C2Tuple_usizeTransactionZZ_none(void);
+	export function COption_C2Tuple_usizeTransactionZZ_none(): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_none();
+		return nativeResponseValue;
+	}
+	// void COption_C2Tuple_usizeTransactionZZ_free(struct LDKCOption_C2Tuple_usizeTransactionZZ _res);
+	export function COption_C2Tuple_usizeTransactionZZ_free(_res: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.COption_C2Tuple_usizeTransactionZZ_free(_res);
+		// debug statements here
+	}
 	// struct LDKCResult_NoneAPIErrorZ CResult_NoneAPIErrorZ_ok(void);
 	export function CResult_NoneAPIErrorZ_ok(): number {
 		if(!isWasmInitialized) {
@@ -4866,6 +5042,22 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelConfig_set_fee_proportional_millionths(this_ptr, val);
 		// debug statements here
 	}
+	// uint16_t ChannelConfig_get_cltv_expiry_delta(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
+	export function ChannelConfig_get_cltv_expiry_delta(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelConfig_get_cltv_expiry_delta(this_ptr);
+		return nativeResponseValue;
+	}
+	// void ChannelConfig_set_cltv_expiry_delta(struct LDKChannelConfig *NONNULL_PTR this_ptr, uint16_t val);
+	export function ChannelConfig_set_cltv_expiry_delta(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelConfig_set_cltv_expiry_delta(this_ptr, val);
+		// debug statements here
+	}
 	// bool ChannelConfig_get_announced_channel(const struct LDKChannelConfig *NONNULL_PTR this_ptr);
 	export function ChannelConfig_get_announced_channel(this_ptr: number): boolean {
 		if(!isWasmInitialized) {
@@ -4898,12 +5090,12 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelConfig_set_commit_upfront_shutdown_pubkey(this_ptr, val);
 		// debug statements here
 	}
-	// MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
-	export function ChannelConfig_new(fee_proportional_millionths_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
+	// MUST_USE_RES struct LDKChannelConfig ChannelConfig_new(uint32_t fee_proportional_millionths_arg, uint16_t cltv_expiry_delta_arg, bool announced_channel_arg, bool commit_upfront_shutdown_pubkey_arg);
+	export function ChannelConfig_new(fee_proportional_millionths_arg: number, cltv_expiry_delta_arg: number, announced_channel_arg: boolean, commit_upfront_shutdown_pubkey_arg: boolean): number {
 		if(!isWasmInitialized) {
 			throw new Error("initializeWasm() must be awaited first!");
 		}
-		const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
+		const nativeResponseValue = wasm.ChannelConfig_new(fee_proportional_millionths_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
 		return nativeResponseValue;
 	}
 	// struct LDKChannelConfig ChannelConfig_clone(const struct LDKChannelConfig *NONNULL_PTR orig);
@@ -5058,6 +5250,70 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.Filter_free(this_ptr);
 		// debug statements here
 	}
+	// void WatchedOutput_free(struct LDKWatchedOutput this_obj);
+	export function WatchedOutput_free(this_obj: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_free(this_obj);
+		// debug statements here
+	}
+	// struct LDKThirtyTwoBytes WatchedOutput_get_block_hash(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+	export function WatchedOutput_get_block_hash(this_ptr: number): Uint8Array {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_get_block_hash(this_ptr);
+		return decodeArray(nativeResponseValue);
+	}
+	// void WatchedOutput_set_block_hash(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKThirtyTwoBytes val);
+	export function WatchedOutput_set_block_hash(this_ptr: number, val: Uint8Array): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_set_block_hash(this_ptr, encodeArray(val));
+		// debug statements here
+	}
+	// struct LDKOutPoint WatchedOutput_get_outpoint(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+	export function WatchedOutput_get_outpoint(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_get_outpoint(this_ptr);
+		return nativeResponseValue;
+	}
+	// void WatchedOutput_set_outpoint(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKOutPoint val);
+	export function WatchedOutput_set_outpoint(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_set_outpoint(this_ptr, val);
+		// debug statements here
+	}
+	// struct LDKu8slice WatchedOutput_get_script_pubkey(const struct LDKWatchedOutput *NONNULL_PTR this_ptr);
+	export function WatchedOutput_get_script_pubkey(this_ptr: number): Uint8Array {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_get_script_pubkey(this_ptr);
+		return decodeArray(nativeResponseValue);
+	}
+	// void WatchedOutput_set_script_pubkey(struct LDKWatchedOutput *NONNULL_PTR this_ptr, struct LDKCVec_u8Z val);
+	export function WatchedOutput_set_script_pubkey(this_ptr: number, val: Uint8Array): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_set_script_pubkey(this_ptr, encodeArray(val));
+		// debug statements here
+	}
+	// MUST_USE_RES struct LDKWatchedOutput WatchedOutput_new(struct LDKThirtyTwoBytes block_hash_arg, struct LDKOutPoint outpoint_arg, struct LDKCVec_u8Z script_pubkey_arg);
+	export function WatchedOutput_new(block_hash_arg: Uint8Array, outpoint_arg: number, script_pubkey_arg: Uint8Array): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.WatchedOutput_new(encodeArray(block_hash_arg), outpoint_arg, encodeArray(script_pubkey_arg));
+		return nativeResponseValue;
+	}
 	// void BroadcasterInterface_free(struct LDKBroadcasterInterface this_ptr);
 	export function BroadcasterInterface_free(this_ptr: number): void {
 		if(!isWasmInitialized) {
@@ -6058,6 +6314,22 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelDetails_set_channel_id(this_ptr, encodeArray(val));
 		// debug statements here
 	}
+	// struct LDKCOption_u64Z ChannelDetails_get_short_channel_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
+	export function ChannelDetails_get_short_channel_id(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelDetails_get_short_channel_id(this_ptr);
+		return nativeResponseValue;
+	}
+	// void ChannelDetails_set_short_channel_id(struct LDKChannelDetails *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	export function ChannelDetails_set_short_channel_id(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelDetails_set_short_channel_id(this_ptr, val);
+		// debug statements here
+	}
 	// struct LDKPublicKey ChannelDetails_get_remote_network_id(const struct LDKChannelDetails *NONNULL_PTR this_ptr);
 	export function ChannelDetails_get_remote_network_id(this_ptr: number): Uint8Array {
 		if(!isWasmInitialized) {
@@ -6362,6 +6634,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelManager_block_disconnected(this_arg, encodeArray(header));
 		// debug statements here
 	}
+	// MUST_USE_RES bool ChannelManager_await_persistable_update_timeout(const struct LDKChannelManager *NONNULL_PTR this_arg, uint64_t max_wait);
+	export function ChannelManager_await_persistable_update_timeout(this_arg: number, max_wait: number): boolean {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelManager_await_persistable_update_timeout(this_arg, max_wait);
+		return nativeResponseValue;
+	}
 	// void ChannelManager_await_persistable_update(const struct LDKChannelManager *NONNULL_PTR this_arg);
 	export function ChannelManager_await_persistable_update(this_arg: number): void {
 		if(!isWasmInitialized) {
@@ -9874,6 +10154,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ReplyShortChannelIdsEnd_write(obj);
 		return decodeArray(nativeResponseValue);
 	}
+	// MUST_USE_RES uint32_t QueryChannelRange_end_blocknum(const struct LDKQueryChannelRange *NONNULL_PTR this_arg);
+	export function QueryChannelRange_end_blocknum(this_arg: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.QueryChannelRange_end_blocknum(this_arg);
+		return nativeResponseValue;
+	}
 	// struct LDKCResult_QueryChannelRangeDecodeErrorZ QueryChannelRange_read(struct LDKu8slice ser);
 	export function QueryChannelRange_read(ser: Uint8Array): number {
 		if(!isWasmInitialized) {
@@ -10170,12 +10458,12 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.PeerManager_disconnect_by_node_id(this_arg, encodeArray(node_id), no_connection_possible);
 		// debug statements here
 	}
-	// void PeerManager_timer_tick_occured(const struct LDKPeerManager *NONNULL_PTR this_arg);
-	export function PeerManager_timer_tick_occured(this_arg: number): void {
+	// void PeerManager_timer_tick_occurred(const struct LDKPeerManager *NONNULL_PTR this_arg);
+	export function PeerManager_timer_tick_occurred(this_arg: number): void {
 		if(!isWasmInitialized) {
 			throw new Error("initializeWasm() must be awaited first!");
 		}
-		const nativeResponseValue = wasm.PeerManager_timer_tick_occured(this_arg);
+		const nativeResponseValue = wasm.PeerManager_timer_tick_occurred(this_arg);
 		// debug statements here
 	}
 	// struct LDKThirtyTwoBytes build_commitment_secret(const uint8_t (*commitment_seed)[32], uint64_t idx);
@@ -10554,6 +10842,30 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.HTLCOutputInCommitment_set_payment_hash(this_ptr, encodeArray(val));
 		// debug statements here
 	}
+	// struct LDKCOption_u32Z HTLCOutputInCommitment_get_transaction_output_index(const struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr);
+	export function HTLCOutputInCommitment_get_transaction_output_index(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.HTLCOutputInCommitment_get_transaction_output_index(this_ptr);
+		return nativeResponseValue;
+	}
+	// void HTLCOutputInCommitment_set_transaction_output_index(struct LDKHTLCOutputInCommitment *NONNULL_PTR this_ptr, struct LDKCOption_u32Z val);
+	export function HTLCOutputInCommitment_set_transaction_output_index(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.HTLCOutputInCommitment_set_transaction_output_index(this_ptr, val);
+		// debug statements here
+	}
+	// MUST_USE_RES struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_new(bool offered_arg, uint64_t amount_msat_arg, uint32_t cltv_expiry_arg, struct LDKThirtyTwoBytes payment_hash_arg, struct LDKCOption_u32Z transaction_output_index_arg);
+	export function HTLCOutputInCommitment_new(offered_arg: boolean, amount_msat_arg: number, cltv_expiry_arg: number, payment_hash_arg: Uint8Array, transaction_output_index_arg: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, encodeArray(payment_hash_arg), transaction_output_index_arg);
+		return nativeResponseValue;
+	}
 	// struct LDKHTLCOutputInCommitment HTLCOutputInCommitment_clone(const struct LDKHTLCOutputInCommitment *NONNULL_PTR orig);
 	export function HTLCOutputInCommitment_clone(orig: number): number {
 		if(!isWasmInitialized) {
@@ -11170,6 +11482,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelFeatures_clone(orig);
 		return nativeResponseValue;
 	}
+	// struct LDKInvoiceFeatures InvoiceFeatures_clone(const struct LDKInvoiceFeatures *NONNULL_PTR orig);
+	export function InvoiceFeatures_clone(orig: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_clone(orig);
+		return nativeResponseValue;
+	}
 	// void InitFeatures_free(struct LDKInitFeatures this_obj);
 	export function InitFeatures_free(this_obj: number): void {
 		if(!isWasmInitialized) {
@@ -11194,6 +11514,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelFeatures_free(this_obj);
 		// debug statements here
 	}
+	// void InvoiceFeatures_free(struct LDKInvoiceFeatures this_obj);
+	export function InvoiceFeatures_free(this_obj: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_free(this_obj);
+		// debug statements here
+	}
 	// MUST_USE_RES struct LDKInitFeatures InitFeatures_empty(void);
 	export function InitFeatures_empty(): number {
 		if(!isWasmInitialized) {
@@ -11242,6 +11570,22 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelFeatures_known();
 		return nativeResponseValue;
 	}
+	// MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_empty(void);
+	export function InvoiceFeatures_empty(): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_empty();
+		return nativeResponseValue;
+	}
+	// MUST_USE_RES struct LDKInvoiceFeatures InvoiceFeatures_known(void);
+	export function InvoiceFeatures_known(): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_known();
+		return nativeResponseValue;
+	}
 	// struct LDKCVec_u8Z InitFeatures_write(const struct LDKInitFeatures *NONNULL_PTR obj);
 	export function InitFeatures_write(obj: number): Uint8Array {
 		if(!isWasmInitialized) {
@@ -11266,6 +11610,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelFeatures_write(obj);
 		return decodeArray(nativeResponseValue);
 	}
+	// struct LDKCVec_u8Z InvoiceFeatures_write(const struct LDKInvoiceFeatures *NONNULL_PTR obj);
+	export function InvoiceFeatures_write(obj: number): Uint8Array {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_write(obj);
+		return decodeArray(nativeResponseValue);
+	}
 	// struct LDKCResult_InitFeaturesDecodeErrorZ InitFeatures_read(struct LDKu8slice ser);
 	export function InitFeatures_read(ser: Uint8Array): number {
 		if(!isWasmInitialized) {
@@ -11290,6 +11642,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelFeatures_read(encodeArray(ser));
 		return nativeResponseValue;
 	}
+	// struct LDKCResult_InvoiceFeaturesDecodeErrorZ InvoiceFeatures_read(struct LDKu8slice ser);
+	export function InvoiceFeatures_read(ser: Uint8Array): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.InvoiceFeatures_read(encodeArray(ser));
+		return nativeResponseValue;
+	}
 	// void RouteHop_free(struct LDKRouteHop this_obj);
 	export function RouteHop_free(this_obj: number): void {
 		if(!isWasmInitialized) {
@@ -11530,6 +11890,46 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.RouteHint_set_cltv_expiry_delta(this_ptr, val);
 		// debug statements here
 	}
+	// struct LDKCOption_u64Z RouteHint_get_htlc_minimum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+	export function RouteHint_get_htlc_minimum_msat(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.RouteHint_get_htlc_minimum_msat(this_ptr);
+		return nativeResponseValue;
+	}
+	// void RouteHint_set_htlc_minimum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	export function RouteHint_set_htlc_minimum_msat(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.RouteHint_set_htlc_minimum_msat(this_ptr, val);
+		// debug statements here
+	}
+	// struct LDKCOption_u64Z RouteHint_get_htlc_maximum_msat(const struct LDKRouteHint *NONNULL_PTR this_ptr);
+	export function RouteHint_get_htlc_maximum_msat(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.RouteHint_get_htlc_maximum_msat(this_ptr);
+		return nativeResponseValue;
+	}
+	// void RouteHint_set_htlc_maximum_msat(struct LDKRouteHint *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	export function RouteHint_set_htlc_maximum_msat(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.RouteHint_set_htlc_maximum_msat(this_ptr, val);
+		// debug statements here
+	}
+	// MUST_USE_RES struct LDKRouteHint RouteHint_new(struct LDKPublicKey src_node_id_arg, uint64_t short_channel_id_arg, struct LDKRoutingFees fees_arg, uint16_t cltv_expiry_delta_arg, struct LDKCOption_u64Z htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg);
+	export function RouteHint_new(src_node_id_arg: Uint8Array, short_channel_id_arg: number, fees_arg: number, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.RouteHint_new(encodeArray(src_node_id_arg), short_channel_id_arg, fees_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg);
+		return nativeResponseValue;
+	}
 	// struct LDKRouteHint RouteHint_clone(const struct LDKRouteHint *NONNULL_PTR orig);
 	export function RouteHint_clone(orig: number): number {
 		if(!isWasmInitialized) {
@@ -11538,12 +11938,12 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.RouteHint_clone(orig);
 		return nativeResponseValue;
 	}
-	// struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
-	export function get_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
+	// struct LDKCResult_RouteLightningErrorZ get_route(struct LDKPublicKey our_node_id, const struct LDKNetworkGraph *NONNULL_PTR network, struct LDKPublicKey payee, struct LDKInvoiceFeatures payee_features, struct LDKCVec_ChannelDetailsZ *first_hops, struct LDKCVec_RouteHintZ last_hops, uint64_t final_value_msat, uint32_t final_cltv, struct LDKLogger logger);
+	export function get_route(our_node_id: Uint8Array, network: number, payee: Uint8Array, payee_features: number, first_hops: number[], last_hops: number[], final_value_msat: number, final_cltv: number, logger: number): number {
 		if(!isWasmInitialized) {
 			throw new Error("initializeWasm() must be awaited first!");
 		}
-		const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), first_hops, last_hops, final_value_msat, final_cltv, logger);
+		const nativeResponseValue = wasm.get_route(encodeArray(our_node_id), network, encodeArray(payee), payee_features, first_hops, last_hops, final_value_msat, final_cltv, logger);
 		return nativeResponseValue;
 	}
 	// void NetworkGraph_free(struct LDKNetworkGraph this_obj);
@@ -11706,6 +12106,22 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.DirectionalChannelInfo_set_htlc_minimum_msat(this_ptr, val);
 		// debug statements here
 	}
+	// struct LDKCOption_u64Z DirectionalChannelInfo_get_htlc_maximum_msat(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
+	export function DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.DirectionalChannelInfo_get_htlc_maximum_msat(this_ptr);
+		return nativeResponseValue;
+	}
+	// void DirectionalChannelInfo_set_htlc_maximum_msat(struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	export function DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.DirectionalChannelInfo_set_htlc_maximum_msat(this_ptr, val);
+		// debug statements here
+	}
 	// struct LDKRoutingFees DirectionalChannelInfo_get_fees(const struct LDKDirectionalChannelInfo *NONNULL_PTR this_ptr);
 	export function DirectionalChannelInfo_get_fees(this_ptr: number): number {
 		if(!isWasmInitialized) {
@@ -11738,6 +12154,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.DirectionalChannelInfo_set_last_update_message(this_ptr, val);
 		// debug statements here
 	}
+	// MUST_USE_RES struct LDKDirectionalChannelInfo DirectionalChannelInfo_new(uint32_t last_update_arg, bool enabled_arg, uint16_t cltv_expiry_delta_arg, uint64_t htlc_minimum_msat_arg, struct LDKCOption_u64Z htlc_maximum_msat_arg, struct LDKRoutingFees fees_arg, struct LDKChannelUpdate last_update_message_arg);
+	export function DirectionalChannelInfo_new(last_update_arg: number, enabled_arg: boolean, cltv_expiry_delta_arg: number, htlc_minimum_msat_arg: number, htlc_maximum_msat_arg: number, fees_arg: number, last_update_message_arg: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg, fees_arg, last_update_message_arg);
+		return nativeResponseValue;
+	}
 	// struct LDKDirectionalChannelInfo DirectionalChannelInfo_clone(const struct LDKDirectionalChannelInfo *NONNULL_PTR orig);
 	export function DirectionalChannelInfo_clone(orig: number): number {
 		if(!isWasmInitialized) {
@@ -11850,6 +12274,22 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelInfo_set_two_to_one(this_ptr, val);
 		// debug statements here
 	}
+	// struct LDKCOption_u64Z ChannelInfo_get_capacity_sats(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
+	export function ChannelInfo_get_capacity_sats(this_ptr: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelInfo_get_capacity_sats(this_ptr);
+		return nativeResponseValue;
+	}
+	// void ChannelInfo_set_capacity_sats(struct LDKChannelInfo *NONNULL_PTR this_ptr, struct LDKCOption_u64Z val);
+	export function ChannelInfo_set_capacity_sats(this_ptr: number, val: number): void {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelInfo_set_capacity_sats(this_ptr, val);
+		// debug statements here
+	}
 	// struct LDKChannelAnnouncement ChannelInfo_get_announcement_message(const struct LDKChannelInfo *NONNULL_PTR this_ptr);
 	export function ChannelInfo_get_announcement_message(this_ptr: number): number {
 		if(!isWasmInitialized) {
@@ -11866,6 +12306,14 @@ public static native long new_empty_slice_vec();
 		const nativeResponseValue = wasm.ChannelInfo_set_announcement_message(this_ptr, val);
 		// debug statements here
 	}
+	// MUST_USE_RES struct LDKChannelInfo ChannelInfo_new(struct LDKChannelFeatures features_arg, struct LDKPublicKey node_one_arg, struct LDKDirectionalChannelInfo one_to_two_arg, struct LDKPublicKey node_two_arg, struct LDKDirectionalChannelInfo two_to_one_arg, struct LDKCOption_u64Z capacity_sats_arg, struct LDKChannelAnnouncement announcement_message_arg);
+	export function ChannelInfo_new(features_arg: number, node_one_arg: Uint8Array, one_to_two_arg: number, node_two_arg: Uint8Array, two_to_one_arg: number, capacity_sats_arg: number, announcement_message_arg: number): number {
+		if(!isWasmInitialized) {
+			throw new Error("initializeWasm() must be awaited first!");
+		}
+		const nativeResponseValue = wasm.ChannelInfo_new(features_arg, encodeArray(node_one_arg), one_to_two_arg, encodeArray(node_two_arg), two_to_one_arg, capacity_sats_arg, announcement_message_arg);
+		return nativeResponseValue;
+	}
 	// struct LDKChannelInfo ChannelInfo_clone(const struct LDKChannelInfo *NONNULL_PTR orig);
 	export function ChannelInfo_clone(orig: number): number {
 		if(!isWasmInitialized) {