+}
+ // void BlindedRoute_free(struct LDKBlindedRoute this_obj);
+/* @internal */
+export function BlindedRoute_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedRoute_free(this_obj);
+ // debug statements here
+}
+ // void BlindedHop_free(struct LDKBlindedHop this_obj);
+/* @internal */
+export function BlindedHop_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedHop_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKCResult_BlindedRouteNoneZ BlindedRoute_new(struct LDKCVec_PublicKeyZ node_pks, const struct LDKKeysInterface *NONNULL_PTR keys_manager);
+/* @internal */
+export function BlindedRoute_new(node_pks: number, keys_manager: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedRoute_new(node_pks, keys_manager);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z BlindedRoute_write(const struct LDKBlindedRoute *NONNULL_PTR obj);
+/* @internal */
+export function BlindedRoute_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedRoute_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedRouteDecodeErrorZ BlindedRoute_read(struct LDKu8slice ser);
+/* @internal */
+export function BlindedRoute_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedRoute_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z BlindedHop_write(const struct LDKBlindedHop *NONNULL_PTR obj);
+/* @internal */
+export function BlindedHop_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedHop_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BlindedHopDecodeErrorZ BlindedHop_read(struct LDKu8slice ser);
+/* @internal */
+export function BlindedHop_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BlindedHop_read(ser);
+ return nativeResponseValue;
+}
+ // void OnionMessenger_free(struct LDKOnionMessenger this_obj);
+/* @internal */
+export function OnionMessenger_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessenger_free(this_obj);
+ // debug statements here
+}
+ // void Destination_free(struct LDKDestination this_ptr);
+/* @internal */
+export function Destination_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Destination_free(this_ptr);
+ // debug statements here
+}
+ // struct LDKDestination Destination_node(struct LDKPublicKey a);
+/* @internal */
+export function Destination_node(a: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Destination_node(a);
+ return nativeResponseValue;
+}
+ // struct LDKDestination Destination_blinded_route(struct LDKBlindedRoute a);
+/* @internal */
+export function Destination_blinded_route(a: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Destination_blinded_route(a);
+ return nativeResponseValue;
+}
+ // void SendError_free(struct LDKSendError this_ptr);
+/* @internal */
+export function SendError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg);
+/* @internal */
+export function SendError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_clone(const struct LDKSendError *NONNULL_PTR orig);
+/* @internal */
+export function SendError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_secp256k1(enum LDKSecp256k1Error a);
+/* @internal */
+export function SendError_secp256k1(a: Secp256k1Error): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_secp256k1(a);
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_too_big_packet(void);
+/* @internal */
+export function SendError_too_big_packet(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_too_big_packet();
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_too_few_blinded_hops(void);
+/* @internal */
+export function SendError_too_few_blinded_hops(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_too_few_blinded_hops();
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_invalid_first_hop(void);
+/* @internal */
+export function SendError_invalid_first_hop(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_invalid_first_hop();
+ return nativeResponseValue;
+}
+ // struct LDKSendError SendError_buffer_full(void);
+/* @internal */
+export function SendError_buffer_full(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SendError_buffer_full();
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKOnionMessenger OnionMessenger_new(struct LDKKeysInterface keys_manager, struct LDKLogger logger);
+/* @internal */
+export function OnionMessenger_new(keys_manager: bigint, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessenger_new(keys_manager, logger);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneSendErrorZ OnionMessenger_send_onion_message(const struct LDKOnionMessenger *NONNULL_PTR this_arg, struct LDKCVec_PublicKeyZ intermediate_nodes, struct LDKDestination destination, struct LDKBlindedRoute reply_path);
+/* @internal */
+export function OnionMessenger_send_onion_message(this_arg: bigint, intermediate_nodes: number, destination: bigint, reply_path: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessenger_send_onion_message(this_arg, intermediate_nodes, destination, reply_path);
+ return nativeResponseValue;
+}
+ // struct LDKOnionMessageHandler OnionMessenger_as_OnionMessageHandler(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
+/* @internal */
+export function OnionMessenger_as_OnionMessageHandler(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageHandler(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKOnionMessageProvider OnionMessenger_as_OnionMessageProvider(const struct LDKOnionMessenger *NONNULL_PTR this_arg);
+/* @internal */
+export function OnionMessenger_as_OnionMessageProvider(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OnionMessenger_as_OnionMessageProvider(this_arg);
+ return nativeResponseValue;