+ // struct LDKCResult_OutputSpendStatusDecodeErrorZ CResult_OutputSpendStatusDecodeErrorZ_clone(const struct LDKCResult_OutputSpendStatusDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_OutputSpendStatusDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutputSpendStatusDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_FilterZ COption_FilterZ_some(struct LDKFilter o);
+/* @internal */
+export function COption_FilterZ_some(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_FilterZ_some(o);
+ return nativeResponseValue;
+}
+ // struct LDKCOption_FilterZ COption_FilterZ_none(void);
+/* @internal */
+export function COption_FilterZ_none(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_FilterZ_none();
+ return nativeResponseValue;
+}
+ // void COption_FilterZ_free(struct LDKCOption_FilterZ _res);
+/* @internal */
+export function COption_FilterZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_COption_FilterZ_free(_res);
+ // debug statements here
+}
+ // void CVec_TrackedSpendableOutputZ_free(struct LDKCVec_TrackedSpendableOutputZ _res);
+/* @internal */
+export function CVec_TrackedSpendableOutputZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_TrackedSpendableOutputZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_OutputSweeperDecodeErrorZ CResult_OutputSweeperDecodeErrorZ_ok(struct LDKOutputSweeper o);
+/* @internal */
+export function CResult_OutputSweeperDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutputSweeperDecodeErrorZ CResult_OutputSweeperDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_OutputSweeperDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_OutputSweeperDecodeErrorZ_is_ok(const struct LDKCResult_OutputSweeperDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_OutputSweeperDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_OutputSweeperDecodeErrorZ_free(struct LDKCResult_OutputSweeperDecodeErrorZ _res);
+/* @internal */
+export function CResult_OutputSweeperDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_OutputSweeperDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // struct LDKC2Tuple_BestBlockOutputSweeperZ C2Tuple_BestBlockOutputSweeperZ_new(struct LDKBestBlock a, struct LDKOutputSweeper b);
+/* @internal */
+export function C2Tuple_BestBlockOutputSweeperZ_new(a: bigint, b: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_BestBlockOutputSweeperZ_free(struct LDKC2Tuple_BestBlockOutputSweeperZ _res);
+/* @internal */
+export function C2Tuple_BestBlockOutputSweeperZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(struct LDKC2Tuple_BestBlockOutputSweeperZ o);
+/* @internal */
+export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(const struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ _res);
+/* @internal */
+export function CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_ok(struct LDKDelayedPaymentBasepoint o);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_DelayedPaymentBasepointDecodeErrorZ_free(struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ _res);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ CResult_DelayedPaymentBasepointDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentBasepointDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentBasepointDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_ok(struct LDKDelayedPaymentKey o);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_DelayedPaymentKeyDecodeErrorZ_free(struct LDKCResult_DelayedPaymentKeyDecodeErrorZ _res);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_DelayedPaymentKeyDecodeErrorZ CResult_DelayedPaymentKeyDecodeErrorZ_clone(const struct LDKCResult_DelayedPaymentKeyDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_DelayedPaymentKeyDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_ok(struct LDKHtlcBasepoint o);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_HtlcBasepointDecodeErrorZ_is_ok(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_HtlcBasepointDecodeErrorZ_free(struct LDKCResult_HtlcBasepointDecodeErrorZ _res);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_HtlcBasepointDecodeErrorZ_clone_ptr(LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcBasepointDecodeErrorZ CResult_HtlcBasepointDecodeErrorZ_clone(const struct LDKCResult_HtlcBasepointDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_HtlcBasepointDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcBasepointDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_ok(struct LDKHtlcKey o);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_HtlcKeyDecodeErrorZ_is_ok(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_HtlcKeyDecodeErrorZ_free(struct LDKCResult_HtlcKeyDecodeErrorZ _res);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_HtlcKeyDecodeErrorZ_clone_ptr(LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HtlcKeyDecodeErrorZ CResult_HtlcKeyDecodeErrorZ_clone(const struct LDKCResult_HtlcKeyDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_HtlcKeyDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_HtlcKeyDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_ok(struct LDKRevocationBasepoint o);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RevocationBasepointDecodeErrorZ_is_ok(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RevocationBasepointDecodeErrorZ_free(struct LDKCResult_RevocationBasepointDecodeErrorZ _res);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RevocationBasepointDecodeErrorZ_clone_ptr(LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationBasepointDecodeErrorZ CResult_RevocationBasepointDecodeErrorZ_clone(const struct LDKCResult_RevocationBasepointDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RevocationBasepointDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationBasepointDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_ok(struct LDKRevocationKey o);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_err(struct LDKDecodeError e);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_err(e: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_err(e);
+ return nativeResponseValue;
+}
+ // bool CResult_RevocationKeyDecodeErrorZ_is_ok(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_RevocationKeyDecodeErrorZ_free(struct LDKCResult_RevocationKeyDecodeErrorZ _res);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_free(_res);
+ // debug statements here
+}
+ // uint64_t CResult_RevocationKeyDecodeErrorZ_clone_ptr(LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR arg);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_RevocationKeyDecodeErrorZ CResult_RevocationKeyDecodeErrorZ_clone(const struct LDKCResult_RevocationKeyDecodeErrorZ *NONNULL_PTR orig);
+/* @internal */
+export function CResult_RevocationKeyDecodeErrorZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_RevocationKeyDecodeErrorZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_ok(struct LDKLockedChannelMonitor o);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_ok(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_ok(o);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_LockedChannelMonitorNoneZ CResult_LockedChannelMonitorNoneZ_err(void);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_err(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_err();
+ return nativeResponseValue;
+}
+ // bool CResult_LockedChannelMonitorNoneZ_is_ok(const struct LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR o);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_is_ok(o: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_is_ok(o);
+ return nativeResponseValue;
+}
+ // void CResult_LockedChannelMonitorNoneZ_free(struct LDKCResult_LockedChannelMonitorNoneZ _res);
+/* @internal */
+export function CResult_LockedChannelMonitorNoneZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CResult_LockedChannelMonitorNoneZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_OutPointChannelIdZ_clone_ptr(LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_OutPointChannelIdZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_OutPointChannelIdZ C2Tuple_OutPointChannelIdZ_clone(const struct LDKC2Tuple_OutPointChannelIdZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_OutPointChannelIdZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_OutPointChannelIdZ C2Tuple_OutPointChannelIdZ_new(struct LDKOutPoint a, struct LDKChannelId b);
+/* @internal */
+export function C2Tuple_OutPointChannelIdZ_new(a: bigint, b: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_OutPointChannelIdZ_free(struct LDKC2Tuple_OutPointChannelIdZ _res);
+/* @internal */
+export function C2Tuple_OutPointChannelIdZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointChannelIdZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_OutPointChannelIdZZ_free(struct LDKCVec_C2Tuple_OutPointChannelIdZZ _res);
+/* @internal */
+export function CVec_C2Tuple_OutPointChannelIdZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointChannelIdZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_MonitorUpdateIdZ_free(struct LDKCVec_MonitorUpdateIdZ _res);
+/* @internal */
+export function CVec_MonitorUpdateIdZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_MonitorUpdateIdZ_free(_res);
+ // debug statements here
+}
+ // uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(const struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR orig);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(struct LDKOutPoint a, struct LDKCVec_MonitorUpdateIdZ b);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a: bigint, b: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a, b);
+ return nativeResponseValue;
+}
+ // void C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(struct LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res);
+/* @internal */
+export function C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res);
+ // debug statements here
+}
+ // void CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(struct LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res);
+/* @internal */
+export function CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res);
+ // debug statements here
+}
+ // void APIError_free(struct LDKAPIError this_ptr);
+/* @internal */
+export function APIError_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg);
+/* @internal */
+export function APIError_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_clone(const struct LDKAPIError *NONNULL_PTR orig);
+/* @internal */
+export function APIError_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_apimisuse_error(struct LDKStr err);
+/* @internal */
+export function APIError_apimisuse_error(err: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_apimisuse_error(err);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_fee_rate_too_high(struct LDKStr err, uint32_t feerate);
+/* @internal */
+export function APIError_fee_rate_too_high(err: number, feerate: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_fee_rate_too_high(err, feerate);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_invalid_route(struct LDKStr err);
+/* @internal */
+export function APIError_invalid_route(err: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_invalid_route(err);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_channel_unavailable(struct LDKStr err);
+/* @internal */
+export function APIError_channel_unavailable(err: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_channel_unavailable(err);
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_monitor_update_in_progress(void);
+/* @internal */
+export function APIError_monitor_update_in_progress(): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_monitor_update_in_progress();
+ return nativeResponseValue;
+}
+ // struct LDKAPIError APIError_incompatible_shutdown_script(struct LDKShutdownScript script);
+/* @internal */
+export function APIError_incompatible_shutdown_script(script: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_incompatible_shutdown_script(script);
+ return nativeResponseValue;
+}
+ // bool APIError_eq(const struct LDKAPIError *NONNULL_PTR a, const struct LDKAPIError *NONNULL_PTR b);
+/* @internal */
+export function APIError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z APIError_write(const struct LDKAPIError *NONNULL_PTR obj);
+/* @internal */
+export function APIError_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_COption_APIErrorZDecodeErrorZ APIError_read(struct LDKu8slice ser);
+/* @internal */
+export function APIError_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_APIError_read(ser);
+ return nativeResponseValue;
+}
+ // void BigSize_free(struct LDKBigSize this_obj);
+/* @internal */
+export function BigSize_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_free(this_obj);
+ // debug statements here
+}
+ // uint64_t BigSize_get_a(const struct LDKBigSize *NONNULL_PTR this_ptr);
+/* @internal */
+export function BigSize_get_a(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void BigSize_set_a(struct LDKBigSize *NONNULL_PTR this_ptr, uint64_t val);
+/* @internal */
+export function BigSize_set_a(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKBigSize BigSize_new(uint64_t a_arg);
+/* @internal */
+export function BigSize_new(a_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg);
+/* @internal */
+export function BigSize_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKBigSize BigSize_clone(const struct LDKBigSize *NONNULL_PTR orig);
+/* @internal */
+export function BigSize_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t BigSize_hash(const struct LDKBigSize *NONNULL_PTR o);
+/* @internal */
+export function BigSize_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_hash(o);
+ return nativeResponseValue;
+}
+ // bool BigSize_eq(const struct LDKBigSize *NONNULL_PTR a, const struct LDKBigSize *NONNULL_PTR b);
+/* @internal */
+export function BigSize_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z BigSize_write(const struct LDKBigSize *NONNULL_PTR obj);
+/* @internal */
+export function BigSize_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_BigSizeDecodeErrorZ BigSize_read(struct LDKu8slice ser);
+/* @internal */
+export function BigSize_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_BigSize_read(ser);
+ return nativeResponseValue;
+}
+ // void Hostname_free(struct LDKHostname this_obj);
+/* @internal */
+export function Hostname_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_free(this_obj);
+ // debug statements here
+}
+ // uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg);
+/* @internal */
+export function Hostname_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKHostname Hostname_clone(const struct LDKHostname *NONNULL_PTR orig);
+/* @internal */
+export function Hostname_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t Hostname_hash(const struct LDKHostname *NONNULL_PTR o);
+/* @internal */
+export function Hostname_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_hash(o);
+ return nativeResponseValue;
+}
+ // bool Hostname_eq(const struct LDKHostname *NONNULL_PTR a, const struct LDKHostname *NONNULL_PTR b);
+/* @internal */
+export function Hostname_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES uint8_t Hostname_len(const struct LDKHostname *NONNULL_PTR this_arg);
+/* @internal */
+export function Hostname_len(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_len(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKStr Hostname_to_str(const struct LDKHostname *NONNULL_PTR o);
+/* @internal */
+export function Hostname_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_to_str(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z Hostname_write(const struct LDKHostname *NONNULL_PTR obj);
+/* @internal */
+export function Hostname_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_HostnameDecodeErrorZ Hostname_read(struct LDKu8slice ser);
+/* @internal */
+export function Hostname_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Hostname_read(ser);
+ return nativeResponseValue;
+}
+ // void TransactionU16LenLimited_free(struct LDKTransactionU16LenLimited this_obj);
+/* @internal */
+export function TransactionU16LenLimited_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_free(this_obj);
+ // debug statements here
+}
+ // uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg);
+/* @internal */
+export function TransactionU16LenLimited_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKTransactionU16LenLimited TransactionU16LenLimited_clone(const struct LDKTransactionU16LenLimited *NONNULL_PTR orig);
+/* @internal */
+export function TransactionU16LenLimited_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_clone(orig);
+ return nativeResponseValue;
+}
+ // uint64_t TransactionU16LenLimited_hash(const struct LDKTransactionU16LenLimited *NONNULL_PTR o);
+/* @internal */
+export function TransactionU16LenLimited_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_hash(o);
+ return nativeResponseValue;
+}
+ // bool TransactionU16LenLimited_eq(const struct LDKTransactionU16LenLimited *NONNULL_PTR a, const struct LDKTransactionU16LenLimited *NONNULL_PTR b);
+/* @internal */
+export function TransactionU16LenLimited_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_TransactionU16LenLimitedNoneZ TransactionU16LenLimited_new(struct LDKTransaction transaction);
+/* @internal */
+export function TransactionU16LenLimited_new(transaction: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_new(transaction);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_into_transaction(struct LDKTransactionU16LenLimited this_arg);
+/* @internal */
+export function TransactionU16LenLimited_into_transaction(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_into_transaction(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKTransaction TransactionU16LenLimited_as_transaction(const struct LDKTransactionU16LenLimited *NONNULL_PTR this_arg);
+/* @internal */
+export function TransactionU16LenLimited_as_transaction(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_as_transaction(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z TransactionU16LenLimited_write(const struct LDKTransactionU16LenLimited *NONNULL_PTR obj);
+/* @internal */
+export function TransactionU16LenLimited_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_TransactionU16LenLimitedDecodeErrorZ TransactionU16LenLimited_read(struct LDKu8slice ser);
+/* @internal */
+export function TransactionU16LenLimited_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TransactionU16LenLimited_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_StrSecp256k1ErrorZ sign(struct LDKu8slice msg, const uint8_t (*sk)[32]);
+/* @internal */
+export function sign(msg: number, sk: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_sign(msg, sk);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_PublicKeySecp256k1ErrorZ recover_pk(struct LDKu8slice msg, struct LDKStr sig);
+/* @internal */
+export function recover_pk(msg: number, sig: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_recover_pk(msg, sig);
+ return nativeResponseValue;
+}
+ // bool verify(struct LDKu8slice msg, struct LDKStr sig, struct LDKPublicKey pk);
+/* @internal */
+export function verify(msg: number, sig: number, pk: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_verify(msg, sig, pk);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z construct_invoice_preimage(struct LDKu8slice hrp_bytes, struct LDKCVec_U5Z data_without_signature);
+/* @internal */
+export function construct_invoice_preimage(hrp_bytes: number, data_without_signature: number): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_construct_invoice_preimage(hrp_bytes, data_without_signature);
+ return nativeResponseValue;
+}
+ // void KVStore_free(struct LDKKVStore this_ptr);
+/* @internal */
+export function KVStore_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_KVStore_free(this_ptr);
+ // debug statements here
+}
+ // void Persister_free(struct LDKPersister this_ptr);
+/* @internal */
+export function Persister_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Persister_free(this_ptr);
+ // debug statements here
+}
+ // struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ read_channel_monitors(struct LDKKVStore kv_store, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
+/* @internal */
+export function read_channel_monitors(kv_store: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_read_channel_monitors(kv_store, entropy_source, signer_provider);
+ return nativeResponseValue;
+}
+ // void MonitorUpdatingPersister_free(struct LDKMonitorUpdatingPersister this_obj);
+/* @internal */
+export function MonitorUpdatingPersister_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKMonitorUpdatingPersister MonitorUpdatingPersister_new(struct LDKKVStore kv_store, struct LDKLogger logger, uint64_t maximum_pending_updates, struct LDKEntropySource entropy_source, struct LDKSignerProvider signer_provider);
+/* @internal */
+export function MonitorUpdatingPersister_new(kv_store: bigint, logger: bigint, maximum_pending_updates: bigint, entropy_source: bigint, signer_provider: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_new(kv_store, logger, maximum_pending_updates, entropy_source, signer_provider);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ MonitorUpdatingPersister_read_all_channel_monitors_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator);
+/* @internal */
+export function MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(this_arg, broadcaster, fee_estimator);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ MonitorUpdatingPersister_read_channel_monitor_with_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, const struct LDKBroadcasterInterface *NONNULL_PTR broadcaster, const struct LDKFeeEstimator *NONNULL_PTR fee_estimator, struct LDKStr monitor_key);
+/* @internal */
+export function MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg: bigint, broadcaster: bigint, fee_estimator: bigint, monitor_key: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(this_arg, broadcaster, fee_estimator, monitor_key);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneIOErrorZ MonitorUpdatingPersister_cleanup_stale_updates(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg, bool lazy);
+/* @internal */
+export function MonitorUpdatingPersister_cleanup_stale_updates(this_arg: bigint, lazy: boolean): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_cleanup_stale_updates(this_arg, lazy);
+ return nativeResponseValue;
+}
+ // struct LDKPersist MonitorUpdatingPersister_as_Persist(const struct LDKMonitorUpdatingPersister *NONNULL_PTR this_arg);
+/* @internal */
+export function MonitorUpdatingPersister_as_Persist(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_MonitorUpdatingPersister_as_Persist(this_arg);
+ return nativeResponseValue;
+}
+ // enum LDKShortChannelIdError ShortChannelIdError_clone(const enum LDKShortChannelIdError *NONNULL_PTR orig);
+/* @internal */
+export function ShortChannelIdError_clone(orig: bigint): ShortChannelIdError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShortChannelIdError_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKShortChannelIdError ShortChannelIdError_block_overflow(void);
+/* @internal */
+export function ShortChannelIdError_block_overflow(): ShortChannelIdError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShortChannelIdError_block_overflow();
+ return nativeResponseValue;
+}
+ // enum LDKShortChannelIdError ShortChannelIdError_tx_index_overflow(void);
+/* @internal */
+export function ShortChannelIdError_tx_index_overflow(): ShortChannelIdError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShortChannelIdError_tx_index_overflow();
+ return nativeResponseValue;
+}
+ // enum LDKShortChannelIdError ShortChannelIdError_vout_index_overflow(void);
+/* @internal */
+export function ShortChannelIdError_vout_index_overflow(): ShortChannelIdError {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShortChannelIdError_vout_index_overflow();
+ return nativeResponseValue;
+}
+ // bool ShortChannelIdError_eq(const enum LDKShortChannelIdError *NONNULL_PTR a, const enum LDKShortChannelIdError *NONNULL_PTR b);
+/* @internal */
+export function ShortChannelIdError_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_ShortChannelIdError_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint32_t block_from_scid(uint64_t short_channel_id);
+/* @internal */
+export function block_from_scid(short_channel_id: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_block_from_scid(short_channel_id);
+ return nativeResponseValue;
+}
+ // uint32_t tx_index_from_scid(uint64_t short_channel_id);
+/* @internal */
+export function tx_index_from_scid(short_channel_id: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_tx_index_from_scid(short_channel_id);
+ return nativeResponseValue;
+}
+ // uint16_t vout_from_scid(uint64_t short_channel_id);
+/* @internal */
+export function vout_from_scid(short_channel_id: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_vout_from_scid(short_channel_id);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_u64ShortChannelIdErrorZ scid_from_parts(uint64_t block, uint64_t tx_index, uint64_t vout_index);
+/* @internal */
+export function scid_from_parts(block: bigint, tx_index: bigint, vout_index: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_scid_from_parts(block, tx_index, vout_index);
+ return nativeResponseValue;
+}
+ // void UntrustedString_free(struct LDKUntrustedString this_obj);
+/* @internal */
+export function UntrustedString_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_free(this_obj);
+ // debug statements here
+}
+ // struct LDKStr UntrustedString_get_a(const struct LDKUntrustedString *NONNULL_PTR this_ptr);
+/* @internal */
+export function UntrustedString_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void UntrustedString_set_a(struct LDKUntrustedString *NONNULL_PTR this_ptr, struct LDKStr val);
+/* @internal */
+export function UntrustedString_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKUntrustedString UntrustedString_new(struct LDKStr a_arg);
+/* @internal */
+export function UntrustedString_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_new(a_arg);
+ return nativeResponseValue;
+}
+ // uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg);
+/* @internal */
+export function UntrustedString_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKUntrustedString UntrustedString_clone(const struct LDKUntrustedString *NONNULL_PTR orig);
+/* @internal */
+export function UntrustedString_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_clone(orig);
+ return nativeResponseValue;
+}
+ // bool UntrustedString_eq(const struct LDKUntrustedString *NONNULL_PTR a, const struct LDKUntrustedString *NONNULL_PTR b);
+/* @internal */
+export function UntrustedString_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t UntrustedString_hash(const struct LDKUntrustedString *NONNULL_PTR o);
+/* @internal */
+export function UntrustedString_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z UntrustedString_write(const struct LDKUntrustedString *NONNULL_PTR obj);
+/* @internal */
+export function UntrustedString_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_UntrustedStringDecodeErrorZ UntrustedString_read(struct LDKu8slice ser);
+/* @internal */
+export function UntrustedString_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_read(ser);
+ return nativeResponseValue;
+}
+ // struct LDKStr UntrustedString_to_str(const struct LDKUntrustedString *NONNULL_PTR o);
+/* @internal */
+export function UntrustedString_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_UntrustedString_to_str(o);
+ return nativeResponseValue;
+}
+ // void PrintableString_free(struct LDKPrintableString this_obj);
+/* @internal */
+export function PrintableString_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrintableString_free(this_obj);
+ // debug statements here
+}
+ // struct LDKStr PrintableString_get_a(const struct LDKPrintableString *NONNULL_PTR this_ptr);
+/* @internal */
+export function PrintableString_get_a(this_ptr: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrintableString_get_a(this_ptr);
+ return nativeResponseValue;
+}
+ // void PrintableString_set_a(struct LDKPrintableString *NONNULL_PTR this_ptr, struct LDKStr val);
+/* @internal */
+export function PrintableString_set_a(this_ptr: bigint, val: number): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrintableString_set_a(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKPrintableString PrintableString_new(struct LDKStr a_arg);
+/* @internal */
+export function PrintableString_new(a_arg: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrintableString_new(a_arg);
+ return nativeResponseValue;
+}
+ // struct LDKStr PrintableString_to_str(const struct LDKPrintableString *NONNULL_PTR o);
+/* @internal */
+export function PrintableString_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_PrintableString_to_str(o);
+ return nativeResponseValue;
+}
+ // void TrackedSpendableOutput_free(struct LDKTrackedSpendableOutput this_obj);
+/* @internal */
+export function TrackedSpendableOutput_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_free(this_obj);
+ // debug statements here
+}
+ // struct LDKSpendableOutputDescriptor TrackedSpendableOutput_get_descriptor(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
+/* @internal */
+export function TrackedSpendableOutput_get_descriptor(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_descriptor(this_ptr);
+ return nativeResponseValue;
+}
+ // void TrackedSpendableOutput_set_descriptor(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKSpendableOutputDescriptor val);
+/* @internal */
+export function TrackedSpendableOutput_set_descriptor(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_descriptor(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKChannelId TrackedSpendableOutput_get_channel_id(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
+/* @internal */
+export function TrackedSpendableOutput_get_channel_id(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_channel_id(this_ptr);
+ return nativeResponseValue;
+}
+ // void TrackedSpendableOutput_set_channel_id(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKChannelId val);
+/* @internal */
+export function TrackedSpendableOutput_set_channel_id(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_channel_id(this_ptr, val);
+ // debug statements here
+}
+ // struct LDKOutputSpendStatus TrackedSpendableOutput_get_status(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr);
+/* @internal */
+export function TrackedSpendableOutput_get_status(this_ptr: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_get_status(this_ptr);
+ return nativeResponseValue;
+}
+ // void TrackedSpendableOutput_set_status(struct LDKTrackedSpendableOutput *NONNULL_PTR this_ptr, struct LDKOutputSpendStatus val);
+/* @internal */
+export function TrackedSpendableOutput_set_status(this_ptr: bigint, val: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_set_status(this_ptr, val);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKTrackedSpendableOutput TrackedSpendableOutput_new(struct LDKSpendableOutputDescriptor descriptor_arg, struct LDKChannelId channel_id_arg, struct LDKOutputSpendStatus status_arg);
+/* @internal */
+export function TrackedSpendableOutput_new(descriptor_arg: bigint, channel_id_arg: bigint, status_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_new(descriptor_arg, channel_id_arg, status_arg);
+ return nativeResponseValue;
+}
+ // uint64_t TrackedSpendableOutput_clone_ptr(LDKTrackedSpendableOutput *NONNULL_PTR arg);
+/* @internal */
+export function TrackedSpendableOutput_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKTrackedSpendableOutput TrackedSpendableOutput_clone(const struct LDKTrackedSpendableOutput *NONNULL_PTR orig);
+/* @internal */
+export function TrackedSpendableOutput_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_clone(orig);
+ return nativeResponseValue;
+}
+ // bool TrackedSpendableOutput_eq(const struct LDKTrackedSpendableOutput *NONNULL_PTR a, const struct LDKTrackedSpendableOutput *NONNULL_PTR b);
+/* @internal */
+export function TrackedSpendableOutput_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_eq(a, b);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES bool TrackedSpendableOutput_is_spent_in(const struct LDKTrackedSpendableOutput *NONNULL_PTR this_arg, struct LDKTransaction tx);
+/* @internal */
+export function TrackedSpendableOutput_is_spent_in(this_arg: bigint, tx: number): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_is_spent_in(this_arg, tx);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z TrackedSpendableOutput_write(const struct LDKTrackedSpendableOutput *NONNULL_PTR obj);
+/* @internal */
+export function TrackedSpendableOutput_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_TrackedSpendableOutputDecodeErrorZ TrackedSpendableOutput_read(struct LDKu8slice ser);
+/* @internal */
+export function TrackedSpendableOutput_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_TrackedSpendableOutput_read(ser);
+ return nativeResponseValue;
+}
+ // void OutputSpendStatus_free(struct LDKOutputSpendStatus this_ptr);
+/* @internal */
+export function OutputSpendStatus_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t OutputSpendStatus_clone_ptr(LDKOutputSpendStatus *NONNULL_PTR arg);
+/* @internal */
+export function OutputSpendStatus_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKOutputSpendStatus OutputSpendStatus_clone(const struct LDKOutputSpendStatus *NONNULL_PTR orig);
+/* @internal */
+export function OutputSpendStatus_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKOutputSpendStatus OutputSpendStatus_pending_initial_broadcast(struct LDKCOption_u32Z delayed_until_height);
+/* @internal */
+export function OutputSpendStatus_pending_initial_broadcast(delayed_until_height: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_initial_broadcast(delayed_until_height);
+ return nativeResponseValue;
+}
+ // struct LDKOutputSpendStatus OutputSpendStatus_pending_first_confirmation(struct LDKThirtyTwoBytes first_broadcast_hash, uint32_t latest_broadcast_height, struct LDKTransaction latest_spending_tx);
+/* @internal */
+export function OutputSpendStatus_pending_first_confirmation(first_broadcast_hash: number, latest_broadcast_height: number, latest_spending_tx: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_first_confirmation(first_broadcast_hash, latest_broadcast_height, latest_spending_tx);
+ return nativeResponseValue;
+}
+ // struct LDKOutputSpendStatus OutputSpendStatus_pending_threshold_confirmations(struct LDKThirtyTwoBytes first_broadcast_hash, uint32_t latest_broadcast_height, struct LDKTransaction latest_spending_tx, uint32_t confirmation_height, struct LDKThirtyTwoBytes confirmation_hash);
+/* @internal */
+export function OutputSpendStatus_pending_threshold_confirmations(first_broadcast_hash: number, latest_broadcast_height: number, latest_spending_tx: number, confirmation_height: number, confirmation_hash: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_pending_threshold_confirmations(first_broadcast_hash, latest_broadcast_height, latest_spending_tx, confirmation_height, confirmation_hash);
+ return nativeResponseValue;
+}
+ // bool OutputSpendStatus_eq(const struct LDKOutputSpendStatus *NONNULL_PTR a, const struct LDKOutputSpendStatus *NONNULL_PTR b);
+/* @internal */
+export function OutputSpendStatus_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_eq(a, b);
+ return nativeResponseValue;
+}
+ // struct LDKCVec_u8Z OutputSpendStatus_write(const struct LDKOutputSpendStatus *NONNULL_PTR obj);
+/* @internal */
+export function OutputSpendStatus_write(obj: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_write(obj);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutputSpendStatusDecodeErrorZ OutputSpendStatus_read(struct LDKu8slice ser);
+/* @internal */
+export function OutputSpendStatus_read(ser: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSpendStatus_read(ser);
+ return nativeResponseValue;
+}
+ // void OutputSweeper_free(struct LDKOutputSweeper this_obj);
+/* @internal */
+export function OutputSweeper_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_free(this_obj);
+ // debug statements here
+}
+ // MUST_USE_RES struct LDKOutputSweeper OutputSweeper_new(struct LDKBestBlock best_block, struct LDKBroadcasterInterface broadcaster, struct LDKFeeEstimator fee_estimator, struct LDKCOption_FilterZ chain_data_source, struct LDKOutputSpender output_spender, struct LDKChangeDestinationSource change_destination_source, struct LDKKVStore kv_store, struct LDKLogger logger);
+/* @internal */
+export function OutputSweeper_new(best_block: bigint, broadcaster: bigint, fee_estimator: bigint, chain_data_source: bigint, output_spender: bigint, change_destination_source: bigint, kv_store: bigint, logger: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_new(best_block, broadcaster, fee_estimator, chain_data_source, output_spender, change_destination_source, kv_store, logger);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCResult_NoneNoneZ OutputSweeper_track_spendable_outputs(const struct LDKOutputSweeper *NONNULL_PTR this_arg, struct LDKCVec_SpendableOutputDescriptorZ output_descriptors, struct LDKChannelId channel_id, bool exclude_static_outputs, struct LDKCOption_u32Z delay_until_height);
+/* @internal */
+export function OutputSweeper_track_spendable_outputs(this_arg: bigint, output_descriptors: number, channel_id: bigint, exclude_static_outputs: boolean, delay_until_height: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_track_spendable_outputs(this_arg, output_descriptors, channel_id, exclude_static_outputs, delay_until_height);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKCVec_TrackedSpendableOutputZ OutputSweeper_tracked_spendable_outputs(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
+/* @internal */
+export function OutputSweeper_tracked_spendable_outputs(this_arg: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_tracked_spendable_outputs(this_arg);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES struct LDKBestBlock OutputSweeper_current_best_block(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
+/* @internal */
+export function OutputSweeper_current_best_block(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_current_best_block(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKListen OutputSweeper_as_Listen(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
+/* @internal */
+export function OutputSweeper_as_Listen(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_as_Listen(this_arg);
+ return nativeResponseValue;
+}
+ // struct LDKConfirm OutputSweeper_as_Confirm(const struct LDKOutputSweeper *NONNULL_PTR this_arg);
+/* @internal */
+export function OutputSweeper_as_Confirm(this_arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_as_Confirm(this_arg);
+ return nativeResponseValue;
+}
+ // void SpendingDelay_free(struct LDKSpendingDelay this_ptr);
+/* @internal */
+export function SpendingDelay_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SpendingDelay_free(this_ptr);
+ // debug statements here
+}
+ // uint64_t SpendingDelay_clone_ptr(LDKSpendingDelay *NONNULL_PTR arg);
+/* @internal */
+export function SpendingDelay_clone_ptr(arg: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SpendingDelay_clone_ptr(arg);
+ return nativeResponseValue;
+}
+ // struct LDKSpendingDelay SpendingDelay_clone(const struct LDKSpendingDelay *NONNULL_PTR orig);
+/* @internal */
+export function SpendingDelay_clone(orig: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SpendingDelay_clone(orig);
+ return nativeResponseValue;
+}
+ // struct LDKSpendingDelay SpendingDelay_relative(uint32_t num_blocks);
+/* @internal */
+export function SpendingDelay_relative(num_blocks: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SpendingDelay_relative(num_blocks);
+ return nativeResponseValue;
+}
+ // struct LDKSpendingDelay SpendingDelay_absolute(uint32_t height);
+/* @internal */
+export function SpendingDelay_absolute(height: number): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_SpendingDelay_absolute(height);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_OutputSweeperDecodeErrorZ OutputSweeper_read(struct LDKu8slice ser, struct LDKBroadcasterInterface arg_a, struct LDKFeeEstimator arg_b, struct LDKCOption_FilterZ arg_c, struct LDKOutputSpender arg_d, struct LDKChangeDestinationSource arg_e, struct LDKKVStore arg_f, struct LDKLogger arg_g);
+/* @internal */
+export function OutputSweeper_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint, arg_d: bigint, arg_e: bigint, arg_f: bigint, arg_g: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_OutputSweeper_read(ser, arg_a, arg_b, arg_c, arg_d, arg_e, arg_f, arg_g);
+ return nativeResponseValue;
+}
+ // struct LDKCResult_C2Tuple_BestBlockOutputSweeperZDecodeErrorZ C2Tuple_BestBlockOutputSweeperZ_read(struct LDKu8slice ser, struct LDKBroadcasterInterface arg_a, struct LDKFeeEstimator arg_b, struct LDKCOption_FilterZ arg_c, struct LDKOutputSpender arg_d, struct LDKChangeDestinationSource arg_e, struct LDKKVStore arg_f, struct LDKLogger arg_g);
+/* @internal */
+export function C2Tuple_BestBlockOutputSweeperZ_read(ser: number, arg_a: bigint, arg_b: bigint, arg_c: bigint, arg_d: bigint, arg_e: bigint, arg_f: bigint, arg_g: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_C2Tuple_BestBlockOutputSweeperZ_read(ser, arg_a, arg_b, arg_c, arg_d, arg_e, arg_f, arg_g);
+ return nativeResponseValue;
+}
+ // void FutureCallback_free(struct LDKFutureCallback this_ptr);
+/* @internal */
+export function FutureCallback_free(this_ptr: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_FutureCallback_free(this_ptr);
+ // debug statements here
+}
+ // void Future_free(struct LDKFuture this_obj);
+/* @internal */
+export function Future_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Future_free(this_obj);
+ // debug statements here
+}
+ // void Future_register_callback_fn(const struct LDKFuture *NONNULL_PTR this_arg, struct LDKFutureCallback callback);
+/* @internal */
+export function Future_register_callback_fn(this_arg: bigint, callback: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Future_register_callback_fn(this_arg, callback);
+ // debug statements here
+}
+ // enum LDKLevel Level_clone(const enum LDKLevel *NONNULL_PTR orig);
+/* @internal */
+export function Level_clone(orig: bigint): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_clone(orig);
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_gossip(void);
+/* @internal */
+export function Level_gossip(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_gossip();
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_trace(void);
+/* @internal */
+export function Level_trace(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_trace();
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_debug(void);
+/* @internal */
+export function Level_debug(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_debug();
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_info(void);
+/* @internal */
+export function Level_info(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_info();
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_warn(void);
+/* @internal */
+export function Level_warn(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_warn();
+ return nativeResponseValue;
+}
+ // enum LDKLevel Level_error(void);
+/* @internal */
+export function Level_error(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_error();
+ return nativeResponseValue;
+}
+ // bool Level_eq(const enum LDKLevel *NONNULL_PTR a, const enum LDKLevel *NONNULL_PTR b);
+/* @internal */
+export function Level_eq(a: bigint, b: bigint): boolean {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_eq(a, b);
+ return nativeResponseValue;
+}
+ // uint64_t Level_hash(const enum LDKLevel *NONNULL_PTR o);
+/* @internal */
+export function Level_hash(o: bigint): bigint {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_hash(o);
+ return nativeResponseValue;
+}
+ // struct LDKStr Level_to_str(const enum LDKLevel *NONNULL_PTR o);
+/* @internal */
+export function Level_to_str(o: bigint): number {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_to_str(o);
+ return nativeResponseValue;
+}
+ // MUST_USE_RES enum LDKLevel Level_max(void);
+/* @internal */
+export function Level_max(): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Level_max();
+ return nativeResponseValue;
+}
+ // void Record_free(struct LDKRecord this_obj);
+/* @internal */
+export function Record_free(this_obj: bigint): void {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Record_free(this_obj);
+ // debug statements here
+}
+ // enum LDKLevel Record_get_level(const struct LDKRecord *NONNULL_PTR this_ptr);
+/* @internal */
+export function Record_get_level(this_ptr: bigint): Level {
+ if(!isWasmInitialized) {
+ throw new Error("initializeWasm() must be awaited first!");
+ }
+ const nativeResponseValue = wasm.TS_Record_get_level(this_ptr);
+ return nativeResponseValue;
+}
+ // void Record_set_level(struct LDKRecord *NONNULL_PTR this_ptr, enum LDKLevel val);